MCLinker upstream commit 9628cfb76b5a.
Change-Id: I6d12c63bdae94299558dc1cf42b489bb98748851
diff --git a/include/mcld/CodeGen/SectLinker.h b/include/mcld/CodeGen/SectLinker.h
index b31b968..4ed2907 100644
--- a/include/mcld/CodeGen/SectLinker.h
+++ b/include/mcld/CodeGen/SectLinker.h
@@ -43,7 +43,7 @@
* - provide an interface for target-specific SectLinekr
* - set up environment for MCLDDriver
* - control AsmPrinter, make sure AsmPrinter has already prepared
-* all MCSectionDatas for linking
+* all SectionDatas for linking
*
* SectLinker resolves the absolue paths of input arguments.
*
diff --git a/include/mcld/Config/Config.h b/include/mcld/Config/Config.h
index a6ce28a..ea92259 100644
--- a/include/mcld/Config/Config.h
+++ b/include/mcld/Config/Config.h
@@ -23,7 +23,7 @@
# define MCLD_ON_WIN32 1
#endif
-#define MCLD_VERSION "LionHead - 1.3.18"
+#define MCLD_VERSION "Phoenix - 1.4.0"
#endif
diff --git a/include/mcld/LD/AlignFragment.h b/include/mcld/LD/AlignFragment.h
new file mode 100644
index 0000000..4c5582c
--- /dev/null
+++ b/include/mcld/LD/AlignFragment.h
@@ -0,0 +1,69 @@
+//===- AlignFragment.h ----------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_LD_ALIGNFRAGMENT_H
+#define MCLD_LD_ALIGNFRAGMENT_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/LD/Fragment.h>
+
+namespace mcld
+{
+
+class SectionData;
+
+class AlignFragment : public Fragment
+{
+public:
+ AlignFragment(unsigned int pAlignment, int64_t pValue, unsigned int pValueSize,
+ unsigned int pMaxBytesToEmit, SectionData *pSD = NULL);
+
+ unsigned int getAlignment() const { return m_Alignment; }
+
+ int64_t getValue() const { return m_Value; }
+
+ unsigned int getValueSize() const { return m_ValueSize; }
+
+ unsigned int getMaxBytesToEmit() const { return m_MaxBytesToEmit; }
+
+ bool hasEmitNops() const { return m_bEmitNops; }
+
+ void setEmitNops(bool pValue) { m_bEmitNops = pValue; }
+
+ static bool classof(const Fragment *F) {
+ return F->getKind() == Fragment::Alignment;
+ }
+ static bool classof(const AlignFragment *) { return true; }
+
+private:
+ /// Alignment - The alignment to ensure, in bytes.
+ unsigned int m_Alignment;
+
+ /// Value - Value to use for filling padding bytes.
+ int64_t m_Value;
+
+ /// ValueSize - The size of the integer (in bytes) of \arg Value.
+ unsigned int m_ValueSize;
+
+ /// MaxBytesToEmit - The maximum number of bytes to emit; if the alignment
+ /// cannot be satisfied in this width then this fragment is ignored.
+ unsigned int m_MaxBytesToEmit;
+
+ /// EmitNops - Flag to indicate that (optimal) NOPs should be emitted instead
+ /// of using the provided value. The exact interpretation of this flag is
+ /// target dependent.
+ bool m_bEmitNops : 1;
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/Archive.h b/include/mcld/LD/Archive.h
new file mode 100644
index 0000000..12b574c
--- /dev/null
+++ b/include/mcld/LD/Archive.h
@@ -0,0 +1,243 @@
+//===- Archive.h ----------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_ARCHIVE_H
+#define MCLD_ARCHIVE_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/ADT/HashEntry.h>
+#include <mcld/ADT/HashTable.h>
+#include <mcld/ADT/StringHash.h>
+#include <mcld/Support/GCFactory.h>
+#include <mcld/MC/InputTree.h>
+
+#include <vector>
+#include <string>
+
+namespace mcld
+{
+class InputTree;
+class Input;
+
+/** \class Archive
+ * \brief This class define the interfacee to Archive files
+ */
+class Archive
+{
+public:
+ static const char MAGIC[]; ///< magic string
+ static const char THIN_MAGIC[]; ///< magic of thin archive
+ static const size_t MAGIC_LEN; ///< length of magic string
+ static const char SVR4_SYMTAB_NAME[]; ///< SVR4 symtab entry name
+ static const char STRTAB_NAME[]; ///< Name of string table
+ static const char PAD[]; ///< inter-file align padding
+ static const char MEMBER_MAGIC[]; ///< fmag field magic #
+
+ struct MemberHeader
+ {
+ char name[16]; ///< Name of the file member.
+ char date[12]; ///< File date, decimal seconds since Epoch
+ char uid[6]; ///< user id in ASCII decimal
+ char gid[6]; ///< group id in ASCII decimal
+ char mode[8]; ///< file mode in ASCII octal
+ char size[10]; ///< file size in ASCII decimal
+ char fmag[2]; ///< Always contains ARFILE_MAGIC_TERMINATOR
+ };
+
+private:
+ template<typename OFFSET_TYPE>
+ struct OffsetCompare
+ {
+ bool operator()(OFFSET_TYPE X, OFFSET_TYPE Y) const
+ { return (X == Y); }
+ };
+
+ struct MurmurHash3
+ {
+ size_t operator()(uint32_t pKey) const
+ {
+ size_t h;
+ h ^= h >> 16;
+ h *= 0x85ebca6b;
+ h ^= h >> 13;
+ h *= 0xc2b2ae35;
+ h ^= h >> 16;
+ return h;
+ }
+ };
+
+ typedef HashEntry<uint32_t,
+ InputTree::iterator,
+ OffsetCompare<uint32_t> > ObjectMemberEntryType;
+public:
+ typedef HashTable<ObjectMemberEntryType,
+ MurmurHash3,
+ EntryFactory<ObjectMemberEntryType> > ObjectMemberMapType;
+
+ struct ArchiveMember
+ {
+ Input* file;
+ InputTree::iterator lastPos;
+ InputTree::Mover* move;
+ };
+
+private:
+ typedef HashEntry<const llvm::StringRef,
+ ArchiveMember,
+ StringCompare<llvm::StringRef> > ArchiveMemberEntryType;
+
+public:
+ typedef HashTable<ArchiveMemberEntryType,
+ StringHash<ELF>,
+ EntryFactory<ArchiveMemberEntryType> > ArchiveMemberMapType;
+
+ struct Symbol
+ {
+ public:
+ enum Status
+ {
+ Include,
+ Exclude,
+ Unknown
+ };
+
+ Symbol(const char* pName,
+ uint32_t pOffset,
+ enum Status pStatus)
+ : name(pName), fileOffset(pOffset), status(pStatus)
+ {}
+
+ ~Symbol()
+ {}
+
+ public:
+ std::string name;
+ uint32_t fileOffset;
+ enum Status status;
+ };
+
+ typedef std::vector<Symbol*> SymTabType;
+
+public:
+ Archive(Input& pInputFile, InputFactory& pInputFactory);
+
+ ~Archive();
+
+ /// getARFile - get the Input& of the archive file
+ Input& getARFile();
+
+ /// getARFile - get the Input& of the archive file
+ const Input& getARFile() const;
+
+ /// inputs - get the input tree built from this archive
+ InputTree& inputs();
+
+ /// inputs - get the input tree built from this archive
+ const InputTree& inputs() const;
+
+ /// getObjectMemberMap - get the map that contains the included object files
+ ObjectMemberMapType& getObjectMemberMap();
+
+ /// getObjectMemberMap - get the map that contains the included object files
+ const ObjectMemberMapType& getObjectMemberMap() const;
+
+ /// numOfObjectMember - return the number of included object files
+ size_t numOfObjectMember() const;
+
+ /// addObjectMember - add a object in the object member map
+ /// @param pFileOffset - file offset in symtab represents a object file
+ /// @param pIter - the iterator in the input tree built from this archive
+ bool addObjectMember(uint32_t pFileOffset, InputTree::iterator pIter);
+
+ /// hasObjectMember - check if a object file is included or not
+ /// @param pFileOffset - file offset in symtab represents a object file
+ bool hasObjectMember(uint32_t pFileOffset) const;
+
+ /// getArchiveMemberMap - get the map that contains the included archive files
+ ArchiveMemberMapType& getArchiveMemberMap();
+
+ /// getArchiveMemberMap - get the map that contains the included archive files
+ const ArchiveMemberMapType& getArchiveMemberMap() const;
+
+ /// addArchiveMember - add an archive in the archive member map
+ /// @param pName - the name of the new archive member
+ /// @param pLastPos - this records the point to insert the next node in the
+ /// subtree of this archive member
+ /// @param pMove - this records the direction to insert the next node in
+ /// the subtree of this archive member
+ bool addArchiveMember(const llvm::StringRef& pName,
+ InputTree::iterator pLastPos,
+ InputTree::Mover* pMove);
+
+ /// hasArchiveMember - check if an archive file is included or not
+ bool hasArchiveMember(const llvm::StringRef& pName) const;
+
+ /// getArchiveMember - get a archive member
+ ArchiveMember* getArchiveMember(const llvm::StringRef& pName);
+
+ /// getSymbolTable - get the symtab
+ SymTabType& getSymbolTable();
+
+ /// getSymbolTable - get the symtab
+ const SymTabType& getSymbolTable() const;
+
+ /// setSymTabSize - set the memory size of symtab
+ void setSymTabSize(size_t pSize);
+
+ /// getSymTabSize - get the memory size of symtab
+ size_t getSymTabSize() const;
+
+ /// numOfSymbols - return the number of symbols in symtab
+ size_t numOfSymbols() const;
+
+ /// addSymbol - add a symtab entry to symtab
+ /// @param pName - symbol name
+ /// @param pFileOffset - file offset in symtab represents a object file
+ void
+ addSymbol(const char* pName,
+ uint32_t pFileOffset,
+ enum Symbol::Status pStatus = Archive::Symbol::Unknown);
+
+ /// getSymbolName - get the symbol name with the given index
+ const std::string& getSymbolName(size_t pSymIdx) const;
+
+ /// getObjFileOffset - get the file offset that represent a object file
+ uint32_t getObjFileOffset(size_t pSymIdx) const;
+
+ /// getSymbolStatus - get the status of a symbol
+ enum Symbol::Status getSymbolStatus(size_t pSymIdx) const;
+
+ /// setSymbolStatus - set the status of a symbol
+ void setSymbolStatus(size_t pSymIdx, enum Symbol::Status pStatus);
+
+ /// getStrTable - get the extended name table
+ std::string& getStrTable();
+
+ /// getStrTable - get the extended name table
+ const std::string& getStrTable() const;
+
+private:
+ typedef GCFactory<Symbol, 0> SymbolFactory;
+
+private:
+ Input& m_ArchiveFile;
+ InputTree *m_pInputTree;
+ ObjectMemberMapType m_ObjectMemberMap;
+ ArchiveMemberMapType m_ArchiveMemberMap;
+ SymbolFactory m_SymbolFactory;
+ SymTabType m_SymTab;
+ size_t m_SymTabSize;
+ std::string m_StrTab;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/ArchiveReader.h b/include/mcld/LD/ArchiveReader.h
index 7d0aa58..5f24f49 100644
--- a/include/mcld/LD/ArchiveReader.h
+++ b/include/mcld/LD/ArchiveReader.h
@@ -11,13 +11,12 @@
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
-#include "mcld/LD/LDReader.h"
+#include <mcld/LD/LDReader.h>
namespace mcld
{
-class Input;
-class InputTree;
+class Archive;
/** \class ArchiveReader
* \brief ArchiveReader provides an common interface for all archive readers.
@@ -31,23 +30,11 @@
class ArchiveReader : public LDReader
{
-protected:
- struct ArchiveMemberHeader
- {
- char name[16];
- char date[12];
- char uid[6];
- char gid[6];
- char mode[8];
- char size[10];
- char finalMagic[2];
- };
-
public:
ArchiveReader();
virtual ~ArchiveReader();
- virtual InputTree *readArchive(Input &input) = 0;
+ virtual bool readArchive(Archive& pArchive) = 0;
};
} // namespace of mcld
diff --git a/include/mcld/LD/BSDArchiveReader.h b/include/mcld/LD/BSDArchiveReader.h
index a275621..7abeecc 100644
--- a/include/mcld/LD/BSDArchiveReader.h
+++ b/include/mcld/LD/BSDArchiveReader.h
@@ -11,13 +11,13 @@
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
-#include "mcld/LD/ArchiveReader.h"
+#include <mcld/LD/ArchiveReader.h>
namespace mcld
{
class Input;
-class InputTree;
+class Archive;
/** \class BSDArchiveReader
* \brief BSDArchiveReader reads BSD-variant archive files.
@@ -29,7 +29,7 @@
BSDArchiveReader();
~BSDArchiveReader();
- InputTree *readArchive(Input &input);
+ bool readArchive(Archive& pArchive);
bool isMyFormat(Input& pInput) const;
};
diff --git a/include/mcld/LD/CIE.h b/include/mcld/LD/CIE.h
index 15e1d69..23dfa22 100644
--- a/include/mcld/LD/CIE.h
+++ b/include/mcld/LD/CIE.h
@@ -13,7 +13,7 @@
#endif
#include <llvm/Support/DataTypes.h>
-#include <mcld/MC/MCRegionFragment.h>
+#include <mcld/LD/RegionFragment.h>
namespace mcld
{
@@ -22,7 +22,7 @@
* \brief Common Information Entry.
* The CIE structure refers to LSB Core Spec 4.1, chap.10.6. Exception Frames.
*/
-class CIE : public MCRegionFragment
+class CIE : public RegionFragment
{
public:
explicit CIE(MemoryRegion& pRegion, uint8_t pFDEEncode);
diff --git a/include/mcld/LD/DiagCommonKinds.inc b/include/mcld/LD/DiagCommonKinds.inc
index ac3d0e1..835e1d4 100644
--- a/include/mcld/LD/DiagCommonKinds.inc
+++ b/include/mcld/LD/DiagCommonKinds.inc
@@ -3,7 +3,7 @@
DIAG(warn_cannot_open_search_dir, DiagnosticEngine::Warning, "can not open search directory `-L%0'", "can not open search directory `-L%0'")
DIAG(err_no_inputs, DiagnosticEngine::Error, "no inputs", "no inputs")
DIAG(err_empty_input, DiagnosticEngine::Error, "Empty input file `%0' : %1", "Empty input file `%0' : %1")
-DIAG(err_unrecognized_input_file, DiagnosticEngine::Fatal, "cannot recognize the format of file `%0'.\n object format or given target machine (%1) is wrong.","cannot recognize the format of file `%0'.\n object format or given target machine (%1) is wrong.")
+DIAG(err_unrecognized_input_file, DiagnosticEngine::Fatal, "cannot recognize the format of file `%0'.\n object format or given target machine (%1) is wrong.","cannot recognize the format of file `%0'.\n object format or given target machine (%1) is wrong.")
DIAG(err_cannot_find_namespec, DiagnosticEngine::Fatal, "cannot recognize namespec -l%0", "cannot recognize namespec -l%0")
DIAG(err_cannot_identify_option, DiagnosticEngine::Fatal, "unknown command line argument `%0' at %1", "unknown command line argument `%0' at %1")
DIAG(err_mixed_shared_static_objects, DiagnosticEngine::Error, "cannot link shared objects with -static option.\nShared object `%0': %1", "cannot link shared objects with -static option.\nShared object `%0': %1")
@@ -35,8 +35,7 @@
DIAG(warn_illegal_input_section, DiagnosticEngine::Warning, "section `%0' should not appear in input file `%1': %2", "section `%0' should not appear in input file `%1': %2")
DIAG(err_cannot_trace_file, DiagnosticEngine::Unreachable, "cannot identify the type (%0) of input file `%1'.\n %2", "cannot identify the type (%0) of input file `%1'.\n %2")
DIAG(err_out_of_range_region, DiagnosticEngine::Unreachable, "requested memory region [%0, %1] is out of range.", "requested memory region [%0, %1] is out of range.")
-DIAG(debug_eh_unsupport, DiagnosticEngine::Debug, "unsupported eh_frame: %0", "unsupported eh_frame: %0")
-DIAG(note_ehframe, DiagnosticEngine::Note, "eh_frame: %0", "eh_frame: %0")
+DIAG(debug_eh_unsupport, DiagnosticEngine::Debug, "unsupported .eh_frame section in input: %0", "unsupported .eh_frame section in input: %0")
DIAG(note_eh_cie, DiagnosticEngine::Note, "CIE length: %0, aug_string: %1, fde_encodeing: %2", "CIE length: %0, aug_string: %1, fde_encodeing: %2")
DIAG(note_eh_fde, DiagnosticEngine::Note, "FDE length: %0, offset of PC Begin: %1", "FDE length: %0, offset of PC Begin: %1")
DIAG(fatal_cannot_init_target, DiagnosticEngine::Fatal, "Cannot initialize mcld::Target for given triple '%0'.\n(Detail: %1)", "Cannot initialize mcld::Target for given triple '%0'.\n(Detail: %1)")
diff --git a/include/mcld/LD/DiagGOTPLT.inc b/include/mcld/LD/DiagGOTPLT.inc
index f0d3d2c..172bceb 100644
--- a/include/mcld/LD/DiagGOTPLT.inc
+++ b/include/mcld/LD/DiagGOTPLT.inc
@@ -1,3 +1,5 @@
DIAG(mips_got_symbol, DiagnosticEngine::Unreachable, "%0 is not a dynamic symbol, do not put it in global got", "%0 is not a dynamic symbol, do not put it in global got")
-DIAG(fail_allocate_memory, DiagnosticEngine::Fatal, "fial to allocate memory for %0", "fial to allocate memory for %0")
-DIAG(reserve_entry_number_mismatch, DiagnosticEngine::Unreachable, "The number of reserved entries for %0 is inconsist", "The number of reserved entries for %0 is inconsist")
+DIAG(fail_allocate_memory_got, DiagnosticEngine::Fatal, "fial to allocate memory for GOT", "fial to allocate memory for GOT")
+DIAG(fail_allocate_memory_plt, DiagnosticEngine::Fatal, "fial to allocate memory for PLT", "fial to allocate memory for PLT")
+DIAG(reserve_entry_number_mismatch_got, DiagnosticEngine::Unreachable, "The number of reserved entries for GOT is inconsist", "The number of reserved entries for GOT is inconsist")
+DIAG(reserve_entry_number_mismatch_plt, DiagnosticEngine::Unreachable, "The number of reserved entries for PLT is inconsist", "The number of reserved entries for PLT is inconsist")
diff --git a/include/mcld/LD/ELFReader.h b/include/mcld/LD/ELFReader.h
index a247804..f893be5 100644
--- a/include/mcld/LD/ELFReader.h
+++ b/include/mcld/LD/ELFReader.h
@@ -15,11 +15,14 @@
#include <llvm/ADT/StringRef.h>
#include <llvm/Support/ELF.h>
#include <llvm/Support/Host.h>
-#include <llvm/MC/MCAssembler.h>
+
#include <mcld/MC/MCLDInfo.h>
#include <mcld/MC/MCLDInput.h>
#include <mcld/MC/MCLinker.h>
-#include <mcld/MC/MCRegionFragment.h>
+#include <mcld/LD/Fragment.h>
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/AlignFragment.h>
+#include <mcld/LD/RegionFragment.h>
#include <mcld/LD/ResolveInfo.h>
#include <mcld/LD/LDContext.h>
#include <mcld/Target/GNULDBackend.h>
@@ -124,6 +127,8 @@
protected:
LDFileFormat::Kind getLDSectionKind(uint32_t pType, const char* pName) const;
+ ResolveInfo::Type getSymType(uint8_t pInfo, uint16_t pShndx) const;
+
ResolveInfo::Desc getSymDesc(uint16_t pShndx, const Input& pInput) const;
ResolveInfo::Binding getSymBinding(uint8_t pBinding,
@@ -134,10 +139,10 @@
uint16_t pShndx,
const Input& pInput) const;
- MCFragmentRef* getSymFragmentRef(Input& pInput,
- MCLinker& pLinker,
- uint16_t pShndx,
- uint32_t pOffset) const;
+ FragmentRef* getSymFragmentRef(Input& pInput,
+ MCLinker& pLinker,
+ uint16_t pShndx,
+ uint32_t pOffset) const;
ResolveInfo::Visibility getSymVisibility(uint8_t pVis) const;
diff --git a/include/mcld/LD/ELFReader.tcc b/include/mcld/LD/ELFReader.tcc
index 4f5c036..7c3f6d4 100644
--- a/include/mcld/LD/ELFReader.tcc
+++ b/include/mcld/LD/ELFReader.tcc
@@ -223,16 +223,16 @@
MemoryRegion* region = pInput.memArea()->request(
pInput.fileOffset() + pInputSectHdr.offset(), pInputSectHdr.size());
- llvm::MCSectionData& sect_data = pLinker.getOrCreateSectData(pInputSectHdr);
+ SectionData& sect_data = pLinker.getOrCreateSectData(pInputSectHdr);
- llvm::MCFragment* frag = NULL;
+ Fragment* frag = NULL;
if (NULL == region) {
// If the input section's size is zero, we got a NULL region.
// use a virtual fill fragment
- frag = new llvm::MCFillFragment(0x0, 0, 0);
+ frag = new FillFragment(0x0, 0, 0);
}
else
- frag = new MCRegionFragment(*region);
+ frag = new RegionFragment(*region);
uint64_t size = pLinker.getLayout().appendFragment(*frag,
sect_data,
@@ -297,7 +297,7 @@
}
// get ld_type
- ResolveInfo::Type ld_type = static_cast<ResolveInfo::Type>(st_info & 0xF);
+ ResolveInfo::Type ld_type = getSymType(st_info, st_shndx);
// get ld_desc
ResolveInfo::Desc ld_desc = getSymDesc(st_shndx, pInput);
@@ -309,10 +309,10 @@
uint64_t ld_value = getSymValue(st_value, st_shndx, pInput);
// get the input fragment
- MCFragmentRef* ld_frag_ref = getSymFragmentRef(pInput,
- pLinker,
- st_shndx,
- ld_value);
+ FragmentRef* ld_frag_ref = getSymFragmentRef(pInput,
+ pLinker,
+ st_shndx,
+ ld_value);
// get ld_vis
ResolveInfo::Visibility ld_vis = getSymVisibility(st_other);
@@ -381,7 +381,6 @@
reinterpret_cast<llvm::ELF::Elf32_Sym*>(symbol_region->start());
uint32_t st_name = 0x0;
- uint32_t st_value = 0x0;
uint32_t st_size = 0x0;
uint8_t st_info = 0x0;
uint8_t st_other = 0x0;
@@ -390,13 +389,11 @@
st_other = entry->st_other;
if (llvm::sys::isLittleEndianHost()) {
st_name = entry->st_name;
- st_value = entry->st_value;
st_size = entry->st_size;
st_shndx = entry->st_shndx;
}
else {
st_name = bswap32(entry->st_name);
- st_value = bswap32(entry->st_value);
st_size = bswap32(entry->st_size);
st_shndx = bswap16(entry->st_shndx);
}
@@ -470,7 +467,7 @@
ResolveInfo* resolve_info = symbol->resolveInfo();
- MCFragmentRef* frag_ref =
+ FragmentRef* frag_ref =
pLinker.getLayout().getFragmentRef(*pSection.getLink(), r_offset);
if (NULL == frag_ref) {
@@ -518,7 +515,7 @@
ResolveInfo* resolve_info = symbol->resolveInfo();
- MCFragmentRef* frag_ref =
+ FragmentRef* frag_ref =
pLinker.getLayout().getFragmentRef(*pSection.getLink(), r_offset);
if (NULL == frag_ref) {
diff --git a/include/mcld/LD/ELFSectionMap.h b/include/mcld/LD/ELFSectionMap.h
new file mode 100644
index 0000000..e832fa9
--- /dev/null
+++ b/include/mcld/LD/ELFSectionMap.h
@@ -0,0 +1,30 @@
+//===- ELFSectionMap.h ----------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_LD_ELF_SECTION_MAP_H
+#define MCLD_LD_ELF_SECTION_MAP_H
+
+#include <mcld/LD/SectionMap.h>
+
+namespace mcld
+{
+
+class ELFSectionMap : public SectionMap
+{
+public:
+ ELFSectionMap();
+
+ ~ELFSectionMap();
+
+ void initStandardMaps();
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/ELFWriter.h b/include/mcld/LD/ELFWriter.h
index 34a6483..3a73605 100644
--- a/include/mcld/LD/ELFWriter.h
+++ b/include/mcld/LD/ELFWriter.h
@@ -15,10 +15,6 @@
#include <llvm/Support/ELF.h>
#include <mcld/MC/MCLDOutput.h>
-namespace llvm {
-class MCSectionData;
-}
-
namespace mcld
{
@@ -27,6 +23,7 @@
class GNULDBackend;
class Relocation;
class LDSection;
+class SectionData;
/** \class ELFWriter
* \brief ELFWriter provides basic functions to write ELF sections, symbols,
@@ -93,12 +90,12 @@
void emitRel(const Layout& pLayout,
const Output& pOutput,
- const llvm::MCSectionData& pSectionData,
+ const SectionData& pSectionData,
MemoryRegion& pRegion) const;
void emitRela(const Layout& pLayout,
const Output& pOutput,
- const llvm::MCSectionData& pSectionData,
+ const SectionData& pSectionData,
MemoryRegion& pRegion) const;
private:
diff --git a/include/mcld/LD/EhFrame.h b/include/mcld/LD/EhFrame.h
index c303240..9497d79 100644
--- a/include/mcld/LD/EhFrame.h
+++ b/include/mcld/LD/EhFrame.h
@@ -16,20 +16,22 @@
#include <mcld/ADT/TypeTraits.h>
#include <mcld/LD/CIE.h>
#include <mcld/LD/FDE.h>
-#include <mcld/MC/MCRegionFragment.h>
+#include <mcld/LD/RegionFragment.h>
#include <mcld/Support/GCFactory.h>
namespace mcld
{
+
+class Input;
+class Layout;
+class SectionData;
+class TargetLDBackend;
+
/** \class EhFrame
* \brief EhFrame represents .eh_frame section
* EhFrame is responsible to parse the input eh_frame sections and create
* the corresponding CIE and FDE entries.
*/
-
-class TargetLDBackend;
-class Input;
-
class EhFrame
{
public:
@@ -47,14 +49,14 @@
/// readEhFrame - read an .eh_frame section and create the corresponding
/// CIEs and FDEs
- /// @param pSD - the MCSectionData of this input eh_frame
+ /// @param pSD - the SectionData of this input eh_frame
/// @param pSection - the input eh_frame
/// @param pArea - the memory area which pSection is within.
/// @ return - size of this eh_frame section, 0 if we do not recognize
/// this eh_frame or this is an empty section
uint64_t readEhFrame(Layout& pLayout,
const TargetLDBackend& pBackend,
- llvm::MCSectionData& pSD,
+ SectionData& pSD,
const Input& pInput,
LDSection& pSection,
MemoryArea& pArea);
@@ -102,7 +104,7 @@
{ return m_fCanRecognizeAll; }
private:
- typedef std::vector<llvm::MCFragment*> FragListType;
+ typedef std::vector<Fragment*> FragListType;
private:
/// addCIE - parse and create a CIE entry
@@ -126,7 +128,7 @@
/// @ref - GNU gold 1.11, ehframe.h, Eh_frame::skip_leb128.
bool skipLEB128(ConstAddress* pp, ConstAddress pend);
- /// deleteFragments - release the MemoryRegion and delete MCFragments in pList
+ /// deleteFragments - release the MemoryRegion and delete Fragments in pList
void deleteFragments(FragListType& pList, MemoryArea& pArea);
private:
diff --git a/include/mcld/LD/FDE.h b/include/mcld/LD/FDE.h
index bd52e78..760a584 100644
--- a/include/mcld/LD/FDE.h
+++ b/include/mcld/LD/FDE.h
@@ -6,15 +6,15 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef MCLD_FRAME_DESCRIPTION_ENTRY_H
-#define MCLD_FRAME_DESCRIPTION_ENTRY_H
+#ifndef MCLD_LD_FRAME_DESCRIPTION_ENTRY_H
+#define MCLD_LD_FRAME_DESCRIPTION_ENTRY_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
#include <llvm/Support/DataTypes.h>
#include <mcld/LD/CIE.h>
-#include <mcld/MC/MCRegionFragment.h>
+#include <mcld/LD/RegionFragment.h>
namespace mcld
{
@@ -23,8 +23,7 @@
* \brief Frame Description Entry
* The FDE structure refers to LSB Core Spec 4.1, chap.10.6. Exception Frames.
*/
-
-class FDE : public MCRegionFragment
+class FDE : public RegionFragment
{
public:
typedef uint32_t Offset;
diff --git a/include/mcld/LD/FillFragment.h b/include/mcld/LD/FillFragment.h
new file mode 100644
index 0000000..db29111
--- /dev/null
+++ b/include/mcld/LD/FillFragment.h
@@ -0,0 +1,56 @@
+//===- FillFragment.h -----------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_LD_FILLFRAGMENT_H
+#define MCLD_LD_FILLFRAGMENT_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <llvm/Support/DataTypes.h>
+
+#include <mcld/LD/Fragment.h>
+
+namespace mcld
+{
+
+class SectionData;
+
+class FillFragment : public Fragment
+{
+public:
+ FillFragment(int64_t pValue, unsigned int pValueSize, uint64_t pSize,
+ SectionData* pSD = NULL);
+
+ int64_t getValue() const { return m_Value; }
+
+ unsigned getValueSize() const { return m_ValueSize; }
+
+ uint64_t getSize() const { return m_Size; }
+
+ static bool classof(const Fragment *F)
+ { return F->getKind() == Fragment::Fillment; }
+
+ static bool classof(const FillFragment *) { return true; }
+
+private:
+ /// m_Value - Value used for filling bytes
+ int64_t m_Value;
+
+ /// m_ValueSize - The size (in bytes) of \arg Value to use when filling, or 0
+ /// if this is a virtual fill fragment.
+ unsigned int m_ValueSize;
+
+ /// m_Size - The number of bytes to insert.
+ uint64_t m_Size;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/Fragment.h b/include/mcld/LD/Fragment.h
new file mode 100644
index 0000000..1baa8df
--- /dev/null
+++ b/include/mcld/LD/Fragment.h
@@ -0,0 +1,78 @@
+//===- Fragment.h ---------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_FRAGMENT_H
+#define MCLD_FRAGMENT_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <llvm/ADT/ilist_node.h>
+#include <llvm/Support/DataTypes.h>
+
+#include <cstddef>
+
+namespace mcld
+{
+
+class SectionData;
+
+/** \class Fragment
+ * \brief Fragment is the minimun linking unit of MCLinker.
+ */
+class Fragment : public llvm::ilist_node<Fragment>
+{
+public:
+ enum Type {
+ Alignment,
+ Fillment,
+ Region,
+ Relocation,
+ Target
+ };
+
+public:
+ Fragment();
+
+ Fragment(Type pKind, SectionData *pParent = NULL);
+
+ virtual ~Fragment();
+
+ Type getKind() const { return m_Kind; }
+
+ SectionData *getParent() const { return m_pParent; }
+
+ void setParent(SectionData *pValue) { m_pParent = pValue; }
+
+ uint64_t getOffset() const { return m_Offset; }
+
+ void setOffset(uint64_t pOffset) { m_Offset = pOffset; }
+
+ unsigned int getLayoutOrder() const { return m_LayoutOrder; }
+
+ void setLayoutOrder(unsigned int pValue) { m_LayoutOrder = pValue; }
+
+ static bool classof(const Fragment *O) { return true; }
+
+private:
+ Fragment(const Fragment& ); // DO NOT IMPLEMENT
+ Fragment& operator=(const Fragment& ); // DO NOT IMPLEMENT
+
+private:
+ Type m_Kind;
+ SectionData* m_pParent;
+
+ uint64_t m_Offset;
+ unsigned int m_LayoutOrder;
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/FragmentRef.h b/include/mcld/LD/FragmentRef.h
new file mode 100644
index 0000000..20b94c2
--- /dev/null
+++ b/include/mcld/LD/FragmentRef.h
@@ -0,0 +1,86 @@
+//===- FragmentRef.h ------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_LD_FRAGMENT_REFERENCE_H
+#define MCLD_LD_FRAGMENT_REFERENCE_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/ADT/SizeTraits.h>
+#include <mcld/ADT/TypeTraits.h>
+#include <mcld/LD/Fragment.h>
+
+namespace mcld
+{
+
+class Layout;
+
+/// compunteFragmentSize - compute the specific Fragment size
+uint64_t computeFragmentSize(const Layout& pLayout,
+ const Fragment& pFrag);
+
+/** \class FragmentRef
+ * \brief FragmentRef is a reference of a Fragment's contetnt.
+ *
+ */
+class FragmentRef
+{
+public:
+ typedef uint64_t Offset; // FIXME: use SizeTraits<T>::Offset
+ typedef NonConstTraits<unsigned char>::pointer Address;
+ typedef ConstTraits<unsigned char>::pointer ConstAddress;
+
+public:
+ FragmentRef();
+ FragmentRef(Fragment& pFrag, Offset pOffset = 0);
+ ~FragmentRef();
+
+ // ----- modifiers ----- //
+ FragmentRef& assign(const FragmentRef& pCopy);
+
+ FragmentRef& assign(Fragment& pFrag, Offset pOffset = 0);
+
+ /// memcpy - copy memory
+ /// copy memory from the fragment to the pDesc.
+ /// @pDest - the destination address
+ /// @pNBytes - copies pNBytes from the fragment[offset()+pOffset]
+ /// @pOffset - additional offset.
+ /// the start address offset from fragment[offset()]
+ void memcpy(void* pDest, size_t pNBytes, Offset pOffset = 0) const;
+
+ // ----- observers ----- //
+ Fragment* frag()
+ { return m_pFragment; }
+
+ const Fragment* frag() const
+ { return m_pFragment; }
+
+ Offset offset() const
+ { return m_Offset; }
+
+ // ----- dereference ----- //
+ Address deref();
+
+ ConstAddress deref() const;
+
+ Address operator*()
+ { return deref(); }
+
+ ConstAddress operator*() const
+ { return deref(); }
+
+private:
+ Fragment* m_pFragment;
+ Offset m_Offset;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/GNUArchiveReader.h b/include/mcld/LD/GNUArchiveReader.h
index 92c7e7a..39a9438 100644
--- a/include/mcld/LD/GNUArchiveReader.h
+++ b/include/mcld/LD/GNUArchiveReader.h
@@ -12,81 +12,74 @@
#include <gtest.h>
#endif
-#include "mcld/LD/ArchiveReader.h"
-
-#include <vector>
-#include <string>
-
-namespace llvm
-{
-class MemoryBuffer;
-
-}
+#include <mcld/LD/ArchiveReader.h>
+#include <mcld/LD/Archive.h>
namespace mcld
{
-class MemoryArea;
+class MemoryAreaFactory;
class MCLDInfo;
class Input;
-class InputTree;
+class ELFObjectReader;
+class Archive;
/** \class GNUArchiveReader
* \brief GNUArchiveReader reads GNU archive files.
*/
class GNUArchiveReader : public ArchiveReader
{
-private:
- struct SymbolTableEntry;
-
- enum Constant
- {
- /// The length of the magic strign at the end of an archive member header.
- HeaderFinalMagicSize = 2,
- /// The length of the magic string at the start of an archive.
- ArchiveMagicSize = 8
- };
- /// The magic string at the start of an archive.
- static const char ArchiveMagic[ArchiveMagicSize];
- static const char ThinArchiveMagic[ArchiveMagicSize];
- /// The Magic string expected at the end of an archive member header.
- static const char HeaderFinalMagic[HeaderFinalMagicSize];
-
public:
- explicit GNUArchiveReader(MCLDInfo &pLDInfo)
- : m_pLDInfo(pLDInfo)
- { }
+ explicit GNUArchiveReader(MCLDInfo& pLDInfo,
+ MemoryAreaFactory& pMemAreaFactory,
+ ELFObjectReader& pELFObjectReader);
- ~GNUArchiveReader()
- { }
+ ~GNUArchiveReader();
- /// Read an archive and extract each member in.
- /// Construct the coresponding Input for each member.
- InputTree *readArchive(Input &input);
+ /// readArchive - read an archive, include the needed members, and build up
+ /// the subtree
+ bool readArchive(Archive& pArchive);
- bool isMyFormat(Input &input) const;
-
- LDReader::Endian endian(Input& pFile) const;
+ /// isMyFormat
+ bool isMyFormat(Input& input) const;
private:
- /// set up the archive, including
- /// first, read symbol table
- /// second, read extended file name which is used in thin archive
- InputTree *setupNewArchive(Input &pInput, size_t off);
+ /// isArchive
+ bool isArchive(const char* pStr) const;
- /// read the archive header, and return the member size
- size_t readMemberHeader(MemoryArea &pArea,
- off_t off,
- std::string *p_Name,
- off_t *nestedOff,
- std::string &p_ExtendedName);
+ /// isThinArchive
+ bool isThinArchive(const char* pStr) const;
- void readSymbolTable(MemoryArea &pArea,
- std::vector<SymbolTableEntry> &pSymbolTable,
- off_t start,
- size_t size);
+ /// isThinArchive
+ bool isThinArchive(Input& input) const;
+
+ /// readMemberHeader - read the header of a member in a archive file and then
+ /// return the corresponding archive member (it may be an input object or
+ /// another archive)
+ /// @param pArchiveRoot - the archive root that holds the strtab (extended
+ /// name table)
+ /// @param pArchiveFile - the archive that contains the needed object
+ /// @param pFileOffset - file offset of the member header in the archive
+ /// @param pNestedOffset - used when we find a nested archive
+ Input* readMemberHeader(Archive& pArchiveRoot,
+ Input& pArchiveFile,
+ uint32_t pFileOffset,
+ uint32_t& pNestedOffset);
+
+ /// readSymbolTable - read the archive symbol map (armap)
+ bool readSymbolTable(Archive& pArchive);
+
+ /// readStringTable - read the strtab for long file name of the archive
+ bool readStringTable(Archive& pArchive);
+
+ /// shouldIncludeSymbol - given a sym name from armap and check if we should
+ /// include the corresponding archive member, and then return the decision
+ enum Archive::Symbol::Status
+ shouldIncludeSymbol(const llvm::StringRef& pSymName) const;
private:
- MCLDInfo &m_pLDInfo;
+ MCLDInfo& m_LDInfo;
+ MemoryAreaFactory& m_MemAreaFactory;
+ ELFObjectReader& m_ELFObjectReader;
};
} // namespace of mcld
diff --git a/include/mcld/LD/LDSection.h b/include/mcld/LD/LDSection.h
index 4c793de..4c881ca 100644
--- a/include/mcld/LD/LDSection.h
+++ b/include/mcld/LD/LDSection.h
@@ -13,29 +13,20 @@
#include <gtest.h>
#endif
-#include <llvm/MC/MCSection.h>
-#include <llvm/MC/MCAssembler.h>
#include <llvm/ADT/StringRef.h>
#include <llvm/Support/DataTypes.h>
#include <mcld/LD/LDFileFormat.h>
#include <string>
-namespace llvm {
-
-class MCAsmInfo;
-class raw_ostream;
-
-} // namespace of llvm
-
namespace mcld {
+
+class SectionData;
+
/** \class LDSection
* \brief LDSection represents a section header entry. It is a unified
- * abstraction for various file formats.
- *
- * LDSection contains both the format-dependent data and LLVM specific data.
- *
+ * abstraction of a section header entry for various file formats.
*/
-class LDSection : public llvm::MCSection
+class LDSection
{
public:
LDSection(const std::string& pName,
@@ -85,7 +76,7 @@
/// virtual image.
/// Before layouting, output's LDSection::offset() should return zero.
/// ELF uses sh_addralign to set alignment constraints. In LLVM, alignment
- /// constraint is set in MCSectionData::setAlignment. addr() contains the
+ /// constraint is set in SectionData::setAlignment. addr() contains the
/// original ELF::sh_addr. Modulo sh_addr by sh_addralign is not necessary.
/// MachO uses the same scenario.
///
@@ -137,30 +128,13 @@
void setType(uint32_t type)
{ m_Type = type; }
- static bool classof(const MCSection *S)
- { return S->getVariant() == SV_LDContext; }
-
- static bool classof(const LDSection *)
- { return true; }
-
- // ----- methods for adapt to llvm::MCSection ----- //
- void PrintSwitchToSection(const llvm::MCAsmInfo &MAI,
- llvm::raw_ostream &OS) const
- { }
-
- bool UseCodeAlign() const
- { return true; }
-
- bool isVirtualSection() const
- { return false; }
-
- llvm::MCSectionData* getSectionData()
+ SectionData* getSectionData()
{ return m_pSectionData; }
- const llvm::MCSectionData* getSectionData() const
+ const SectionData* getSectionData() const
{ return m_pSectionData; }
- void setSectionData(llvm::MCSectionData* pSD)
+ void setSectionData(SectionData* pSD)
{ m_pSectionData = pSD; }
bool hasSectionData() const
@@ -191,8 +165,7 @@
size_t m_Info;
LDSection* m_pLink;
- // pointer to MCSectionData.
- llvm::MCSectionData* m_pSectionData;
+ SectionData* m_pSectionData;
// the index of the file
size_t m_Index;
diff --git a/include/mcld/LD/LDSectionFactory.h b/include/mcld/LD/LDSectionFactory.h
index 49b11c7..b748a64 100644
--- a/include/mcld/LD/LDSectionFactory.h
+++ b/include/mcld/LD/LDSectionFactory.h
@@ -11,10 +11,12 @@
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
+
+#include <string>
+
#include <mcld/Support/GCFactory.h>
#include <mcld/LD/LDSection.h>
#include <mcld/LD/LDFileFormat.h>
-#include <string>
namespace mcld
{
@@ -31,7 +33,7 @@
~LDSectionFactory();
/// produce - produce an empty section information.
- /// This function will create an empty MCSectionData and its LDSection.
+ /// This function will create an empty SectionData and its LDSection.
/// @param pName - The name of the section.
/// @param pKind - The kind of the section. Used to create default section map
/// @param pType - sh_type in ELF.
diff --git a/include/mcld/LD/LDSymbol.h b/include/mcld/LD/LDSymbol.h
index 45c0b75..99b3885 100644
--- a/include/mcld/LD/LDSymbol.h
+++ b/include/mcld/LD/LDSymbol.h
@@ -12,11 +12,11 @@
#include <gtest.h>
#endif
-#include "mcld/ADT/Uncopyable.h"
-#include "mcld/LD/ResolveInfo.h"
-#include "mcld/MC/MCFragmentRef.h"
-#include <llvm/MC/MCAssembler.h>
-#include <assert.h>
+#include <cassert>
+
+#include <mcld/ADT/Uncopyable.h>
+#include <mcld/LD/ResolveInfo.h>
+#include <mcld/LD/FragmentRef.h>
namespace mcld
{
@@ -31,7 +31,7 @@
// FIXME: use SizeTrait<32> or SizeTrait<64> instead of big type
typedef ResolveInfo::SizeType SizeType;
typedef uint64_t ValueType;
- typedef MCFragmentRef::Offset Offset;
+ typedef FragmentRef::Offset Offset;
public:
LDSymbol();
@@ -86,7 +86,7 @@
ValueType value() const
{ return m_Value; }
- const MCFragmentRef* fragRef() const
+ const FragmentRef* fragRef() const
{ return m_pFragRef; }
SizeType size() const
@@ -110,14 +110,14 @@
void setValue(ValueType pValue)
{ m_Value = pValue; }
- void setFragmentRef(MCFragmentRef* pFragmentRef);
+ void setFragmentRef(FragmentRef* pFragmentRef);
void setResolveInfo(const ResolveInfo& pInfo);
private:
// ----- Symbol's fields ----- //
ResolveInfo* m_pResolveInfo;
- MCFragmentRef* m_pFragRef;
+ FragmentRef* m_pFragRef;
ValueType m_Value;
};
diff --git a/include/mcld/LD/Layout.h b/include/mcld/LD/Layout.h
index 2b36126..4dc9897 100644
--- a/include/mcld/LD/Layout.h
+++ b/include/mcld/LD/Layout.h
@@ -6,20 +6,23 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef MCLD_LAYOUT_H
-#define MCLD_LAYOUT_H
+#ifndef MCLD_LD_LAYOUT_H
+#define MCLD_LD_LAYOUT_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
+
+#include <map>
+
#include <llvm/ADT/ilist.h>
#include <llvm/ADT/ilist_node.h>
#include <llvm/ADT/DenseMap.h>
-#include <llvm/MC/MCAssembler.h>
-#include <mcld/MC/MCFragmentRef.h>
-#include <mcld/Support/GCFactory.h>
+
+#include <mcld/LD/FragmentRef.h>
#include <mcld/LD/LDSection.h>
+#include <mcld/LD/SectionData.h>
#include <mcld/MC/MCLDInfo.h>
-#include <map>
+#include <mcld/Support/GCFactory.h>
namespace mcld
{
@@ -49,17 +52,17 @@
/// destructor
~Layout();
- /// getInputLDSection - give a MCFragment, return the corresponding input
+ /// getInputLDSection - give a Fragment, return the corresponding input
/// LDSection*
///
/// @return return NULL if the fragment is not found in input
- LDSection* getInputLDSection(const llvm::MCFragment& pFrag);
+ LDSection* getInputLDSection(const Fragment& pFrag);
- /// getInputLDSection - give a MCFragment, return the corresponding input
+ /// getInputLDSection - give a Fragment, return the corresponding input
/// LDSection*
///
/// @return return NULL if the fragment is not found in input
- const LDSection* getInputLDSection(const llvm::MCFragment& pFrag) const;
+ const LDSection* getInputLDSection(const Fragment& pFrag) const;
/// getFragmentRef - give a LDSection in input file and an offset, return
/// the fragment reference.
@@ -67,7 +70,7 @@
/// @param pInputSection - the given input section
/// @param pOffset - the offset, cannot be larger than this input section.
/// @return if found, return the fragment. Otherwise, return NULL.
- MCFragmentRef*
+ FragmentRef*
getFragmentRef(const LDSection& pInputSection, uint64_t pOffset);
/// getFragmentRef - give a fragment and a big offset, return the fragment
@@ -77,55 +80,53 @@
/// @param pBigOffset - the offset, can be larger than the fragment, but can
/// not larger than this input section.
/// @return if found, return the fragment. Otherwise, return NULL.
- MCFragmentRef*
- getFragmentRef(const llvm::MCFragment& pFrag, uint64_t pBigOffset);
+ FragmentRef* getFragmentRef(const Fragment& pFrag, uint64_t pBigOffset);
/// getOutputOffset - Get the offset of the given fragment inside the
- /// the output's MCSectionData.
- uint64_t getOutputOffset(const llvm::MCFragment& pFrag);
+ /// the output's SectionData.
+ uint64_t getOutputOffset(const Fragment& pFrag);
/// getOutputOffset - Get the offset of the given fragment inside the
- /// the output's MCSectionData.
- uint64_t getOutputOffset(const llvm::MCFragment& pFrag) const;
+ /// the output's SectionData.
+ uint64_t getOutputOffset(const Fragment& pFrag) const;
/// getOutputOffset - Get the offset of the given fragment inside
- /// the output's MCSectionData.
+ /// the output's SectionData.
///
- /// @return return -1 if the fragment is not found in output's MCSectionData.
+ /// @return return -1 if the fragment is not found in output's SectionData.
- uint64_t getOutputOffset(const MCFragmentRef& pFragRef);
+ uint64_t getOutputOffset(const FragmentRef& pFragRef);
/// getOutputOffset - Get the offset of the given fragment inside
- /// the output's MCSectionData.
+ /// the output's SectionData.
///
- /// @return return -1 if the fragment is not found in output's MCSectionData.
- uint64_t getOutputOffset(const MCFragmentRef& pFragRef) const;
+ /// @return return -1 if the fragment is not found in output's SectionData.
+ uint64_t getOutputOffset(const FragmentRef& pFragRef) const;
- /// getOutputLDSection - give a MCFragment, return the corresponding output
+ /// getOutputLDSection - give a Fragment, return the corresponding output
/// LDSection*
///
/// @return return NULL if the fragment is not found in the output
- LDSection* getOutputLDSection(const llvm::MCFragment& pFrag);
+ LDSection* getOutputLDSection(const Fragment& pFrag);
- /// getOutputLDSection - give a MCFragment, return the corresponding output
+ /// getOutputLDSection - give a Fragment, return the corresponding output
/// LDSection*
///
/// @return return NULL if the fragment is not found in the output
- const LDSection* getOutputLDSection(const llvm::MCFragment& pFrag) const;
+ const LDSection* getOutputLDSection(const Fragment& pFrag) const;
// ----- modifiers ----- //
- bool layout(Output& pOutput, const TargetLDBackend& pBackend, const MCLDInfo& pInfo);
+ bool layout(Output& pOutput,
+ const TargetLDBackend& pBackend, const MCLDInfo& pInfo);
/// addInputRange
- void addInputRange(const llvm::MCSectionData& pSD,
- const LDSection& pInputHdr);
+ void addInputRange(const SectionData& pSD, const LDSection& pInputHdr);
- /// appendFragment - append the given MCFragment to the given MCSectionData,
- /// and insert a MCAlignFragment to preserve the required align constraint if
+ /// appendFragment - append the given Fragment to the given SectionData,
+ /// and insert a AlignFragment to preserve the required align constraint if
/// needed
/// @return return the inserted size, i.e., the size of pFrag and alignment
/// size if any
- uint64_t appendFragment(llvm::MCFragment& pFrag,
- llvm::MCSectionData& pSD,
+ uint64_t appendFragment(Fragment& pFrag, SectionData& pSD,
uint32_t pAlignConstraint = 1);
private:
/** \class Range
@@ -140,14 +141,14 @@
public:
LDSection* header;
- llvm::MCFragment* prevRear;
+ Fragment* prevRear;
};
typedef llvm::iplist<Range> RangeList;
- typedef std::map<const llvm::MCSectionData*, RangeList*> SDRangeMap;
+ typedef std::map<const SectionData*, RangeList*> SDRangeMap;
- typedef GCFactory<MCFragmentRef, 0> FragRefFactory;
+ typedef GCFactory<FragmentRef, 0> FragRefFactory;
private:
inline bool isFirstRange(const Range& pRange) const
@@ -169,7 +170,7 @@
}
// get the front fragment in the range.
- inline llvm::MCFragment* getFront(Range& pRange) const
+ inline Fragment* getFront(Range& pRange) const
{
if (!pRange.header->hasSectionData())
return NULL;
@@ -185,7 +186,7 @@
return pRange.prevRear->getNextNode();
}
- inline const llvm::MCFragment* getFront(const Range& pRange) const
+ inline const Fragment* getFront(const Range& pRange) const
{
if (!pRange.header->hasSectionData())
return NULL;
@@ -202,7 +203,7 @@
}
// get the rear fragment in the range.
- inline llvm::MCFragment* getRear(Range& pRange) const
+ inline Fragment* getRear(Range& pRange) const
{
if (!pRange.header->hasSectionData())
return NULL;
@@ -217,7 +218,7 @@
return pRange.getNextNode()->prevRear;
}
- inline const llvm::MCFragment* getRear(const Range& pRange) const
+ inline const Fragment* getRear(const Range& pRange) const
{
if (!pRange.header->hasSectionData())
return NULL;
@@ -232,23 +233,22 @@
return pRange.getNextNode()->prevRear;
}
- MCFragmentRef* getFragmentRef(Range &pRange, uint64_t pOffset);
+ FragmentRef* getFragmentRef(Range &pRange, uint64_t pOffset);
- MCFragmentRef* getFragmentRef(llvm::MCFragment& pFront,
- llvm::MCFragment& pRear,
- uint64_t pOffset);
+ FragmentRef*
+ getFragmentRef(Fragment& pFront, Fragment& pRear, uint64_t pOffset);
- bool hasLayoutOrder(const llvm::MCFragment& pFragment) const
+ bool hasLayoutOrder(const Fragment& pFragment) const
{ return (pFragment.getLayoutOrder() != ~(0U)); }
- bool hasLayoutOffset(const llvm::MCFragment& pFragment) const
- { return (pFragment.Offset != ~UINT64_C(0)); }
+ bool hasLayoutOffset(const Fragment& pFragment) const
+ { return (pFragment.getOffset() != ~UINT64_C(0)); }
- bool isValidOffset(const llvm::MCFragment& pFrag, uint64_t pTargetOffset) const;
+ bool isValidOffset(const Fragment& pFrag, uint64_t pTargetOffset) const;
- void setFragmentLayoutOrder(llvm::MCFragment* pFragment);
+ void setFragmentLayoutOrder(Fragment* pFragment);
- void setFragmentLayoutOffset(llvm::MCFragment* pFragment);
+ void setFragmentLayoutOffset(Fragment* pFragment);
/// sortSectionOrder - perform sorting on m_SectionOrder to get final layout
/// ordering
@@ -260,7 +260,7 @@
/// a vector to describe the order of sections
SectionOrder m_SectionOrder;
- /// the map from MCSectionData* to its own RangeList.
+ /// the map from SectionData* to its own RangeList.
SDRangeMap m_SDRangeMap;
FragRefFactory m_FragRefFactory;
diff --git a/include/mcld/LD/NamePool.h b/include/mcld/LD/NamePool.h
index 79d55b9..1c0f8b3 100644
--- a/include/mcld/LD/NamePool.h
+++ b/include/mcld/LD/NamePool.h
@@ -12,19 +12,16 @@
#include <gtest.h>
#endif
+#include <utility>
+
#include <llvm/ADT/StringRef.h>
+
#include <mcld/ADT/HashTable.h>
#include <mcld/ADT/StringHash.h>
#include <mcld/ADT/Uncopyable.h>
#include <mcld/LD/ResolveInfo.h>
#include <mcld/LD/Resolver.h>
#include <mcld/LD/ResolveInfoFactory.h>
-#include <utility>
-
-namespace llvm
-{
- class MCSectionData;
-}
namespace mcld
{
@@ -32,6 +29,7 @@
class Resolver;
class StringTable;
class SymbolTableIF;
+class SectionData;
/** \class NamePool
* \brief Store symbol and search symbol by name. Can help symbol resolution.
diff --git a/include/mcld/LD/RegionFragment.h b/include/mcld/LD/RegionFragment.h
new file mode 100644
index 0000000..8aba1ef
--- /dev/null
+++ b/include/mcld/LD/RegionFragment.h
@@ -0,0 +1,51 @@
+//===- RegionFragment.h ---------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MCLD_LD_REGION_FRAGMENT_H
+#define MCLD_LD_REGION_FRAGMENT_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/LD/Fragment.h>
+#include <mcld/Support/MemoryRegion.h>
+
+namespace mcld
+{
+
+/** \class RegionFragment
+ * \brief RegionFragment is a kind of Fragment containing mcld::MemoryRegion
+ */
+class RegionFragment : public Fragment
+{
+public:
+ RegionFragment(MemoryRegion& pRegion, SectionData* pSD = NULL);
+
+ ~RegionFragment();
+
+ MemoryRegion& getRegion()
+ { return m_Region; }
+
+ const MemoryRegion& getRegion() const
+ { return m_Region; }
+
+ static bool classof(const Fragment *F)
+ { return F->getKind() == Fragment::Region; }
+
+ static bool classof(const RegionFragment *)
+ { return true; }
+
+private:
+ MemoryRegion& m_Region;
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/Relocation.h b/include/mcld/LD/Relocation.h
index 09ff6e4..fa77e64 100644
--- a/include/mcld/LD/Relocation.h
+++ b/include/mcld/LD/Relocation.h
@@ -6,14 +6,16 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef LD_RELOCATION_H
-#define LD_RELOCATION_H
+#ifndef MCLD_LD_RELOCATION_H
+#define MCLD_LD_RELOCATION_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
#include <llvm/ADT/ilist_node.h>
#include <llvm/Support/DataTypes.h>
-#include <mcld/MC/MCFragmentRef.h>
+
+#include <mcld/LD/Fragment.h>
+#include <mcld/LD/FragmentRef.h>
#include <mcld/LD/ResolveInfo.h>
#include <mcld/LD/LDSymbol.h>
@@ -24,7 +26,7 @@
class RelocationFactory;
class MCLDInfo;
-class Relocation : public llvm::MCFragment
+class Relocation : public Fragment
{
friend class RelocationFactory;
@@ -35,7 +37,7 @@
private:
Relocation(Type pType,
- MCFragmentRef* pTargetRef,
+ FragmentRef* pTargetRef,
Address pAddend,
DWord pTargetData);
@@ -71,11 +73,11 @@
const DWord& target() const;
/// targetRef - the reference of the target data
- MCFragmentRef& targetRef()
+ FragmentRef& targetRef()
{ return m_TargetAddress; }
/// targetRef - the reference of the target data
- const MCFragmentRef& targetRef() const
+ const FragmentRef& targetRef() const
{ return m_TargetAddress; }
void apply(RelocationFactory& pRelocFactory, const MCLDInfo& pLDInfo);
@@ -87,9 +89,9 @@
void setSymInfo(ResolveInfo* pSym);
- // Relocation is a kind of MCFragment with type of FT_Reloc
- static bool classof(const MCFragment *F)
- { return F->getKind() == MCFragment::FT_Reloc;}
+ // Relocation is a kind of Fragment with type of FT_Reloc
+ static bool classof(const Fragment *F)
+ { return F->getKind() == Fragment::Relocation; }
static bool classof(const Relocation *) { return true; }
private:
@@ -102,8 +104,8 @@
/// m_pSymInfo - resolved symbol info of relocation target symbol
ResolveInfo* m_pSymInfo;
- /// m_TargetAddress - MCFragmentRef of the place being relocated
- MCFragmentRef m_TargetAddress;
+ /// m_TargetAddress - FragmentRef of the place being relocated
+ FragmentRef m_TargetAddress;
/// m_Addend - the addend
Address m_Addend;
diff --git a/include/mcld/LD/RelocationFactory.h b/include/mcld/LD/RelocationFactory.h
index 717a709..cde120f 100644
--- a/include/mcld/LD/RelocationFactory.h
+++ b/include/mcld/LD/RelocationFactory.h
@@ -6,8 +6,8 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef LD_RELOCATION_FACTORY_H
-#define LD_RELOCATION_FACTORY_H
+#ifndef MCLD_LD_RELOCATION_FACTORY_H
+#define MCLD_LD_RELOCATION_FACTORY_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
@@ -19,7 +19,7 @@
class LDSymbol;
class ResolveInfo;
-class MCFragmentRef;
+class FragmentRef;
class Layout;
class GOT;
class TargetLDBackend;
@@ -60,7 +60,7 @@
/// @param pFragRef - the place to apply the relocation
/// @param pAddend - the addend of the relocation entry
Relocation* produce(Type pType,
- MCFragmentRef& pFragRef,
+ FragmentRef& pFragRef,
Address pAddend = 0);
/// produceEmptyEntry - produce an empty relocation which
diff --git a/include/mcld/LD/SectionData.h b/include/mcld/LD/SectionData.h
new file mode 100644
index 0000000..8666195
--- /dev/null
+++ b/include/mcld/LD/SectionData.h
@@ -0,0 +1,80 @@
+//===- SectionData.h ------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_LD_SECTION_DATA_H
+#define MCLD_LD_SECTION_DATA_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <llvm/ADT/ilist.h>
+#include <llvm/ADT/ilist_node.h>
+#include <llvm/Support/DataTypes.h>
+
+#include <mcld/LD/Fragment.h>
+
+namespace mcld
+{
+
+class LDSection;
+
+/** \class SectionData
+ * \brief SectionData provides a container for all Fragments.
+ */
+class SectionData
+{
+private:
+ SectionData(const SectionData &); // DO NOT IMPLEMENT
+ SectionData& operator=(const SectionData &); // DO NOT IMPLEMENT
+
+public:
+ typedef llvm::iplist<Fragment> FragmentListType;
+ typedef FragmentListType::iterator iterator;
+ typedef FragmentListType::const_iterator const_iterator;
+
+ typedef FragmentListType::reverse_iterator reverse_iterator;
+ typedef FragmentListType::const_reverse_iterator const_reverse_iterator;
+
+public:
+ explicit SectionData(const LDSection &pSection);
+
+ const LDSection &getSection() const { return *m_pSection; }
+
+ unsigned int getAlignment() const { return m_Alignment; }
+ void setAlignment(unsigned int pValue) { m_Alignment = pValue; }
+
+ FragmentListType &getFragmentList() { return m_Fragments; }
+ const FragmentListType &getFragmentList() const { return m_Fragments; }
+
+ iterator begin() { return m_Fragments.begin(); }
+ const_iterator begin() const { return m_Fragments.begin(); }
+
+ iterator end() { return m_Fragments.end(); }
+ const_iterator end() const { return m_Fragments.end(); }
+
+ reverse_iterator rbegin() { return m_Fragments.rbegin(); }
+ const_reverse_iterator rbegin() const { return m_Fragments.rbegin(); }
+
+ reverse_iterator rend() { return m_Fragments.rend(); }
+ const_reverse_iterator rend() const { return m_Fragments.rend(); }
+
+ size_t size() const { return m_Fragments.size(); }
+
+ bool empty() const { return m_Fragments.empty(); }
+
+private:
+ FragmentListType m_Fragments;
+ const LDSection* m_pSection;
+ unsigned int m_Alignment;
+
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/LD/SectionMerger.h b/include/mcld/LD/SectionMerger.h
index 40f1453..a9ca0c6 100644
--- a/include/mcld/LD/SectionMerger.h
+++ b/include/mcld/LD/SectionMerger.h
@@ -14,7 +14,7 @@
#include <vector>
#include <string>
-#include <llvm/MC/MCAssembler.h>
+
#include <mcld/LD/LDSection.h>
#include <mcld/LD/LDContext.h>
#include <mcld/LD/SectionMap.h>
@@ -47,7 +47,7 @@
LDSection* getOutputSectHdr(const std::string& pName);
/// getOutputSectData - return a associated output section data
- llvm::MCSectionData* getOutputSectData(const std::string& pName);
+ SectionData* getOutputSectData(const std::string& pName);
/// addMapping - add a mapping as creating one new output LDSection
/// @param pName - a input section name
diff --git a/include/mcld/LD/TargetFragment.h b/include/mcld/LD/TargetFragment.h
new file mode 100644
index 0000000..92af5a0
--- /dev/null
+++ b/include/mcld/LD/TargetFragment.h
@@ -0,0 +1,49 @@
+//===- TargetFragment.h ---------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MCLD_LD_TARGET_FRAGMENT_H
+#define MCLD_LD_TARGET_FRAGMENT_H
+#ifdef ENABLE_UNITTEST
+#include <gtest.h>
+#endif
+
+#include <mcld/LD/Fragment.h>
+
+namespace mcld
+{
+
+class SectionData;
+
+/** \class TargetFragment
+ * \brief TargetFragment is a kind of MCFragment inherited by
+ * target-depedent Fragment.
+ */
+class TargetFragment : public Fragment
+{
+protected:
+ TargetFragment(Fragment::Type pKind, SectionData* pSD = NULL)
+ : Fragment(pKind, pSD) {}
+
+public:
+ virtual ~TargetFragment() {}
+
+ virtual size_t getSize() const = 0;
+
+public:
+ static bool classof(const Fragment *F)
+ { return F->getKind() == Fragment::Target; }
+
+ static bool classof(const TargetFragment *)
+ { return true; }
+};
+
+} // namespace of mcld
+
+#endif
+
diff --git a/include/mcld/MC/MCBitcodeInterceptor.h b/include/mcld/MC/MCBitcodeInterceptor.h
deleted file mode 100644
index 182b157..0000000
--- a/include/mcld/MC/MCBitcodeInterceptor.h
+++ /dev/null
@@ -1,75 +0,0 @@
-//===- MCBitcodeInterceptor.h ---------------------------------------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCLD_BITCODE_INTERCEPTOR_H
-#define MCLD_BITCODE_INTERCEPTOR_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <llvm/MC/MCObjectWriter.h>
-
-
-namespace llvm
-{
- class MCStreamer;
- class MCObjectStreamer;
- class MCAsmLayout;
- class MCAssembler;
- class MCFixup;
- class MCFragment;
- class MCSymbol;
- class MCSymbolData;
- class MCSymbolRefExpr;
- class MCValue;
- class raw_ostream;
-} // namespace of llvm
-
-namespace mcld
-{
-
-class MCLDInfo;
-class TargetLDBackend;
-
-/** \class MCBitcodeInterceptor
- * \brief MCBitcodeInterceptor converts bitcode into LDContext
- *
- * @see LDContext
- * @see MCObjectWriter
- */
-class MCBitcodeInterceptor : public llvm::MCObjectWriter
-{
-public:
- MCBitcodeInterceptor(llvm::MCObjectStreamer&, TargetLDBackend&, MCLDInfo&);
- ~MCBitcodeInterceptor();
-
- void ExecutePostLayoutBinding(llvm::MCAssembler &Asm,
- const llvm::MCAsmLayout &Layout);
-
- /// RecordRelocation - record relocations
- // make a LDRelocation and recordds in the LDContext.
- void RecordRelocation(const llvm::MCAssembler &Asm,
- const llvm::MCAsmLayout &Layout,
- const llvm::MCFragment *Fragment,
- const llvm::MCFixup &Fixup,
- llvm::MCValue Target,
- uint64_t &FixedValue);
-
- /// WriteObject - not really write out a object. Instead, load data to
- /// LDContext
- void WriteObject(llvm::MCAssembler &Asm, const llvm::MCAsmLayout &Layout);
-
-private:
- TargetLDBackend& m_Backend;
- MCLDInfo& m_LDInfo;
-
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/MC/MCDataFragment.h b/include/mcld/MC/MCDataFragment.h
deleted file mode 100644
index 63ae497..0000000
--- a/include/mcld/MC/MCDataFragment.h
+++ /dev/null
@@ -1,82 +0,0 @@
-//===- MCDataFragment.h ---------------------------------------------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCDATAFRAGMENT_H
-#define MCDATAFRAGMENT_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <llvm/MC/MCAssembler.h>
-#include <llvm/MC/MCInst.h>
-#include <llvm/ADT/SmallString.h>
-#include "mcld/LD/Relocation.h"
-
-namespace mcld
-{
-
-/** \class MCDataFragment
- * \brief MCDataFragment for mcld
- */
-class MCDataFragment : public llvm::MCFragment
-{
-public:
- typedef std::vector<Relocation*> RelocationsType;
-private:
-
- /// m_pFragment - llvm MCDataFragment for this MCDataFragment
- llvm::MCDataFragment* m_pFragment;
-
- /// m_Relocation - The list of relocations in this fragment
- RelocationsType m_Relocations;
-
-public:
- typedef RelocationsType::const_iterator const_relocation_iterator;
- typedef RelocationsType::iterator relocation_iterator;
-
-public:
- MCDataFragment(llvm::MCDataFragment& pFragment)
- : m_pFragment(&pFragment) {
- setParent( pFragment.getParent() );
- setAtom( pFragment.getAtom() );
- setLayoutOrder( pFragment.getLayoutOrder());
- }
- ~MCDataFragment(){}
-
- // ------ observers ------//
- llvm::SmallString<32> &getContents() { return m_pFragment->getContents(); }
- const llvm::SmallString<32> &getContents() const { return m_pFragment->getContents(); }
-
- // relocation access
- void addRelocation(Relocation &pReloc){ m_Relocations.push_back(&pReloc); }
-
- RelocationsType &getRelocations() { return m_Relocations; }
- const RelocationsType &getRelcoations() const { return m_Relocations; }
-
- relocation_iterator relocation_begin() { return m_Relocations.begin(); }
- const_relocation_iterator relocation_begin() const { return m_Relocations.begin(); }
-
- relocation_iterator relocation_end() {return m_Relocations.end();}
- const_relocation_iterator relocation_end() const {return m_Relocations.end();}
-
- size_t relocations_size() const { return m_Relocations.size(); }
-
- // fragment identification
- static bool classof(const MCFragment *pF) {
- return pF->getKind() == llvm::MCFragment::FT_Data;
- }
- static bool classof(const MCDataFragment *) { return true; }
-
- // overwrite parent method
- FragmentType getKind() const { return m_pFragment->getKind(); }
-
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/MC/MCInstFragment.h b/include/mcld/MC/MCInstFragment.h
deleted file mode 100644
index 6dbbc85..0000000
--- a/include/mcld/MC/MCInstFragment.h
+++ /dev/null
@@ -1,92 +0,0 @@
-//===- MCInstFragment.h ---------------------------------------------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#ifndef MCINSTFRAGMENT_H
-#define MCINSTFRAGMENT_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-#include <llvm/MC/MCAssembler.h>
-#include <llvm/MC/MCInst.h>
-#include <llvm/ADT/SmallString.h>
-#include <llvm/ADT/ilist.h>
-#include "mcld/LD/Relocation.h"
-
-
-namespace mcld
-{
-
-/** \class MCInstFragment
- * \brief MCInstFragment for mcld
- */
-class MCInstFragment : public llvm::MCFragment
-{
-public:
- typedef std::vector<Relocation*> RelocationsType;
-private:
-
- /// m_pFragment - llvm MCInstFragment for this MCInstFragment
- llvm::MCInstFragment* m_pFragment;
-
- /// m_Relocation - The list of relocations in this fragment
- RelocationsType m_Relocations;
-
-public:
- typedef RelocationsType::const_iterator const_relocation_iterator;
- typedef RelocationsType::iterator relocation_iterator;
-
-public:
- MCInstFragment( llvm::MCInstFragment& pFragment )
- : m_pFragment(&pFragment){
- setParent( pFragment.getParent() );
- setAtom( pFragment.getAtom() );
- setLayoutOrder( pFragment.getLayoutOrder());
- }
- ~MCInstFragment(){}
-
- // ------ observers ------//
- llvm::SmallVectorImpl<char> &getCode() { return m_pFragment->getCode(); }
- const llvm::SmallVectorImpl<char> &getCode() const { return m_pFragment->getCode(); }
-
- unsigned getInstSize() const { return m_pFragment->getCode().size(); }
-
- llvm::MCInst &getInst() { return m_pFragment->getInst(); }
- const llvm::MCInst &getInst() const { return m_pFragment->getInst(); }
-
- // ----- modifiers ------//
- void setInst(llvm::MCInst pValue) { m_pFragment->setInst(pValue); }
-
- // relocation access
- void addRelocation(Relocation &pReloc){ m_Relocations.push_back(&pReloc); }
-
- RelocationsType &getRelocations() { return m_Relocations; }
- const RelocationsType &getRelcoations() const { return m_Relocations; }
-
- relocation_iterator relocation_begin() { return m_Relocations.begin(); }
- const_relocation_iterator relocation_begin() const { return m_Relocations.begin(); }
-
- relocation_iterator relocation_end() {return m_Relocations.end();}
- const_relocation_iterator relocation_end() const {return m_Relocations.end();}
-
- size_t relocations_size() const { return m_Relocations.size(); }
-
- // fragment identification
- static bool classof(const MCFragment *pF) {
- return pF->getKind() == llvm::MCFragment::FT_Inst;
- }
- static bool classof(const MCInstFragment *) { return true; }
-
- // overwrite parent method
- FragmentType getKind() const { return m_pFragment->getKind(); }
-
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/MC/MCLDDriver.h b/include/mcld/MC/MCLDDriver.h
index ec8acf5..2259186 100644
--- a/include/mcld/MC/MCLDDriver.h
+++ b/include/mcld/MC/MCLDDriver.h
@@ -28,13 +28,16 @@
class TargetLDBackend;
class MemoryAreaFactory;
-//===----------------------------------------------------------------------===//
-/// MCLDDriver - MCLDDriver prepares parameters for MCLinker.
-///
+/** \class MCLDDriver
+ * \brief MCLDDriver prepares parameters for MCLinker.
+ */
class MCLDDriver
{
public:
- MCLDDriver(MCLDInfo& pLDInfo, TargetLDBackend& pLDBackend);
+ MCLDDriver(MCLDInfo& pLDInfo,
+ TargetLDBackend& pLDBackend,
+ MemoryAreaFactory& pAreaFactory);
+
~MCLDDriver();
/// initMCLinker - initialize MCLinker
@@ -53,20 +56,9 @@
/// - check every Input has a correct Attribute
bool linkable() const;
- /// readSections - read all input section headers
- bool readSections();
-
/// mergeSections - put allinput sections into output sections
bool mergeSections();
- /// readSymbolTables - read symbol tables from the input files.
- /// for each input file, loads its symbol table from file.
- bool readSymbolTables();
-
- /// mergeSymbolTables - merge the symbol tables of input files into the
- /// output's symbol table.
- bool mergeSymbolTables();
-
/// addStandardSymbols - shared object and executable files need some
/// standard symbols
/// @return if there are some input symbols with the same name to the
@@ -128,6 +120,7 @@
TargetLDBackend &m_LDBackend;
MCLinker* m_pLinker;
SectionMap m_SectionMap;
+ MemoryAreaFactory &m_AreaFactory;
};
} // end namespace mcld
diff --git a/include/mcld/MC/MCLDFile.h b/include/mcld/MC/MCLDFile.h
index f77fe82..c780cb8 100644
--- a/include/mcld/MC/MCLDFile.h
+++ b/include/mcld/MC/MCLDFile.h
@@ -11,8 +11,8 @@
//
//===----------------------------------------------------------------------===//
-#ifndef MCLD_LDFILE_H
-#define MCLD_LDFILE_H
+#ifndef MCLD_LD_FILE_H
+#define MCLD_LD_FILE_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
diff --git a/include/mcld/MC/MCLinker.h b/include/mcld/MC/MCLinker.h
index f592d6e..9fe78d8 100644
--- a/include/mcld/MC/MCLinker.h
+++ b/include/mcld/MC/MCLinker.h
@@ -17,8 +17,11 @@
#include <gtest.h>
#endif
+#include <set>
+#include <string>
+
#include <llvm/ADT/ilist.h>
-#include <llvm/MC/MCAssembler.h>
+
#include <mcld/LD/StaticResolver.h>
#include <mcld/LD/LDSectionFactory.h>
#include <mcld/LD/LDFileFormat.h>
@@ -30,8 +33,6 @@
#include <mcld/MC/SymbolCategory.h>
#include <mcld/Support/GCFactory.h>
#include <mcld/Support/GCFactoryListTraits.h>
-#include <set>
-#include <string>
namespace mcld {
@@ -39,6 +40,7 @@
class MCLDInfo;
class LDSection;
class LDSectionFactory;
+class SectionData;
class SectionMap;
class Output;
class EhFrame;
@@ -78,7 +80,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility = ResolveInfo::Default);
/// defineSymbol - add a symbol
@@ -108,7 +110,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility = ResolveInfo::Default);
bool finalizeSymbols();
@@ -136,7 +138,7 @@
uint32_t pAlign = 0x0);
/// getOrCreateSectData - for reader to map and perform section merging immediately
- llvm::MCSectionData& getOrCreateSectData(LDSection& pSection);
+ SectionData& getOrCreateSectData(LDSection& pSection);
// ----- eh_frame sections ----- //
/// addEhFrame - add an exception handling section
@@ -157,7 +159,7 @@
Relocation* addRelocation(Relocation::Type pType,
const LDSymbol& pSym,
ResolveInfo& pResolveInfo,
- MCFragmentRef& pFragmentRef,
+ FragmentRef& pFragmentRef,
const LDSection& pSection,
Relocation::Address pAddend = 0);
@@ -201,7 +203,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility);
LDSymbol* defineAndResolveSymbolForcefully(const llvm::StringRef& pName,
@@ -211,7 +213,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility);
LDSymbol* defineSymbolAsRefered(const llvm::StringRef& pName,
@@ -221,7 +223,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility);
LDSymbol* defineAndResolveSymbolAsRefered(const llvm::StringRef& pName,
@@ -231,7 +233,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility);
bool shouldForceLocal(const ResolveInfo& pInfo) const;
@@ -242,7 +244,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility);
LDSymbol* addSymbolFromObject(const llvm::StringRef& pName,
@@ -251,13 +253,13 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility);
private:
typedef GCFactory<LDSymbol, 0> LDSymbolFactory;
- typedef GCFactory<llvm::MCSectionData, 0> LDSectionDataFactory;
- typedef llvm::iplist<llvm::MCFragment,
- GCFactoryListTraits<llvm::MCFragment> > RelocationListType;
+ typedef GCFactory<SectionData, 0> LDSectionDataFactory;
+ typedef llvm::iplist<Fragment,
+ GCFactoryListTraits<Fragment> > RelocationListType;
typedef std::set<LDSymbol*> ForceLocalSymbolTable;
typedef std::vector<LDSymbol*> OutputSymbolTable;
diff --git a/include/mcld/MC/MCLinker.tcc b/include/mcld/MC/MCLinker.tcc
index d6c5744..b13e48d 100644
--- a/include/mcld/MC/MCLinker.tcc
+++ b/include/mcld/MC/MCLinker.tcc
@@ -15,7 +15,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
llvm::StringRef symbol_name = pName;
@@ -62,7 +62,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
// These if/return should be optimized by compiler.
diff --git a/include/mcld/MC/MCRegionFragment.h b/include/mcld/MC/MCRegionFragment.h
deleted file mode 100644
index 7dd088b..0000000
--- a/include/mcld/MC/MCRegionFragment.h
+++ /dev/null
@@ -1,53 +0,0 @@
-//===- MCRegionFragment.h - MCFragment containing MemoryRegion ------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MCLD_REGION_FRAGMENT_H
-#define MCLD_REGION_FRAGMENT_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-
-#include <mcld/Support/MemoryRegion.h>
-#include <llvm/MC/MCAssembler.h>
-
-namespace mcld
-{
-
-/** \class MCRegionFragment
- * \brief MCRegionFragment is a kind of MCFragment containing
- * mcld::MemoryRegion
- */
-class MCRegionFragment : public llvm::MCFragment
-{
-public:
- MCRegionFragment(MemoryRegion& pRegion, llvm::MCSectionData* pSD = 0);
- ~MCRegionFragment();
-
- MemoryRegion& getRegion()
- { return m_Region; }
-
- const MemoryRegion& getRegion() const
- { return m_Region; }
-
- static bool classof(const MCFragment *F)
- { return F->getKind() == llvm::MCFragment::FT_Region; }
-
- static bool classof(const MCRegionFragment *)
- { return true; }
-
-private:
- MemoryRegion& m_Region;
- llvm::MCSectionData* m_pSectionData;
-
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/MC/MCTargetFragment.h b/include/mcld/MC/MCTargetFragment.h
deleted file mode 100644
index 4050708..0000000
--- a/include/mcld/MC/MCTargetFragment.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//===- MCTargetFragment.h - MCFragment containing MemoryRegion ------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef MCLD_TARGET_FRAGMENT_H
-#define MCLD_TARGET_FRAGMENT_H
-#ifdef ENABLE_UNITTEST
-#include <gtest.h>
-#endif
-
-#include <llvm/MC/MCAssembler.h>
-
-namespace mcld
-{
-
-/** \class MCTargetFragment
- * \brief MCTargetFragment is a kind of MCFragment inherited by
- * target-depedent MCFragment.
- */
-class MCTargetFragment : public llvm::MCFragment
-{
-protected:
- MCTargetFragment(llvm::MCFragment::FragmentType pKind,
- llvm::MCSectionData* pSD = 0) :
- llvm::MCFragment(pKind, pSD) {}
-
-public:
- virtual ~MCTargetFragment() {}
-
- virtual size_t getSize() const = 0;
-
-public:
- static bool classof(const MCFragment *F)
- { return F->getKind() == llvm::MCFragment::FT_Target; }
-
- static bool classof(const MCTargetFragment *)
- { return true; }
-};
-
-} // namespace of mcld
-
-#endif
-
diff --git a/include/mcld/Support/Path.h b/include/mcld/Support/Path.h
index 54b75c5..de49d3e 100644
--- a/include/mcld/Support/Path.h
+++ b/include/mcld/Support/Path.h
@@ -88,6 +88,7 @@
std::string string() const;
// ----- decomposition ----- //
+ Path parent_path() const;
Path stem() const;
Path extension() const;
diff --git a/include/mcld/Target/GNULDBackend.h b/include/mcld/Target/GNULDBackend.h
index 9f3e308..d05fe72 100644
--- a/include/mcld/Target/GNULDBackend.h
+++ b/include/mcld/Target/GNULDBackend.h
@@ -65,7 +65,9 @@
virtual ~GNULDBackend();
// ----- readers/writers ----- //
- bool initArchiveReader(MCLinker& pLinker, MCLDInfo& pInfo);
+ bool initArchiveReader(MCLinker& pLinker,
+ MCLDInfo& pInfo,
+ MemoryAreaFactory& pMemAreaFactory);
bool initObjectReader(MCLinker& pLinker);
bool initDynObjReader(MCLinker& pLinker);
bool initObjectWriter(MCLinker& pLinker);
diff --git a/include/mcld/Target/GOT.h b/include/mcld/Target/GOT.h
index eb0873a..5621778 100644
--- a/include/mcld/Target/GOT.h
+++ b/include/mcld/Target/GOT.h
@@ -6,29 +6,30 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef MCLD_GOT_H
-#define MCLD_GOT_H
+#ifndef MCLD_GLOBAL_OFFSET_TABLE_H
+#define MCLD_GLOBAL_OFFSET_TABLE_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
#include <mcld/LD/LDSection.h>
-#include <mcld/MC/MCTargetFragment.h>
+#include <mcld/LD/TargetFragment.h>
namespace mcld
{
class GOT;
class ResolveInfo;
+class SectionData;
/** \class GOTEntry
* \brief The entry of Global Offset Table
*/
-class GOTEntry : public MCTargetFragment
+class GOTEntry : public TargetFragment
{
public:
explicit GOTEntry(uint64_t pContent, size_t pEntrySize,
- llvm::MCSectionData* pParent);
+ SectionData* pParent);
virtual ~GOTEntry();
@@ -41,8 +42,8 @@
void setContent(uint64_t pValue)
{ f_Content = pValue; }
- static bool classof(const MCFragment *pFrag)
- { return pFrag->getKind() == llvm::MCFragment::FT_Target; }
+ static bool classof(const Fragment *pFrag)
+ { return pFrag->getKind() == Fragment::Target; }
static bool classof(const GOTEntry* pFrag)
{ return true; }
@@ -62,9 +63,7 @@
class GOT
{
protected:
- GOT(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
- size_t pEntrySize);
+ GOT(LDSection& pSection, SectionData& pSectionData, size_t pEntrySize);
public:
virtual ~GOT();
@@ -75,10 +74,10 @@
const LDSection& getSection() const
{ return m_Section; }
- llvm::MCSectionData& getSectionData()
+ SectionData& getSectionData()
{ return m_SectionData; }
- const llvm::MCSectionData& getSectionData() const
+ const SectionData& getSectionData() const
{ return m_SectionData; }
public:
@@ -96,7 +95,7 @@
protected:
LDSection& m_Section;
- llvm::MCSectionData& m_SectionData;
+ SectionData& m_SectionData;
size_t f_EntrySize;
};
diff --git a/include/mcld/Target/OutputRelocSection.h b/include/mcld/Target/OutputRelocSection.h
index fe83f2a..b75952b 100644
--- a/include/mcld/Target/OutputRelocSection.h
+++ b/include/mcld/Target/OutputRelocSection.h
@@ -12,8 +12,8 @@
#include <gtest.h>
#endif
-#include <llvm/MC/MCAssembler.h>
#include <llvm/ADT/DenseMap.h>
+#include <mcld/LD/SectionData.h>
#include <mcld/LD/RelocationFactory.h>
namespace mcld
@@ -29,8 +29,8 @@
{
public:
OutputRelocSection(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
- unsigned int pEntrySize);
+ SectionData& pSectionData,
+ unsigned int pEntrySize);
~OutputRelocSection();
@@ -45,14 +45,14 @@
typedef SymRelMapType::iterator SymRelMapIterator;
- typedef llvm::MCSectionData::iterator MCFragmentIterator;
+ typedef SectionData::iterator FragmentIterator;
private:
/// m_pSection - LDSection of this Section
LDSection* m_pSection;
- /// m_SectionData - MCSectionData which contains the dynamic relocations
- llvm::MCSectionData* m_pSectionData;
+ /// m_SectionData - SectionData which contains the dynamic relocations
+ SectionData* m_pSectionData;
/// m_EntryBytes - size of a relocation entry
unsigned int m_EntryBytes;
@@ -61,7 +61,7 @@
bool m_isVisit;
/// m_ValidEntryIterator - point to the first valid entry
- MCFragmentIterator m_ValidEntryIterator;
+ FragmentIterator m_ValidEntryIterator;
/// m_SymRelMap - map the resolved symbol to the Relocation entry
SymRelMapType m_SymRelMap;
diff --git a/include/mcld/Target/PLT.h b/include/mcld/Target/PLT.h
index 6a7522a..2a4f641 100644
--- a/include/mcld/Target/PLT.h
+++ b/include/mcld/Target/PLT.h
@@ -6,27 +6,29 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef PROCEDURE_LINKAGE_TABLE_H
-#define PROCEDURE_LINKAGE_TABLE_H
+#ifndef MCLD_PROCEDURE_LINKAGE_TABLE_H
+#define MCLD_PROCEDURE_LINKAGE_TABLE_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
-#include <mcld/LD/LDSection.h>
-#include <mcld/MC/MCTargetFragment.h>
#include <llvm/ADT/ilist.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/TargetFragment.h>
+
namespace mcld
{
+class SectionData;
class ResolveInfo;
/** \class PLTEntry
*/
-class PLTEntry : public MCTargetFragment
+class PLTEntry : public TargetFragment
{
public:
- PLTEntry(size_t pSize, llvm::MCSectionData* pParent);
+ PLTEntry(size_t pSize, SectionData* pParent);
virtual ~PLTEntry();
size_t getEntrySize() const
@@ -39,7 +41,7 @@
{ return m_pContent; }
//Used by llvm::cast<>.
- static bool classof(const MCFragment *O)
+ static bool classof(const Fragment *O)
{ return true; }
size_t getSize() const
@@ -56,13 +58,13 @@
class PLT
{
public:
- PLT(LDSection& pSection, llvm::MCSectionData& pSectionData);
+ PLT(LDSection& pSection, SectionData& pSectionData);
virtual ~PLT();
const LDSection& getSection() const
{ return m_Section; }
- const llvm::MCSectionData& getSectionData() const
+ const SectionData& getSectionData() const
{ return m_SectionData; }
public:
@@ -77,7 +79,7 @@
protected:
LDSection& m_Section;
- llvm::MCSectionData& m_SectionData;
+ SectionData& m_SectionData;
};
} // namespace of mcld
diff --git a/include/mcld/Target/TargetLDBackend.h b/include/mcld/Target/TargetLDBackend.h
index 205e1f2..f4c02b5 100644
--- a/include/mcld/Target/TargetLDBackend.h
+++ b/include/mcld/Target/TargetLDBackend.h
@@ -33,6 +33,7 @@
class Input;
class LDFileFormat;
class GOT;
+class MemoryAreaFactory;
//===----------------------------------------------------------------------===//
/// TargetLDBackend - Generic interface to target specific assembler backends.
@@ -74,7 +75,9 @@
const LDSection& pSection) = 0;
// ----- format dependent ----- //
- virtual bool initArchiveReader(MCLinker&, MCLDInfo&) = 0;
+ virtual bool initArchiveReader(MCLinker&,
+ MCLDInfo&,
+ MemoryAreaFactory&) = 0;
virtual bool initObjectReader(MCLinker&) = 0;
virtual bool initDynObjReader(MCLinker&) = 0;
virtual bool initObjectWriter(MCLinker&) = 0;
diff --git a/lib/CodeGen/LLVMTargetMachine.cpp b/lib/CodeGen/LLVMTargetMachine.cpp
index e24596c..822ff36 100644
--- a/lib/CodeGen/LLVMTargetMachine.cpp
+++ b/lib/CodeGen/LLVMTargetMachine.cpp
@@ -7,14 +7,13 @@
//
//===----------------------------------------------------------------------===//
-#include "mcld/CodeGen/SectLinker.h"
-#include "mcld/CodeGen/SectLinkerOption.h"
-#include "mcld/MC/MCBitcodeInterceptor.h"
-#include "mcld/MC/MCLDFile.h"
-#include "mcld/Support/RealPath.h"
-#include "mcld/Support/TargetRegistry.h"
-#include "mcld/Target/TargetMachine.h"
-#include "mcld/Target/TargetLDBackend.h"
+#include <mcld/CodeGen/SectLinker.h>
+#include <mcld/CodeGen/SectLinkerOption.h>
+#include <mcld/MC/MCLDFile.h>
+#include <mcld/Support/RealPath.h>
+#include <mcld/Support/TargetRegistry.h>
+#include <mcld/Target/TargetMachine.h>
+#include <mcld/Target/TargetLDBackend.h>
#include <llvm/ADT/OwningPtr.h>
#include <llvm/Analysis/Passes.h>
@@ -55,6 +54,7 @@
//===----------------------------------------------------------------------===//
/// Arguments
+//===----------------------------------------------------------------------===//
// Enable or disable FastISel. Both options are needed, because
// FastISel is enabled by default with -fast, and we wish to be
// able to enable or disable fast-isel independently from -O0.
@@ -91,6 +91,7 @@
//===---------------------------------------------------------------------===//
/// LLVMTargetMachine
+//===----------------------------------------------------------------------===//
mcld::LLVMTargetMachine::LLVMTargetMachine(llvm::TargetMachine &pTM,
const mcld::Target& pTarget,
const std::string& pTriple )
@@ -265,17 +266,19 @@
llvm::MCContext *&Context)
{
const MCAsmInfo &MAI = *getTM().getMCAsmInfo();
+ const MCInstrInfo &MII = *getTM().getInstrInfo();
+ const MCRegisterInfo &MRI = *getTM().getRegisterInfo();
const MCSubtargetInfo &STI = getTM().getSubtarget<MCSubtargetInfo>();
MCInstPrinter *InstPrinter =
getTarget().get()->createMCInstPrinter(MAI.getAssemblerDialect(), MAI,
- *(getTM().getInstrInfo()),
+ MII,
Context->getRegisterInfo(), STI);
MCCodeEmitter* MCE = 0;
MCAsmBackend *MAB = 0;
if (ArgShowMCEncoding) {
- MCE = getTarget().get()->createMCCodeEmitter(*(getTM().getInstrInfo()), STI, *Context);
+ MCE = getTarget().get()->createMCCodeEmitter(MII, MRI, STI, *Context);
MAB = getTarget().get()->createMCAsmBackend(m_Triple);
}
@@ -308,8 +311,11 @@
llvm::MCContext *&Context)
{
// MCCodeEmitter
+ const MCInstrInfo &MII = *getTM().getInstrInfo();
+ const MCRegisterInfo &MRI = *getTM().getRegisterInfo();
const MCSubtargetInfo &STI = getTM().getSubtarget<MCSubtargetInfo>();
- MCCodeEmitter* MCE = getTarget().get()->createMCCodeEmitter(*getTM().getInstrInfo(), STI, *Context);
+ MCCodeEmitter* MCE =
+ getTarget().get()->createMCCodeEmitter(MII, MRI, STI, *Context);
// MCAsmBackend
MCAsmBackend* MAB = getTarget().get()->createMCAsmBackend(m_Triple);
@@ -342,50 +348,10 @@
MCLDFile::Type pOutputLinkType,
llvm::MCContext *&Context)
{
-// FIXME: when MCLinker can directly turn bitcode into shared object, turn on this
-// block of code.
-#if 0
- // Initialize MCAsmStreamer first, than chain its output into SectLinker.
- // MCCodeEmitter
- const MCSubtargetInfo &STI = getTM().getSubtarget<MCSubtargetInfo>();
- MCCodeEmitter* MCE = getTarget().get()->createMCCodeEmitter(*getTM().getInstrInfo(),
- STI,
- *Context);
- // MCAsmBackend
- MCAsmBackend *MAB = getTarget().get()->createMCAsmBackend(m_Triple);
- if (MCE == 0 || MAB == 0)
- return true;
-
- // now, we have MCCodeEmitter and MCAsmBackend, we can create AsmStreamer.
- MCStreamer* AsmStreamer =
- getTarget().get()->createMCObjectStreamer(m_Triple,
- *Context,
- *MAB,
- llvm::nulls(),
- MCE,
- getTM().hasMCRelaxAll(),
- getTM().hasMCNoExecStack());
- if (0 == AsmStreamer)
- return true;
-
- AsmStreamer->InitSections();
- AsmPrinter* printer = getTarget().get()->createAsmPrinter(getTM(), *AsmStreamer);
- if (0 == printer)
- return true;
- pPM.add(printer);
-#endif
TargetLDBackend* ldBackend = getTarget().createLDBackend(m_Triple);
if (0 == ldBackend)
return true;
-// FIXME: when MCLinker can directly turn bitcode into shared object, turn on this
-// block of code.
-#if 0
- MCBitcodeInterceptor* objReader = new MCBitcodeInterceptor(
- static_cast<MCObjectStreamer&>(*AsmStreamer),
- *ldBackend,
- getLDInfo());
-#endif
// set up output's SOName
if (pOutputLinkType == MCLDFile::DynObj &&
pLinkerOpt->info().output().name().empty()) {
diff --git a/lib/CodeGen/SectLinker.cpp b/lib/CodeGen/SectLinker.cpp
index 4f32c4f..0e4c3ad 100644
--- a/lib/CodeGen/SectLinker.cpp
+++ b/lib/CodeGen/SectLinker.cpp
@@ -77,7 +77,7 @@
initializeInputTree(PosDepOpts);
initializeInputOutput(info);
// Now, all input arguments are prepared well, send it into MCLDDriver
- m_pLDDriver = new MCLDDriver(info, *m_pLDBackend);
+ m_pLDDriver = new MCLDDriver(info, *m_pLDBackend, *memAreaFactory());
return false;
}
@@ -133,16 +133,11 @@
return true;
- // 6. - read all sections
- if (!m_pLDDriver->readSections() ||
- !m_pLDDriver->mergeSections())
+ // 6. - merge all sections
+ if (!m_pLDDriver->mergeSections())
return true;
- // 7. - read all symbol tables of input files and resolve them
- if (!m_pLDDriver->readSymbolTables())
- return true;
-
- // 7.a - add standard symbols and target-dependent symbols
+ // 7. - add standard symbols and target-dependent symbols
// m_pLDDriver->addUndefSymbols();
if (!m_pLDDriver->addStandardSymbols() ||
!m_pLDDriver->addTargetSymbols())
@@ -157,7 +152,7 @@
// 10. - linear layout
m_pLDDriver->layout();
- // 10.b - post-layout
+ // 10.b - post-layout (create segment, instruction relaxing)
m_pLDDriver->postlayout();
// 11. - finalize symbol value
diff --git a/lib/LD/AlignFragment.cpp b/lib/LD/AlignFragment.cpp
new file mode 100644
index 0000000..5154b0b
--- /dev/null
+++ b/lib/LD/AlignFragment.cpp
@@ -0,0 +1,27 @@
+//===- AlignFragment.cpp --------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/AlignFragment.h>
+
+#include <mcld/LD/SectionData.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// AlignFragment
+//===----------------------------------------------------------------------===//
+AlignFragment::AlignFragment(unsigned int pAlignment,
+ int64_t pValue,
+ unsigned int pValueSize,
+ unsigned int pMaxBytesToEmit,
+ SectionData *pSD)
+ : Fragment(Fragment::Alignment, pSD), m_Alignment(pAlignment),
+ m_Value(pValue), m_ValueSize(pValueSize), m_MaxBytesToEmit(pMaxBytesToEmit),
+ m_bEmitNops(false) {
+}
+
diff --git a/lib/LD/Android.mk b/lib/LD/Android.mk
index d7cccfa..d3c9dd8 100644
--- a/lib/LD/Android.mk
+++ b/lib/LD/Android.mk
@@ -5,6 +5,8 @@
# =====================================================
mcld_ld_SRC_FILES := \
+ AlignFragment.cpp \
+ Archive.cpp \
ArchiveReader.cpp \
BranchIsland.cpp \
CIE.cpp \
@@ -22,6 +24,9 @@
EhFrameHdr.cpp \
ExecWriter.cpp \
FDE.cpp \
+ FillFragment.cpp \
+ Fragment.cpp \
+ FragmentRef.cpp \
Layout.cpp \
LDContext.cpp \
LDFileFormat.cpp \
@@ -33,11 +38,13 @@
MsgHandler.cpp \
NamePool.cpp \
ObjectWriter.cpp \
+ RegionFragment.cpp \
Relocation.cpp \
RelocationFactory.cpp \
ResolveInfo.cpp \
ResolveInfoFactory.cpp \
Resolver.cpp \
+ SectionData.cpp \
SectionMap.cpp \
SectionMerger.cpp \
StaticResolver.cpp \
diff --git a/lib/LD/Archive.cpp b/lib/LD/Archive.cpp
new file mode 100644
index 0000000..2805541
--- /dev/null
+++ b/lib/LD/Archive.cpp
@@ -0,0 +1,229 @@
+//===- Archive.cpp --------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/Archive.h>
+#include <mcld/MC/InputFactory.h>
+#include <llvm/ADT/StringRef.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// Archive
+const char Archive::MAGIC[] = "!<arch>\n";
+const char Archive::THIN_MAGIC[] = "!<thin>\n";
+const size_t Archive::MAGIC_LEN = sizeof(Archive::MAGIC) - 1;
+const char Archive::SVR4_SYMTAB_NAME[] = "/ ";
+const char Archive::STRTAB_NAME[] = "// ";
+const char Archive::PAD[] = "\n";
+const char Archive::MEMBER_MAGIC[] = "`\n";
+
+Archive::Archive(Input& pInputFile, InputFactory& pInputFactory)
+ : m_ArchiveFile(pInputFile),
+ m_pInputTree(NULL),
+ m_SymbolFactory(32)
+{
+ m_pInputTree = new InputTree(pInputFactory);
+}
+
+Archive::~Archive()
+{
+ delete m_pInputTree;
+}
+
+/// getARFile - get the Input& of the archive file
+Input& Archive::getARFile()
+{
+ return m_ArchiveFile;
+}
+
+/// getARFile - get the Input& of the archive file
+const Input& Archive::getARFile() const
+{
+ return m_ArchiveFile;
+}
+
+/// inputs - get the input tree built from this archive
+InputTree& Archive::inputs()
+{
+ return *m_pInputTree;
+}
+
+/// inputs - get the input tree built from this archive
+const InputTree& Archive::inputs() const
+{
+ return *m_pInputTree;
+}
+
+/// getObjectMemberMap - get the map that contains the included object files
+Archive::ObjectMemberMapType& Archive::getObjectMemberMap()
+{
+ return m_ObjectMemberMap;
+}
+
+/// getObjectMemberMap - get the map that contains the included object files
+const Archive::ObjectMemberMapType& Archive::getObjectMemberMap() const
+{
+ return m_ObjectMemberMap;
+}
+
+/// numOfObjectMember - return the number of included object files
+size_t Archive::numOfObjectMember() const
+{
+ return m_ObjectMemberMap.numOfEntries();
+}
+
+/// addObjectMember - add a object in the object member map
+/// @param pFileOffset - file offset in symtab represents a object file
+/// @param pIter - the iterator in the input tree built from this archive
+bool Archive::addObjectMember(uint32_t pFileOffset, InputTree::iterator pIter)
+{
+ bool exist;
+ ObjectMemberEntryType* entry = m_ObjectMemberMap.insert(pFileOffset, exist);
+ if (!exist)
+ entry->setValue(pIter);
+ return !exist;
+}
+
+/// hasObjectMember - check if a object file is included or not
+/// @param pFileOffset - file offset in symtab represents a object file
+bool Archive::hasObjectMember(uint32_t pFileOffset) const
+{
+ return (m_ObjectMemberMap.find(pFileOffset) != m_ObjectMemberMap.end());
+}
+
+/// getArchiveMemberMap - get the map that contains the included archive files
+Archive::ArchiveMemberMapType& Archive::getArchiveMemberMap()
+{
+ return m_ArchiveMemberMap;
+}
+
+/// getArchiveMemberMap - get the map that contains the included archive files
+const Archive::ArchiveMemberMapType& Archive::getArchiveMemberMap() const
+{
+ return m_ArchiveMemberMap;
+}
+
+/// addArchiveMember - add an archive in the archive member map
+/// @param pName - the name of the new archive member
+/// @param pLastPos - this records the point to insert the next node in the
+/// subtree of this archive member
+/// @param pMove - this records the direction to insert the next node in the
+/// subtree of this archive member
+bool Archive::addArchiveMember(const llvm::StringRef& pName,
+ InputTree::iterator pLastPos,
+ InputTree::Mover* pMove)
+{
+ bool exist;
+ ArchiveMemberEntryType* entry = m_ArchiveMemberMap.insert(pName, exist);
+ if (!exist) {
+ ArchiveMember& ar = entry->value();
+ ar.file = *pLastPos;
+ ar.lastPos = pLastPos;
+ ar.move = pMove;
+ }
+ return !exist;
+}
+
+/// hasArchiveMember - check if an archive file is included or not
+bool Archive::hasArchiveMember(const llvm::StringRef& pName) const
+{
+ return (m_ArchiveMemberMap.find(pName) != m_ArchiveMemberMap.end());
+}
+
+/// getArchiveMember - get a archive member
+Archive::ArchiveMember* Archive::getArchiveMember(const llvm::StringRef& pName)
+{
+ ArchiveMemberMapType::iterator it = m_ArchiveMemberMap.find(pName);
+ if (it != m_ArchiveMemberMap.end())
+ return &(it.getEntry()->value());
+ return NULL;
+}
+
+/// getSymbolTable - get the symtab
+Archive::SymTabType& Archive::getSymbolTable()
+{
+ return m_SymTab;
+}
+
+/// getSymbolTable - get the symtab
+const Archive::SymTabType& Archive::getSymbolTable() const
+{
+ return m_SymTab;
+}
+
+/// setSymTabSize - set the memory size of symtab
+void Archive::setSymTabSize(size_t pSize)
+{
+ m_SymTabSize = pSize;
+}
+
+/// getSymTabSize - get the memory size of symtab
+size_t Archive::getSymTabSize() const
+{
+ return m_SymTabSize;
+}
+
+/// numOfSymbols - return the number of symbols in symtab
+size_t Archive::numOfSymbols() const
+{
+ return m_SymTab.size();
+}
+
+/// addSymbol - add a symtab entry to symtab
+/// @param pName - symbol name
+/// @param pFileOffset - file offset in symtab represents a object file
+void Archive::addSymbol(const char* pName,
+ uint32_t pFileOffset,
+ enum Archive::Symbol::Status pStatus)
+{
+ Symbol* entry = m_SymbolFactory.allocate();
+ new (entry) Symbol(pName, pFileOffset, pStatus);
+ m_SymTab.push_back(entry);
+}
+
+/// getSymbolName - get the symbol name with the given index
+const std::string& Archive::getSymbolName(size_t pSymIdx) const
+{
+ assert(pSymIdx < numOfSymbols());
+ return m_SymTab[pSymIdx]->name;
+}
+
+/// getObjFileOffset - get the file offset that represent a object file
+uint32_t Archive::getObjFileOffset(size_t pSymIdx) const
+{
+ assert(pSymIdx < numOfSymbols());
+ return m_SymTab[pSymIdx]->fileOffset;
+}
+
+/// getSymbolStatus - get the status of a symbol
+enum Archive::Symbol::Status Archive::getSymbolStatus(size_t pSymIdx) const
+{
+ assert(pSymIdx < numOfSymbols());
+ return m_SymTab[pSymIdx]->status;
+}
+
+/// setSymbolStatus - set the status of a symbol
+void Archive::setSymbolStatus(size_t pSymIdx,
+ enum Archive::Symbol::Status pStatus)
+{
+ assert(pSymIdx < numOfSymbols());
+ m_SymTab[pSymIdx]->status = pStatus;
+}
+
+/// getStrTable - get the extended name table
+std::string& Archive::getStrTable()
+{
+ return m_StrTab;
+}
+
+/// getStrTable - get the extended name table
+const std::string& Archive::getStrTable() const
+{
+ return m_StrTab;
+}
+
diff --git a/lib/LD/BSDArchiveReader.cpp b/lib/LD/BSDArchiveReader.cpp
index 079153b..bd59844 100644
--- a/lib/LD/BSDArchiveReader.cpp
+++ b/lib/LD/BSDArchiveReader.cpp
@@ -7,8 +7,8 @@
//
//===----------------------------------------------------------------------===//
#include <mcld/MC/MCLDInput.h>
-#include <mcld/MC/InputTree.h>
#include <mcld/LD/BSDArchiveReader.h>
+#include <mcld/LD/Archive.h>
using namespace mcld;
@@ -20,10 +20,10 @@
{
}
-InputTree *BSDArchiveReader::readArchive(Input &input)
+bool BSDArchiveReader::readArchive(Archive& pArchive)
{
// TODO
- return NULL;
+ return true;
}
bool BSDArchiveReader::isMyFormat(Input& pInput) const
diff --git a/lib/LD/CIE.cpp b/lib/LD/CIE.cpp
index c2f4317..5ddb166 100644
--- a/lib/LD/CIE.cpp
+++ b/lib/LD/CIE.cpp
@@ -11,11 +11,11 @@
using namespace mcld;
-//==========================
+//===----------------------------------------------------------------------===//
// CIE
-
+//===----------------------------------------------------------------------===//
CIE::CIE(MemoryRegion& pRegion, uint8_t pFDEEncode)
- : MCRegionFragment(pRegion), m_FDEEncoding(pFDEEncode) {
+ : RegionFragment(pRegion), m_FDEEncoding(pFDEEncode) {
}
CIE::~CIE()
diff --git a/lib/LD/DiagnosticEngine.cpp b/lib/LD/DiagnosticEngine.cpp
index 8b209c9..173b4f2 100644
--- a/lib/LD/DiagnosticEngine.cpp
+++ b/lib/LD/DiagnosticEngine.cpp
@@ -25,9 +25,6 @@
{
if (m_OwnPrinter && m_pPrinter != NULL)
delete m_pPrinter;
-
- if (NULL != m_pLineInfo)
- delete m_pLineInfo;
}
void DiagnosticEngine::reset(const MCLDInfo& pLDInfo)
diff --git a/lib/LD/ELFObjectReader.cpp b/lib/LD/ELFObjectReader.cpp
index c69149c..e645567 100644
--- a/lib/LD/ELFObjectReader.cpp
+++ b/lib/LD/ELFObjectReader.cpp
@@ -6,20 +6,21 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <llvm/Support/ELF.h>
-#include <llvm/ADT/Twine.h>
-#include <mcld/LD/ELFObjectReader.h>
-#include <mcld/LD/ELFReader.h>
-#include <mcld/MC/MCLDInput.h>
-#include <mcld/MC/MCLinker.h>
-#include <mcld/MC/MCRegionFragment.h>
-#include <mcld/Target/GNULDBackend.h>
-#include <mcld/Support/MsgHandling.h>
#include <string>
#include <cassert>
-using namespace llvm;
+#include <llvm/Support/ELF.h>
+#include <llvm/ADT/Twine.h>
+
+#include <mcld/MC/MCLDInput.h>
+#include <mcld/MC/MCLinker.h>
+#include <mcld/LD/RegionFragment.h>
+#include <mcld/LD/ELFReader.h>
+#include <mcld/LD/ELFObjectReader.h>
+#include <mcld/Target/GNULDBackend.h>
+#include <mcld/Support/MsgHandling.h>
+
using namespace mcld;
//==========================
@@ -176,10 +177,9 @@
llvm::ELF::SHT_NOBITS,
llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE);
- llvm::MCSectionData& sect_data = m_Linker.getOrCreateSectData(**section);
- /* value, valsize, size*/
- llvm::MCFillFragment* frag =
- new llvm::MCFillFragment(0x0, 1, (*section)->size());
+ SectionData& sect_data = m_Linker.getOrCreateSectData(**section);
+ /* value, valsize, size*/
+ FillFragment* frag = new FillFragment(0x0, 1, (*section)->size());
uint64_t size = m_Linker.getLayout().appendFragment(*frag,
sect_data,
diff --git a/lib/LD/ELFReader.cpp b/lib/LD/ELFReader.cpp
index d74d314..fce4e8b 100644
--- a/lib/LD/ELFReader.cpp
+++ b/lib/LD/ELFReader.cpp
@@ -11,6 +11,7 @@
#include <llvm/ADT/Twine.h>
#include <llvm/Support/ELF.h>
#include <llvm/Support/Host.h>
+
#include <mcld/MC/MCLinker.h>
#include <mcld/LD/ELFReader.h>
#include <mcld/Target/GNULDBackend.h>
@@ -86,6 +87,21 @@
return LDFileFormat::MetaData;
}
+/// getSymType
+ResolveInfo::Type ELFReaderIF::getSymType(uint8_t pInfo, uint16_t pShndx) const
+{
+ ResolveInfo::Type result = static_cast<ResolveInfo::Type>(pInfo & 0xF);
+ if (llvm::ELF::SHN_ABS == pShndx && ResolveInfo::Section == result) {
+ // In Mips, __gp_disp is a special section symbol. Its name comes from
+ // .strtab, not .shstrtab. However, it is unique. Only it is also a ABS
+ // symbol. So here is a tricky to identify __gp_disp and convert it to
+ // Object symbol.
+ return ResolveInfo::Object;
+ }
+
+ return result;
+}
+
/// getSymDesc
ResolveInfo::Desc ELFReaderIF::getSymDesc(uint16_t pShndx, const Input& pInput) const
{
@@ -135,7 +151,7 @@
}
/// getSymFragmentRef
-MCFragmentRef*
+FragmentRef*
ELFReaderIF::getSymFragmentRef(Input& pInput,
MCLinker& pLinker,
uint16_t pShndx,
@@ -151,7 +167,7 @@
unreachable(diag::unreachable_invalid_section_idx) << pShndx
<< pInput.path().native();
- MCFragmentRef* result = pLinker.getLayout().getFragmentRef(*sect_hdr, pOffset);
+ FragmentRef* result = pLinker.getLayout().getFragmentRef(*sect_hdr, pOffset);
return result;
}
diff --git a/lib/LD/ELFSectionMap.cpp b/lib/LD/ELFSectionMap.cpp
new file mode 100644
index 0000000..9d433d7
--- /dev/null
+++ b/lib/LD/ELFSectionMap.cpp
@@ -0,0 +1,87 @@
+//===- ELFSectionMap.cpp --------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/LD/ELFSectionMap.h>
+
+using namespace mcld;
+
+struct NameMap {
+ const char* from;
+ const char* to;
+};
+
+// Common mappings of ELF and other formants. Now only ELF specific mappings
+// are added
+static const NameMap map[] =
+{
+ {".text", ".text"},
+ {".rodata", ".rodata"},
+ {".data.rel.ro.local", ".data.rel.ro.local"},
+ {".data.rel.ro", ".data.rel.ro"},
+ {".data", ".data"},
+ {".bss", ".bss"},
+ {".tdata", ".tdata"},
+ {".tbss", ".tbss"},
+ {".init_array", ".init_array"},
+ {".fini_array", ".fini_array"},
+ // TODO: Support DT_INIT_ARRAY for all constructors?
+ {".ctors", ".ctors"},
+ {".dtors", ".dtors"},
+ {".sdata", ".sdata"},
+ {".sbss", ".sbss"},
+ // FIXME: in GNU ld, if we are creating a shared object .sdata2 and .sbss2
+ // sections would be handled differently.
+ {".sdata2", ".sdata"},
+ {".sbss2", ".sbss"},
+ {".lrodata", ".lrodata"},
+ {".ldata", ".ldata"},
+ {".lbss", ".lbss"},
+ {".gcc_except_table", ".gcc_except_table"},
+ {".gnu.linkonce.d.rel.ro.local", ".data.rel.ro.local"},
+ {".gnu.linkonce.d.rel.ro", ".data.rel.ro"},
+ {".gnu.linkonce.t", ".text"},
+ {".gnu.linkonce.r", ".rodata"},
+ {".gnu.linkonce.d", ".data"},
+ {".gnu.linkonce.b", ".bss"},
+ {".gnu.linkonce.s", ".sdata"},
+ {".gnu.linkonce.sb", ".sbss"},
+ {".gnu.linkonce.s2", ".sdata"},
+ {".gnu.linkonce.sb2", ".sbss"},
+ {".gnu.linkonce.wi", ".debug_info"},
+ {".gnu.linkonce.td", ".tdata"},
+ {".gnu.linkonce.tb", ".tbss"},
+ {".gnu.linkonce.lr", ".lrodata"},
+ {".gnu.linkonce.l", ".ldata"},
+ {".gnu.linkonce.lb", ".lbss"},
+};
+
+static const int map_size = (sizeof(map) / sizeof(map[0]));
+
+ELFSectionMap::ELFSectionMap()
+{
+}
+
+ELFSectionMap::~ELFSectionMap()
+{
+}
+
+void ELFSectionMap::initStandardMaps()
+{
+ for (unsigned int i = 0; i < map_size; ++i) {
+ bool exist = false;
+ NamePair& pair = append(map[i].from, map[i].to, exist);
+ if (exist) {
+ warning(diag::warn_duplicate_std_sectmap) << map[i].from
+ << map[i].to
+ << pair.from
+ << pair.to;
+ }
+ }
+}
+
diff --git a/lib/LD/ELFWriter.cpp b/lib/LD/ELFWriter.cpp
index 2f2d898..bf3152a 100644
--- a/lib/LD/ELFWriter.cpp
+++ b/lib/LD/ELFWriter.cpp
@@ -6,14 +6,19 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
+#include <cstdlib>
+#include <cstring>
+
#include <llvm/Support/ELF.h>
-#include <llvm/Support/ErrorHandling.h>
-#include <llvm/MC/MCAssembler.h>
+#include <llvm/Support/Casting.h>
+
#include <mcld/ADT/SizeTraits.h>
-#include <mcld/Support/MemoryRegion.h>
#include <mcld/MC/MCLDInfo.h>
#include <mcld/MC/MCLinker.h>
-#include <mcld/MC/MCRegionFragment.h>
+#include <mcld/LD/AlignFragment.h>
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/RegionFragment.h>
#include <mcld/LD/ELFWriter.h>
#include <mcld/LD/LDSymbol.h>
#include <mcld/LD/LDSection.h>
@@ -21,8 +26,7 @@
#include <mcld/LD/ELFSegment.h>
#include <mcld/LD/ELFSegmentFactory.h>
#include <mcld/Target/GNULDBackend.h>
-#include <cstdlib>
-#include <cstring>
+#include <mcld/Support/MemoryRegion.h>
using namespace llvm::ELF;
using namespace mcld;
@@ -397,21 +401,21 @@
const LDSection& pSection,
MemoryRegion& pRegion) const
{
- const llvm::MCSectionData* data = pSection.getSectionData();
- llvm::MCSectionData::const_iterator fragIter, fragEnd = data->end();
+ const SectionData* data = pSection.getSectionData();
+ SectionData::const_iterator fragIter, fragEnd = data->end();
size_t cur_offset = 0;
for (fragIter = data->begin(); fragIter != fragEnd; ++fragIter) {
size_t size = computeFragmentSize(pLayout, *fragIter);
switch(fragIter->getKind()) {
- case llvm::MCFragment::FT_Region: {
- const MCRegionFragment& region_frag = llvm::cast<MCRegionFragment>(*fragIter);
+ case Fragment::Region: {
+ const RegionFragment& region_frag = llvm::cast<RegionFragment>(*fragIter);
const uint8_t* from = region_frag.getRegion().start();
memcpy(pRegion.getBuffer(cur_offset), from, size);
break;
}
- case llvm::MCFragment::FT_Align: {
+ case Fragment::Alignment: {
// TODO: emit values with different sizes (> 1 byte), and emit nops
- llvm::MCAlignFragment& align_frag = llvm::cast<llvm::MCAlignFragment>(*fragIter);
+ AlignFragment& align_frag = llvm::cast<AlignFragment>(*fragIter);
uint64_t count = size / align_frag.getValueSize();
switch (align_frag.getValueSize()) {
case 1u:
@@ -425,8 +429,8 @@
}
break;
}
- case llvm::MCFragment::FT_Fill: {
- llvm::MCFillFragment& fill_frag = llvm::cast<llvm::MCFillFragment>(*fragIter);
+ case Fragment::Fillment: {
+ FillFragment& fill_frag = llvm::cast<FillFragment>(*fragIter);
if (0 == size ||
0 == fill_frag.getValueSize() ||
0 == fill_frag.getSize()) {
@@ -442,19 +446,10 @@
}
break;
}
- case llvm::MCFragment::FT_Data:
- case llvm::MCFragment::FT_Inst:
- case llvm::MCFragment::FT_Org:
- case llvm::MCFragment::FT_Dwarf:
- case llvm::MCFragment::FT_DwarfFrame:
- case llvm::MCFragment::FT_LEB: {
- llvm::report_fatal_error("unsupported fragment yet.\n");
- break;
- }
- case llvm::MCFragment::FT_Reloc:
+ case Fragment::Relocation:
llvm::report_fatal_error("relocation fragment should not be in a regular section.\n");
break;
- case llvm::MCFragment::FT_Target:
+ case Fragment::Target:
llvm::report_fatal_error("Target fragment should not be in a regular section.\n");
break;
default:
@@ -471,13 +466,13 @@
const LDSection& pSection,
MemoryRegion& pRegion) const
{
- const llvm::MCSectionData* SectionData = pSection.getSectionData();
- assert(SectionData && "SectionData is NULL in emitRelocation!");
+ const SectionData* sect_data = pSection.getSectionData();
+ assert(NULL != sect_data && "SectionData is NULL in emitRelocation!");
if (pSection.type() == SHT_REL)
- emitRel(pLayout, pOutput, *SectionData, pRegion);
+ emitRel(pLayout, pOutput, *sect_data, pRegion);
else if (pSection.type() == SHT_RELA)
- emitRela(pLayout, pOutput, *SectionData, pRegion);
+ emitRela(pLayout, pOutput, *sect_data, pRegion);
else
llvm::report_fatal_error("unsupported relocation section type!");
}
@@ -486,31 +481,29 @@
/// emitRel
void ELFWriter::emitRel(const Layout& pLayout,
const Output& pOutput,
- const llvm::MCSectionData& pSectionData,
+ const SectionData& pSectionData,
MemoryRegion& pRegion) const
{
Elf32_Rel* rel = reinterpret_cast<Elf32_Rel*>(pRegion.start());
Relocation* relocation = 0;
- MCFragmentRef* FragmentRef = 0;
+ FragmentRef* frag_ref = 0;
- for (llvm::MCSectionData::const_iterator it = pSectionData.begin(),
+ for (SectionData::const_iterator it = pSectionData.begin(),
ie = pSectionData.end(); it != ie; ++it, ++rel) {
relocation = &(llvm::cast<Relocation>(*it));
- FragmentRef = &(relocation->targetRef());
+ frag_ref = &(relocation->targetRef());
if(pOutput.type() == Output::DynObj || pOutput.type() == Output::Exec) {
rel->r_offset = static_cast<Elf32_Addr>(
- llvm::cast<LDSection>(
- FragmentRef->frag()->getParent()->getSection()).addr() +
- pLayout.getOutputOffset(*FragmentRef));
+ frag_ref->frag()->getParent()->getSection().addr() +
+ pLayout.getOutputOffset(*frag_ref));
}
else {
rel->r_offset = static_cast<Elf32_Addr>(
- llvm::cast<LDSection>(
- FragmentRef->frag()->getParent()->getSection()).offset() +
- pLayout.getOutputOffset(*FragmentRef));
+ frag_ref->frag()->getParent()->getSection().offset() +
+ pLayout.getOutputOffset(*frag_ref));
}
Elf32_Word Index;
@@ -527,31 +520,29 @@
/// emitRela
void ELFWriter::emitRela(const Layout& pLayout,
const Output& pOutput,
- const llvm::MCSectionData& pSectionData,
+ const SectionData& pSectionData,
MemoryRegion& pRegion) const
{
Elf32_Rela* rel = reinterpret_cast<Elf32_Rela*>(pRegion.start());
Relocation* relocation = 0;
- MCFragmentRef* FragmentRef = 0;
+ FragmentRef* frag_ref = 0;
- for (llvm::MCSectionData::const_iterator it = pSectionData.begin(),
+ for (SectionData::const_iterator it = pSectionData.begin(),
ie = pSectionData.end(); it != ie; ++it, ++rel) {
relocation = &(llvm::cast<Relocation>(*it));
- FragmentRef = &(relocation->targetRef());
+ frag_ref = &(relocation->targetRef());
if(pOutput.type() == Output::DynObj || pOutput.type() == Output::Exec) {
rel->r_offset = static_cast<Elf32_Addr>(
- llvm::cast<LDSection>(
- FragmentRef->frag()->getParent()->getSection()).addr() +
- pLayout.getOutputOffset(*FragmentRef));
+ frag_ref->frag()->getParent()->getSection().addr() +
+ pLayout.getOutputOffset(*frag_ref));
}
else {
rel->r_offset = static_cast<Elf32_Addr>(
- llvm::cast<LDSection>(
- FragmentRef->frag()->getParent()->getSection()).offset() +
- pLayout.getOutputOffset(*FragmentRef));
+ frag_ref->frag()->getParent()->getSection().offset() +
+ pLayout.getOutputOffset(*frag_ref));
}
Elf32_Word Index;
diff --git a/lib/LD/EhFrame.cpp b/lib/LD/EhFrame.cpp
index 4a84b00..bc5ed1d 100644
--- a/lib/LD/EhFrame.cpp
+++ b/lib/LD/EhFrame.cpp
@@ -6,13 +6,16 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#include <mcld/LD/EhFrame.h>
-#include <mcld/MC/MCLinker.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Target/TargetLDBackend.h>
+
#include <llvm/Support/Dwarf.h>
#include <llvm/Support/Host.h>
+#include <mcld/MC/MCLinker.h>
+#include <mcld/Target/TargetLDBackend.h>
+#include <mcld/Support/MsgHandling.h>
+
using namespace mcld;
//==========================
@@ -27,7 +30,7 @@
uint64_t EhFrame::readEhFrame(Layout& pLayout,
const TargetLDBackend& pBackend,
- llvm::MCSectionData& pSD,
+ SectionData& pSD,
const Input& pInput,
LDSection& pSection,
MemoryArea& pArea)
@@ -36,7 +39,6 @@
pInput.fileOffset() + pSection.offset(), pSection.size());
// an empty .eh_frame
if (NULL == region) {
- note(diag::note_ehframe) << "an empty eh_frame";
return 0;
}
@@ -50,13 +52,12 @@
// This CIE is a terminator if the Length field is 0, return 0 to handled it
// as an ordinary input.
if (0 == len) {
- note(diag::note_ehframe) << "a terminator";
pArea.release(region);
return 0;
}
if (0xffffffff == len) {
- debug(diag::debug_eh_unsupport) << "64-bit eh_frame";
+ debug(diag::debug_eh_unsupport) << pInput.name();
pArea.release(region);
m_fCanRecognizeAll = false;
return 0;
@@ -68,7 +69,7 @@
while (p < eh_end) {
if (eh_end - p < 4) {
- debug(diag::debug_eh_unsupport) << "CIE or FDE size smaller than 4";
+ debug(diag::debug_eh_unsupport) << pInput.name();
m_fCanRecognizeAll = false;
break;
}
@@ -79,20 +80,19 @@
// the zero length entry should be the end of the section
if (0 == len) {
if (p < eh_end) {
- debug(diag::debug_eh_unsupport) << "Non-end entry with zero length";
+ debug(diag::debug_eh_unsupport) << pInput.name();
m_fCanRecognizeAll = false;
}
break;
}
if (0xffffffff == len) {
- debug(diag::debug_eh_unsupport) << "64-bit eh_frame";
+ debug(diag::debug_eh_unsupport) << pInput.name();
m_fCanRecognizeAll = false;
break;
}
if (eh_end - p < 4) {
- debug(diag::debug_eh_unsupport) <<
- "CIE:ID field / FDE: CIE Pointer field";
+ debug(diag::debug_eh_unsupport) << pInput.name();
m_fCanRecognizeAll = false;
break;
}
@@ -127,6 +127,7 @@
}
if (!m_fCanRecognizeAll) {
+ debug(diag::debug_eh_unsupport) << pInput.name();
pArea.release(region);
deleteFragments(frag_list, pArea);
return 0;
@@ -156,7 +157,6 @@
// the version should be 1
if (1 != *p) {
- debug(diag::debug_eh_unsupport) << "CIE version";
return false;
}
++p;
@@ -171,17 +171,14 @@
// skip the Code Alignment Factor
if (!skipLEB128(&p, cie_end)) {
- debug(diag::debug_eh_unsupport) << "unrecognized Code Alignment Factor";
return false;
}
// skip the Data Alignment Factor
if (!skipLEB128(&p, cie_end)) {
- debug(diag::debug_eh_unsupport) << "unrecognized Data Alignment Factor";
return false;
}
// skip the Return Address Register
if (cie_end - p < 1) {
- debug(diag::debug_eh_unsupport) << "unrecognized Return Address Register";
return false;
}
++p;
@@ -189,7 +186,6 @@
// the Augmentation String start with 'eh' is a CIE from gcc before 3.0,
// in LSB Core Spec 3.0RC1. We do not support it.
if (aug_str[0] == 'e' && aug_str[1] == 'h') {
- debug(diag::debug_eh_unsupport) << "augmentation string `eh`";
return false;
}
@@ -203,21 +199,17 @@
// skip the Augumentation Data Length
if (!skipLEB128(&p, cie_end)) {
- debug(diag::debug_eh_unsupport) <<
- "unrecognized Augmentation Data Length";
return false;
}
while (aug_str != aug_str_end) {
switch (*aug_str) {
default:
- debug(diag::debug_eh_unsupport) << "augmentation string";
return false;
// LDSA encoding (1 byte)
case 'L':
if (cie_end - p < 1) {
- debug(diag::debug_eh_unsupport) << "augmentation string `L`";
return false;
}
++p;
@@ -229,7 +221,6 @@
case 'P': {
// the first argument
if (cie_end - p < 1) {
- debug(diag::debug_eh_unsupport) << "augmentation string `P`";
return false;
}
uint8_t per_encode = *p;
@@ -237,12 +228,10 @@
// get the length of the second argument
uint32_t per_length = 0;
if (0x60 == (per_encode & 0x60)) {
- debug(diag::debug_eh_unsupport) << "augmentation string `P`";
return false;
}
switch (per_encode & 7) {
default:
- debug(diag::debug_eh_unsupport) << "augmentation string `P`";
return false;
case llvm::dwarf::DW_EH_PE_udata2:
per_length = 2;
@@ -263,14 +252,12 @@
per_align += per_length - 1;
per_align &= ~(per_length -1);
if (static_cast<uint32_t>(cie_end - p) < per_align) {
- debug(diag::debug_eh_unsupport) << "augmentation string `P`";
return false;
}
p += per_align;
}
// skip the second argument
if (static_cast<uint32_t>(cie_end - p) < per_length) {
- debug(diag::debug_eh_unsupport) << "augmentation string `P`";
return false;
}
p += per_length;
@@ -280,7 +267,6 @@
// FDE encoding (1 byte)
case 'R':
if (cie_end - p < 1) {
- debug(diag::debug_eh_unsupport) << "augmentation string `R`";
return false;
}
fde_encoding = *p;
@@ -291,7 +277,6 @@
case llvm::dwarf::DW_EH_PE_absptr:
break;
default:
- debug(diag::debug_eh_unsupport) << "FDE encoding";
return false;
}
++p;
@@ -309,7 +294,7 @@
// create and push back the CIE entry
CIE* entry = new CIE(pRegion, fde_encoding);
m_CIEs.push_back(entry);
- pFragList.push_back(static_cast<llvm::MCFragment*>(entry));
+ pFragList.push_back(static_cast<Fragment*>(entry));
return true;
}
@@ -326,7 +311,6 @@
// get the entry offset of the PC Begin
if (fde_end - p < 1) {
- debug(diag::debug_eh_unsupport) << "FDE PC Begin";
return false;
}
FDE::Offset pc_offset = static_cast<FDE::Offset>(p - fde_start);
@@ -335,7 +319,7 @@
// create and push back the FDE entry
FDE* entry = new FDE(pRegion, **(m_CIEs.end() -1), pc_offset);
m_FDEs.push_back(entry);
- pFragList.push_back(static_cast<llvm::MCFragment*>(entry));
+ pFragList.push_back(static_cast<Fragment*>(entry));
return true;
}
@@ -363,9 +347,9 @@
void EhFrame::deleteFragments(FragListType& pList, MemoryArea& pArea)
{
- MCRegionFragment* frag = NULL;
+ RegionFragment* frag = NULL;
for (FragListType::iterator it = pList.begin(); it != pList.end(); ++it) {
- frag = static_cast<MCRegionFragment*>(*it);
+ frag = static_cast<RegionFragment*>(*it);
pArea.release(&(frag->getRegion()));
delete *it;
}
diff --git a/lib/LD/FDE.cpp b/lib/LD/FDE.cpp
index b70f7e1..1aa196b 100644
--- a/lib/LD/FDE.cpp
+++ b/lib/LD/FDE.cpp
@@ -6,19 +6,19 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/LD/EhFrame.h>
+
#include <mcld/LD/FDE.h>
+#include <mcld/LD/EhFrame.h>
using namespace mcld;
-//==========================
+//===----------------------------------------------------------------------===//
// FDE
-
+//===----------------------------------------------------------------------===//
FDE::FDE(MemoryRegion& pRegion, const CIE& pCIE, Offset pPCBeginOffset)
- : MCRegionFragment(pRegion), m_CIE(pCIE), m_PCBeginOffset(pPCBeginOffset) {
+ : RegionFragment(pRegion), m_CIE(pCIE), m_PCBeginOffset(pPCBeginOffset) {
}
FDE::~FDE()
{
}
-
diff --git a/lib/LD/FillFragment.cpp b/lib/LD/FillFragment.cpp
new file mode 100644
index 0000000..8f127ca
--- /dev/null
+++ b/lib/LD/FillFragment.cpp
@@ -0,0 +1,28 @@
+//===- FillFragment.cpp ---------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/SectionData.h>
+#include <cassert>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// FillFragment
+//===----------------------------------------------------------------------===//
+FillFragment::FillFragment(int64_t pValue,
+ unsigned int pValueSize,
+ uint64_t pSize,
+ SectionData* pSD)
+ : Fragment(Fragment::Fillment, pSD), m_Value(pValue), m_ValueSize(pValueSize),
+ m_Size(pSize) {
+ assert((!m_ValueSize || (m_Size % m_ValueSize) == 0) &&
+ "Fill size must be a multiple of the value size!");
+}
+
diff --git a/lib/LD/Fragment.cpp b/lib/LD/Fragment.cpp
new file mode 100644
index 0000000..6e1e3a7
--- /dev/null
+++ b/lib/LD/Fragment.cpp
@@ -0,0 +1,34 @@
+//===- Fragment.cpp -------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <mcld/LD/Fragment.h>
+
+#include <llvm/Support/DataTypes.h>
+
+#include <mcld/LD/SectionData.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// Fragment
+//===----------------------------------------------------------------------===//
+Fragment::Fragment()
+ : m_Kind(Type(~0)), m_pParent(NULL), m_Offset(~uint64_t(0)), m_LayoutOrder(~(0U)) {
+}
+
+Fragment::Fragment(Type pKind, SectionData *pParent)
+ : m_Kind(pKind), m_pParent(pParent), m_Offset(~uint64_t(0)), m_LayoutOrder(~(0U)) {
+ if (NULL != m_pParent)
+ m_pParent->getFragmentList().push_back(this);
+}
+
+Fragment::~Fragment()
+{
+}
+
diff --git a/lib/LD/FragmentRef.cpp b/lib/LD/FragmentRef.cpp
new file mode 100644
index 0000000..9ae8e4d
--- /dev/null
+++ b/lib/LD/FragmentRef.cpp
@@ -0,0 +1,150 @@
+//===- FragmentRef.cpp --------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <mcld/LD/FragmentRef.h>
+
+#include <cstring>
+#include <cassert>
+
+#include <llvm/Support/MathExtras.h>
+#include <llvm/Support/Casting.h>
+
+#include <mcld/LD/AlignFragment.h>
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/RegionFragment.h>
+#include <mcld/LD/TargetFragment.h>
+#include <mcld/LD/Layout.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// Helper Functions
+//===----------------------------------------------------------------------===//
+/// compunteFragmentSize - compute the specific Fragment size
+uint64_t mcld::computeFragmentSize(const Layout& pLayout,
+ const Fragment& pFrag)
+{
+ switch (pFrag.getKind()) {
+ case Fragment::Fillment:
+ return static_cast<const FillFragment&>(pFrag).getSize();
+
+ case Fragment::Alignment: {
+ uint64_t offset = pLayout.getOutputOffset(pFrag);
+ const AlignFragment& align_frag = llvm::cast<AlignFragment>(pFrag);
+ uint64_t size = llvm::OffsetToAlignment(offset, align_frag.getAlignment());
+ if (size > align_frag.getMaxBytesToEmit())
+ return 0;
+ return size;
+ }
+
+ case Fragment::Region:
+ return llvm::cast<RegionFragment>(pFrag).getRegion().size();
+
+ case Fragment::Target:
+ return llvm::cast<TargetFragment>(pFrag).getSize();
+
+ case Fragment::Relocation:
+ assert(0 && "the size of FT_Reloc fragment is handled by backend");
+ return 0;
+
+ default:
+ assert(0 && "invalid fragment kind");
+ return 0;
+ }
+}
+
+//===----------------------------------------------------------------------===//
+// FragmentRef
+//===----------------------------------------------------------------------===//
+FragmentRef::FragmentRef()
+ : m_pFragment(NULL), m_Offset(0) {
+}
+
+FragmentRef::FragmentRef(Fragment& pFrag,
+ FragmentRef::Offset pOffset)
+ : m_pFragment(&pFrag), m_Offset(pOffset) {
+}
+
+FragmentRef::~FragmentRef()
+{
+ m_pFragment = NULL;
+ m_Offset = 0;
+}
+
+FragmentRef& FragmentRef::assign(const FragmentRef& pCopy)
+{
+ m_pFragment = const_cast<Fragment*>(pCopy.m_pFragment);
+ m_Offset = pCopy.m_Offset;
+ return *this;
+}
+
+FragmentRef& FragmentRef::assign(Fragment& pFrag, FragmentRef::Offset pOffset)
+{
+ m_pFragment = &pFrag;
+ m_Offset = pOffset;
+ return *this;
+}
+
+void FragmentRef::memcpy(void* pDest, size_t pNBytes, Offset pOffset) const
+{
+ // check if the offset is still in a legal range.
+ if (NULL == m_pFragment)
+ return;
+ unsigned int total_offset = m_Offset + pOffset;
+ switch(m_pFragment->getKind()) {
+ case Fragment::Region: {
+ RegionFragment* region_frag = static_cast<RegionFragment*>(m_pFragment);
+ unsigned int total_length = region_frag->getRegion().size();
+ if (total_length < (total_offset+pNBytes))
+ pNBytes = total_length - total_offset;
+
+ std::memcpy(pDest, region_frag->getRegion().getBuffer(total_offset), pNBytes);
+ return;
+ }
+ case Fragment::Alignment:
+ case Fragment::Fillment:
+ default:
+ return;
+ }
+}
+
+FragmentRef::Address FragmentRef::deref()
+{
+ if (NULL == m_pFragment)
+ return NULL;
+ Address base = NULL;
+ switch(m_pFragment->getKind()) {
+ case Fragment::Region:
+ base = static_cast<RegionFragment*>(m_pFragment)->getRegion().getBuffer();
+ break;
+ case Fragment::Alignment:
+ case Fragment::Fillment:
+ default:
+ return NULL;
+ }
+ return base + m_Offset;
+}
+
+FragmentRef::ConstAddress FragmentRef::deref() const
+{
+ if (NULL == m_pFragment)
+ return NULL;
+ ConstAddress base = NULL;
+ switch(m_pFragment->getKind()) {
+ case Fragment::Region:
+ base = static_cast<const RegionFragment*>(m_pFragment)->getRegion().getBuffer();
+ break;
+ case Fragment::Alignment:
+ case Fragment::Fillment:
+ default:
+ return NULL;
+ }
+ return base + m_Offset;
+}
+
diff --git a/lib/LD/GNUArchiveReader.cpp b/lib/LD/GNUArchiveReader.cpp
index 0a64752..55c8c76 100644
--- a/lib/LD/GNUArchiveReader.cpp
+++ b/lib/LD/GNUArchiveReader.cpp
@@ -10,343 +10,384 @@
#include <mcld/MC/MCLDInput.h>
#include <mcld/MC/InputTree.h>
#include <mcld/LD/GNUArchiveReader.h>
+#include <mcld/LD/ResolveInfo.h>
+#include <mcld/LD/ELFObjectReader.h>
#include <mcld/Support/FileSystem.h>
+#include <mcld/Support/FileHandle.h>
#include <mcld/Support/MemoryArea.h>
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MemoryAreaFactory.h>
#include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/Path.h>
#include <mcld/ADT/SizeTraits.h>
-#include <llvm/Support/system_error.h>
+#include <llvm/ADT/StringRef.h>
#include <llvm/Support/Host.h>
-#include <sstream>
-#include <string>
-#include <vector>
+#include <cstring>
#include <cstdlib>
using namespace mcld;
-typedef uint32_t elfWord;
-
-
-/// Archive Header, Magic number
-const char GNUArchiveReader::ArchiveMagic[ArchiveMagicSize] = { '!', '<', 'a', 'r', 'c', 'h', '>', '\n' };
-const char GNUArchiveReader::ThinArchiveMagic[ArchiveMagicSize] = { '!', '<', 't', 'h', 'i', 'n', '>', '\n' };
-const char GNUArchiveReader::HeaderFinalMagic[HeaderFinalMagicSize] = { '`', '\n' };
-
-
-struct GNUArchiveReader::SymbolTableEntry
+GNUArchiveReader::GNUArchiveReader(MCLDInfo& pLDInfo,
+ MemoryAreaFactory& pMemAreaFactory,
+ ELFObjectReader& pELFObjectReader)
+ : m_LDInfo(pLDInfo),
+ m_MemAreaFactory(pMemAreaFactory),
+ m_ELFObjectReader(pELFObjectReader)
{
- off_t fileOffset;
- std::string name;
-};
-
-
-
-/// convert string to size_t
-template<class Type>
-Type stringToType(const std::string &str)
-{
- Type n;
- std::stringstream ss(str);
- ss >> n;
- return n;
}
+GNUArchiveReader::~GNUArchiveReader()
+{
+}
-/// GNUArchiveReader Operations
-/// Public API
-bool GNUArchiveReader::isMyFormat(Input &pInput) const
+/// isMyFormat
+bool GNUArchiveReader::isMyFormat(Input& pInput) const
{
assert(pInput.hasMemArea());
+ MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
+ Archive::MAGIC_LEN);
+ const char* str = reinterpret_cast<const char*>(region->getBuffer());
- MemoryRegion *region = pInput.memArea()->request(0, ArchiveMagicSize);
- if (!region)
- llvm::report_fatal_error("can't request MemoryRegion for archive magic");
+ bool result = false;
+ assert(NULL != str);
+ if (isArchive(str) || isThinArchive(str))
+ result = true;
- const char *p_buffer = reinterpret_cast<char *> (region->getBuffer());
+ pInput.memArea()->release(region);
+ return result;
+}
- /// check archive format.
- if (memcmp(p_buffer, ArchiveMagic, ArchiveMagicSize) != 0
- && memcmp(p_buffer, ThinArchiveMagic, ArchiveMagicSize) != 0) {
- return false;
- }
+/// isArchive
+bool GNUArchiveReader::isArchive(const char* pStr) const
+{
+ return (0 == memcmp(pStr, Archive::MAGIC, Archive::MAGIC_LEN));
+}
+
+/// isThinArchive
+bool GNUArchiveReader::isThinArchive(const char* pStr) const
+{
+ return (0 == memcmp(pStr, Archive::THIN_MAGIC, Archive::MAGIC_LEN));
+}
+
+/// isThinArchive
+bool GNUArchiveReader::isThinArchive(Input& pInput) const
+{
+ assert(pInput.hasMemArea());
+ MemoryRegion* region = pInput.memArea()->request(pInput.fileOffset(),
+ Archive::MAGIC_LEN);
+ const char* str = reinterpret_cast<const char*>(region->getBuffer());
+
+ bool result = false;
+ assert(NULL != str);
+ if (isThinArchive(str))
+ result = true;
+
+ pInput.memArea()->release(region);
+ return result;
+}
+
+bool GNUArchiveReader::readArchive(Archive& pArchive)
+{
+ // read the symtab of the archive
+ readSymbolTable(pArchive);
+
+ // read the strtab of the archive
+ readStringTable(pArchive);
+
+ // add root archive to ArchiveMemberMap
+ pArchive.addArchiveMember(pArchive.getARFile().name(),
+ pArchive.inputs().root(),
+ &InputTree::Downward);
+
+ // include the needed members in the archive and build up the input tree
+ bool willSymResolved;
+ do {
+ willSymResolved = false;
+ for (size_t idx = 0; idx < pArchive.numOfSymbols(); ++idx) {
+ // bypass if we already decided to include this symbol or not
+ if (Archive::Symbol::Unknown != pArchive.getSymbolStatus(idx))
+ continue;
+
+ // bypass if another symbol with the same object file offset is included
+ if (pArchive.hasObjectMember(pArchive.getObjFileOffset(idx))) {
+ pArchive.setSymbolStatus(idx, Archive::Symbol::Include);
+ continue;
+ }
+
+ // check if we should include this defined symbol
+ Archive::Symbol::Status status =
+ shouldIncludeSymbol(pArchive.getSymbolName(idx));
+ if (Archive::Symbol::Unknown != status)
+ pArchive.setSymbolStatus(idx, status);
+
+ if (Archive::Symbol::Include == status) {
+ Input* cur_archive = &(pArchive.getARFile());
+ Input* member = cur_archive;
+ uint32_t file_offset = pArchive.getObjFileOffset(idx);
+ while ((member != NULL) && (Input::Object != member->type())) {
+ uint32_t nested_offset = 0;
+ // use the file offset in current archive to find out the member we
+ // want to include
+ member = readMemberHeader(pArchive,
+ *cur_archive,
+ file_offset,
+ nested_offset);
+ assert(member != NULL);
+ // bypass if we get an archive that is already in the map
+ if (Input::Archive == member->type()) {
+ cur_archive = member;
+ file_offset = nested_offset;
+ continue;
+ }
+
+ // insert a node into the subtree of current archive.
+ Archive::ArchiveMember* parent =
+ pArchive.getArchiveMember(cur_archive->name());
+
+ assert(NULL != parent);
+ pArchive.inputs().insert(parent->lastPos, *(parent->move), *member);
+
+ // move the iterator to new created node, and also adjust the
+ // direction to Afterward for next insertion in this subtree
+ parent->move->move(parent->lastPos);
+ parent->move = &InputTree::Afterward;
+
+ if (m_ELFObjectReader.isMyFormat(*member)) {
+ member->setType(Input::Object);
+ pArchive.addObjectMember(pArchive.getObjFileOffset(idx),
+ parent->lastPos);
+ m_ELFObjectReader.readObject(*member);
+ m_ELFObjectReader.readSections(*member);
+ m_ELFObjectReader.readSymbols(*member);
+ }
+ else if (isMyFormat(*member)) {
+ member->setType(Input::Archive);
+ // when adding a new archive node, set the iterator to archive
+ // itself, and set the direction to Downward
+ pArchive.addArchiveMember(member->name(),
+ parent->lastPos,
+ &InputTree::Downward);
+ cur_archive = member;
+ file_offset = nested_offset;
+ }
+ } // end of while
+ willSymResolved = true;
+ } // end of if
+ } // end of for
+ } while (willSymResolved);
+
return true;
}
-LDReader::Endian GNUArchiveReader::endian(Input& pFile) const
+/// readMemberHeader - read the header of a member in a archive file and then
+/// return the corresponding archive member (it may be an input object or
+/// another archive)
+/// @param pArchiveRoot - the archive root that holds the strtab (extended
+/// name table)
+/// @param pArchiveFile - the archive that contains the needed object
+/// @param pFileOffset - file offset of the member header in the archive
+/// @param pNestedOffset - used when we find a nested archive
+Input* GNUArchiveReader::readMemberHeader(Archive& pArchiveRoot,
+ Input& pArchiveFile,
+ uint32_t pFileOffset,
+ uint32_t& pNestedOffset)
{
- return LDReader::BigEndian;
-}
+ assert(pArchiveFile.hasMemArea());
-InputTree *GNUArchiveReader::readArchive(Input &pInput)
-{
- return setupNewArchive(pInput, 0);
-}
+ MemoryRegion* header_region =
+ pArchiveFile.memArea()->request((pArchiveFile.fileOffset() + pFileOffset),
+ sizeof(Archive::MemberHeader));
+ const Archive::MemberHeader* header =
+ reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer());
-/// Read Input as archive. First create a null InputTree.
-/// Then Construct Input object for corresponding member of this archive
-/// and insert the Input object into the InputTree.
-/// Finally, return the InputTree.
-InputTree *GNUArchiveReader::setupNewArchive(Input &pInput,
- size_t off)
-{
- assert(pInput.hasMemArea());
- MemoryRegion *region = pInput.memArea()->request(off, ArchiveMagicSize);
+ assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, 2));
- if (!region)
- llvm::report_fatal_error("can't request MemoryRegion for archive magic");
+ // int size = atoi(header->size);
- const char *pFile = reinterpret_cast<char *> (region->getBuffer());
-
- /// check archive format.
- bool isThinArchive;
- isThinArchive = memcmp(pFile, ThinArchiveMagic, ArchiveMagicSize) == 0;
- if(!isThinArchive && memcmp(pFile, ArchiveMagic, ArchiveMagicSize) != 0)
- llvm::report_fatal_error("Fail : archive magic number is not matched");
-
- InputTree *resultTree = new InputTree(m_pLDInfo.inputFactory());
- std::vector<SymbolTableEntry> symbolTable;
- std::string archiveMemberName;
- std::string extendedName;
-
- off += ArchiveMagicSize ;
- size_t symbolTableSize = readMemberHeader(*pInput.memArea(), off, &archiveMemberName,
- NULL, extendedName);
- /// read archive symbol table
- if(archiveMemberName.empty())
- {
- readSymbolTable(*pInput.memArea(), symbolTable,
- off+sizeof(ArchiveMemberHeader), symbolTableSize);
- off = off + sizeof(ArchiveMemberHeader) + symbolTableSize;
+ // parse the member name and nested offset if any
+ std::string member_name;
+ llvm::StringRef name_field(header->name, 16);
+ if ('/' != header->name[0]) {
+ // this is an object file in an archive
+ size_t pos = name_field.find_first_of('/');
+ member_name.assign(name_field.substr(0, pos).str());
}
- else
- {
- llvm::report_fatal_error("fatal error : need symbol table\n");
- return NULL;
+ else {
+ // this is an object/archive file in a thin archive
+ size_t begin = 1;
+ size_t end = name_field.find_first_of(" :");
+ uint32_t name_offset = 0;
+ // parse the name offset
+ name_field.substr(begin, end - begin).getAsInteger(10, name_offset);
+
+ if (':' == name_field[end]) {
+ // there is a nested offset
+ begin = end + 1;
+ end = name_field.find_first_of(' ', begin);
+ name_field.substr(begin, end - begin).getAsInteger(10, pNestedOffset);
+ }
+
+ // get the member name from the extended name table
+ begin = name_offset;
+ end = pArchiveRoot.getStrTable().find_first_of('\n', begin);
+ member_name.assign(pArchiveRoot.getStrTable().substr(begin, end - begin -1));
}
- if((off&1) != 0)
- ++off;
-
- size_t extendedSize = readMemberHeader(*pInput.memArea(), off, &archiveMemberName,
- NULL, extendedName);
- /// read long Name table if exist
- if(archiveMemberName == "/")
- {
- off += sizeof(ArchiveMemberHeader);
- MemoryRegion *extended_name_region = pInput.memArea()->request(off, extendedSize);
- pFile = reinterpret_cast<char *>(extended_name_region->getBuffer());
- extendedName.assign(pFile, extendedSize);
-
+ Input* member = NULL;
+ if (!isThinArchive(pArchiveFile)) {
+ // this is an object file in an archive
+ member =
+ m_LDInfo.inputFactory().produce(member_name,
+ pArchiveFile.path(),
+ Input::Unknown,
+ (pFileOffset +
+ sizeof(Archive::MemberHeader)));
+ assert(member != NULL);
+ member->setMemArea(pArchiveFile.memArea());
+ LDContext *input_context = m_LDInfo.contextFactory().produce();
+ member->setContext(input_context);
}
+ else {
+ // this is a member in a thin archive
+ // try to find if this is a archive already in the map first
+ Archive::ArchiveMember* ar_member =
+ pArchiveRoot.getArchiveMember(member_name);
+ if (NULL != ar_member) {
+ return ar_member->file;
+ }
- /// traverse all the archive members
- InputTree::iterator node = resultTree->root();
- std::set<std::string> haveSeen;
- for(unsigned i=0 ; i<symbolTable.size() ; ++i)
- {
- /// We shall get each member at this archive.
- /// Construct a corresponding mcld::Input, and insert it into
- /// the original InputTree, resultTree.
- off_t nestedOff = 0;
-
- readMemberHeader(*pInput.memArea(), symbolTable[i].fileOffset, &archiveMemberName,
- &nestedOff, extendedName);
-
- if(haveSeen.find(archiveMemberName)==haveSeen.end())
- haveSeen.insert(archiveMemberName);
+ // get nested file path, the nested file's member name is the relative
+ // path to the archive containing it.
+ sys::fs::Path input_path(pArchiveFile.path().parent_path());
+ if (!input_path.empty())
+ input_path.append(member_name);
else
- continue;
+ input_path.assign(member_name);
+ member =
+ m_LDInfo.inputFactory().produce(member_name, input_path, Input::Unknown);
- if(!isThinArchive)
- {
- /// New a Input object and assign fileOffset in MCLDFile.
- /// Insert the object to resultTree and move ahead.
- off_t fileOffset = symbolTable[i].fileOffset + sizeof(ArchiveMemberHeader);
- Input *insertObjectFile = m_pLDInfo.inputFactory().produce(archiveMemberName,
- pInput.path(),
- MCLDFile::Object,
- fileOffset);
- resultTree->insert<InputTree::Positional>(node, *insertObjectFile);
- if(i==0)
- node.move<InputTree::Inclusive>();
- else
- node.move<InputTree::Positional>();
-
- continue;
+ assert(member != NULL);
+ MemoryArea* input_memory =
+ m_MemAreaFactory.produce(member->path(), FileHandle::ReadOnly);
+ if (input_memory->handler()->isGood()) {
+ member->setMemArea(input_memory);
}
-
- /// TODO:(Duo)
- /// adjust the relative pathname
- /// For example
- /// thin archive pathname : "/usr/lib/thin.a"
- /// Member name : "member.a"
- /// pathname after adjust : "/usr/lib/member.a"
- sys::fs::RealPath realPath(archiveMemberName);
- if(nestedOff > 0)
- {
- /// This is a member of a nested archive.
- /// Create an Input for this archive ,and recursive call setupNewArchive
- /// Finally, merge the new InputTree with the old one
- Input *newArchive = m_pLDInfo.inputFactory().produce(archiveMemberName,
- realPath,
- MCLDFile::Archive,
- 0);
-
- resultTree->insert<InputTree::Positional>(node, *newArchive);
- if(i==0)
- node.move<InputTree::Inclusive>();
- else
- node.move<InputTree::Positional>();
- InputTree *newArchiveTree = setupNewArchive(*newArchive, 0);
- resultTree->merge<InputTree::Inclusive>(node, *newArchiveTree);
- continue;
+ else {
+ error(diag::err_cannot_open_input) << member->name() << member->path();
+ return NULL;
}
- /// External member , open it as normal object file
- /// add new Input to InputTree
- Input *insertObjectFile = m_pLDInfo.inputFactory().produce(archiveMemberName,
- realPath,
- MCLDFile::Object,
- 0);
- resultTree->insert<InputTree::Positional>(node, *insertObjectFile);
- if(i==0)
- node.move<InputTree::Inclusive>();
- else
- node.move<InputTree::Positional>();
+ LDContext *input_context = m_LDInfo.contextFactory().produce(input_path);
+ member->setContext(input_context);
}
- return resultTree;
+
+ pArchiveFile.memArea()->release(header_region);
+ return member;
}
-
-/// Parse the member header and return the size of member
-/// Archive member names in System 5 style :
-///
-/// "/ " - symbol table, must be the first member
-/// "// " - long name table
-/// "filename.o/ " - regular file with short name
-/// "/5566 " - name at offset 5566 at long name table
-
-size_t GNUArchiveReader::readMemberHeader(MemoryArea &pArea,
- off_t off,
- std::string *p_Name,
- off_t *p_NestedOff,
- std::string &p_ExtendedName)
+/// readSymbolTable - read the archive symbol map (armap)
+bool GNUArchiveReader::readSymbolTable(Archive& pArchive)
{
- MemoryRegion *region = pArea.request(off, sizeof(ArchiveMemberHeader));
- const char *pFile = reinterpret_cast<char *>(region->getBuffer());
- const ArchiveMemberHeader *header = reinterpret_cast<const ArchiveMemberHeader *>(pFile);
+ assert(pArchive.getARFile().hasMemArea());
- /// check magic number of member header
- if(memcmp(header->finalMagic, HeaderFinalMagic, sizeof HeaderFinalMagic))
- {
- llvm::report_fatal_error("archive member header magic number false");
- return 0;
- }
+ MemoryRegion* header_region =
+ pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() +
+ Archive::MAGIC_LEN),
+ sizeof(Archive::MemberHeader));
+ const Archive::MemberHeader* header =
+ reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer());
+ assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, 2));
- /// evaluate member size
- std::string sizeString(header->size, sizeof(header->size)+1);
- size_t memberSize = stringToType<size_t>(sizeString);
- if(memberSize == 0)
- {
- llvm::report_fatal_error("member Size Error");
- return 0;
- }
+ int symtab_size = atoi(header->size);
+ pArchive.setSymTabSize(symtab_size);
- if(header->name[0] != '/')
- {
- /// This is a regular file with short name
- const char* nameEnd = strchr(header->name, '/');
- size_t nameLen = ((nameEnd == NULL) ? 0 : (nameEnd - header->name));
- if((nameLen <= 0) || (nameLen >= sizeof(header->name)))
- {
- llvm::report_fatal_error("header name format error\n");
- return 0;
- }
- p_Name->assign(header->name, nameLen);
+ MemoryRegion* symtab_region =
+ pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() +
+ Archive::MAGIC_LEN +
+ sizeof(Archive::MemberHeader)),
+ symtab_size);
+ const uint32_t* data =
+ reinterpret_cast<const uint32_t*>(symtab_region->getBuffer());
- if(!p_NestedOff)
- p_NestedOff = 0;
- }
- else if(header->name[1] == ' ')
- {
- /// This is symbol table
- if(!p_Name->empty())
- p_Name->clear();
- }
- else if(header->name[1] == '/')
- {
- /// This is long name table
- p_Name->assign(1,'/');
- }
+ // read the number of symbols
+ uint32_t number = 0;
+ if (llvm::sys::isLittleEndianHost())
+ number = bswap32(*data);
else
- {
- /// This is regular file with long name
- char *end;
- long extendedNameOff = strtol(header->name+1, &end, 10);
- long nestedOff = 0;
- if(*end == ':')
- nestedOff = strtol(end+1, &end, 10);
+ number = *data;
- if(*end != ' '
- || extendedNameOff < 0
- || static_cast<size_t>(extendedNameOff) >= p_ExtendedName.size())
- {
- llvm::report_fatal_error("extended name");
- return 0;
- }
+ // set up the pointers for file offset and name offset
+ ++data;
+ const char* name = reinterpret_cast<const char*>(data + number);
- const char *name = p_ExtendedName.data() + extendedNameOff;
- const char *nameEnd = strchr(name, '\n');
- if(nameEnd[-1] != '/'
- || static_cast<size_t>(nameEnd-name) > p_ExtendedName.size())
- {
- llvm::report_fatal_error("p_ExtendedName substring is not end with / \n");
- return 0;
- }
- p_Name->assign(name, nameEnd-name-1);
- if(p_NestedOff)
- *p_NestedOff = nestedOff;
+ // add the archive symbols
+ for (uint32_t i = 0; i < number; ++i) {
+ if (llvm::sys::isLittleEndianHost())
+ pArchive.addSymbol(name, bswap32(*data));
+ else
+ pArchive.addSymbol(name, *data);
+ name += strlen(name) + 1;
+ ++data;
}
- return memberSize;
+ pArchive.getARFile().memArea()->release(header_region);
+ pArchive.getARFile().memArea()->release(symtab_region);
+ return true;
}
-void GNUArchiveReader::readSymbolTable(MemoryArea &pArea,
- std::vector<SymbolTableEntry> &pSymbolTable,
- off_t start,
- size_t size)
+/// readStringTable - read the strtab for long file name of the archive
+bool GNUArchiveReader::readStringTable(Archive& pArchive)
{
- MemoryRegion *region = pArea.request(start, size);
- const char *pFile = reinterpret_cast<char *>(region->getBuffer());
- const elfWord *p_Word = reinterpret_cast<const elfWord *>(pFile);
- unsigned int symbolNum = *p_Word;
+ size_t offset = Archive::MAGIC_LEN +
+ sizeof(Archive::MemberHeader) +
+ pArchive.getSymTabSize();
- /// Portable Issue on Sparc platform
- /// Intel, ARM and Mips are littel-endian , Sparc is little-endian after verion 9
- /// symbolNum in symbol table is always big-endian
- if(llvm::sys::isLittleEndianHost())
- symbolNum = bswap32(symbolNum);
- ++p_Word;
+ if (0x0 != (offset & 1))
+ ++offset;
- const char *p_Name = reinterpret_cast<const char *>(p_Word + symbolNum);
+ assert(pArchive.getARFile().hasMemArea());
- for(unsigned int i=0 ; i<symbolNum ; ++i)
- {
- SymbolTableEntry entry;
- /// member offset
- unsigned int memberOffset = *p_Word;
- if(llvm::sys::isLittleEndianHost())
- memberOffset = bswap32(memberOffset);
- entry.fileOffset = static_cast<off_t>(memberOffset);
- ++p_Word;
- /// member name
- off_t nameEnd = strlen(p_Name) + 1;
- entry.name.assign(p_Name, nameEnd);
- p_Name += nameEnd;
- /// the symbol is found in symbol pool
- if (m_pLDInfo.getNamePool().findSymbol(entry.name))
- pSymbolTable.push_back(entry);
- }
+ MemoryRegion* header_region =
+ pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() +
+ offset),
+ sizeof(Archive::MemberHeader));
+ const Archive::MemberHeader* header =
+ reinterpret_cast<const Archive::MemberHeader*>(header_region->getBuffer());
+
+ assert(0 == memcmp(header->fmag, Archive::MEMBER_MAGIC, 2));
+
+ int strtab_size = atoi(header->size);
+
+ MemoryRegion* strtab_region =
+ pArchive.getARFile().memArea()->request((pArchive.getARFile().fileOffset() +
+ offset +
+ sizeof(Archive::MemberHeader)),
+ strtab_size);
+ const char* strtab =
+ reinterpret_cast<const char*>(strtab_region->getBuffer());
+
+ pArchive.getStrTable().assign(strtab, strtab_size);
+
+ pArchive.getARFile().memArea()->release(header_region);
+ pArchive.getARFile().memArea()->release(strtab_region);
+ return true;
}
+
+/// shouldIncludeStatus - given a sym name from armap and check if including
+/// the corresponding archive member, and then return the decision
+enum Archive::Symbol::Status
+GNUArchiveReader::shouldIncludeSymbol(const llvm::StringRef& pSymName) const
+{
+ // TODO: handle symbol version issue and user defined symbols
+ ResolveInfo* info = m_LDInfo.getNamePool().findInfo(pSymName);
+ if (NULL != info) {
+ if (!info->isUndef())
+ return Archive::Symbol::Exclude;
+ if (info->isWeak())
+ return Archive::Symbol::Unknown;
+ return Archive::Symbol::Include;
+ }
+ return Archive::Symbol::Unknown;
+}
+
diff --git a/lib/LD/LDSection.cpp b/lib/LD/LDSection.cpp
index 1ec9c13..2aad917 100644
--- a/lib/LD/LDSection.cpp
+++ b/lib/LD/LDSection.cpp
@@ -7,7 +7,6 @@
//
//===----------------------------------------------------------------------===//
#include <mcld/LD/LDSection.h>
-#include <llvm/MC/SectionKind.h>
using namespace mcld;
@@ -18,8 +17,7 @@
uint64_t pSize,
uint64_t pOffset,
uint64_t pAddr)
- : llvm::MCSection(llvm::MCSection::SV_LDContext, llvm::SectionKind::getMetadata()),
- m_Name(pName),
+ : m_Name(pName),
m_Kind(pKind),
m_Type(pType),
m_Flag(pFlag),
diff --git a/lib/LD/LDSymbol.cpp b/lib/LD/LDSymbol.cpp
index f26e052..f088b5c 100644
--- a/lib/LD/LDSymbol.cpp
+++ b/lib/LD/LDSymbol.cpp
@@ -6,7 +6,9 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include "mcld/LD/LDSymbol.h"
+
+#include <mcld/LD/LDSymbol.h>
+
#include <cstring>
using namespace mcld;
@@ -33,7 +35,7 @@
return (*this);
}
-void LDSymbol::setFragmentRef(MCFragmentRef* pFragmentRef)
+void LDSymbol::setFragmentRef(FragmentRef* pFragmentRef)
{
m_pFragRef = pFragmentRef;
}
diff --git a/lib/LD/Layout.cpp b/lib/LD/Layout.cpp
index bc91cee..1650556 100644
--- a/lib/LD/Layout.cpp
+++ b/lib/LD/Layout.cpp
@@ -7,22 +7,29 @@
//
//===----------------------------------------------------------------------===//
-#include <llvm/ADT/Twine.h>
-#include <mcld/ADT/SizeTraits.h>
#include <mcld/LD/Layout.h>
+
+#include <cassert>
+
+#include <llvm/ADT/Twine.h>
+
+#include <mcld/ADT/SizeTraits.h>
#include <mcld/LD/LDContext.h>
#include <mcld/LD/LDFileFormat.h>
#include <mcld/LD/LDSection.h>
+#include <mcld/LD/Fragment.h>
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/AlignFragment.h>
#include <mcld/MC/MCLinker.h>
#include <mcld/MC/MCLDInfo.h>
#include <mcld/Support/MsgHandling.h>
#include <mcld/Target/TargetLDBackend.h>
-#include <cassert>
using namespace mcld;
//===----------------------------------------------------------------------===//
// Range
+//===----------------------------------------------------------------------===//
Layout::Range::Range()
: header(NULL),
prevRear(NULL) {
@@ -39,6 +46,7 @@
//===----------------------------------------------------------------------===//
// Layout
+//===----------------------------------------------------------------------===//
Layout::Layout()
: m_FragRefFactory(32) /** magic number **/ {
}
@@ -47,23 +55,25 @@
{
}
-void Layout::setFragmentLayoutOrder(llvm::MCFragment* pFrag)
+void Layout::setFragmentLayoutOrder(Fragment* pFrag)
{
if (NULL == pFrag)
return;
- // compute the most-recent fragment whose order was set.
- llvm::MCFragment* first = pFrag;
+ /// find the most-recent fragment whose order was set.
+ Fragment* first = pFrag;
while (!hasLayoutOrder(*first)) {
if (NULL == first->getPrevNode())
break;
first = first->getPrevNode();
}
- // set all layout order
- unsigned int layout_order = 0;
- llvm::MCFragment* frag_not_set = NULL;
+ /// set all layout order
+ // find the first fragment who has no order.
+ // find the last order of the fragment
+ unsigned int layout_order = 0;
+ Fragment* frag_not_set = NULL;
if (NULL == first->getPrevNode()) {
layout_order = 0;
frag_not_set = first;
@@ -73,7 +83,7 @@
frag_not_set = first->getNextNode();
}
- // set up all layout order
+ // for all fragments that has no order, set up its order
while(NULL != frag_not_set) {
frag_not_set->setLayoutOrder(layout_order);
++layout_order;
@@ -84,12 +94,13 @@
/// setFragmentLayoutOffset - set the fragment's layout offset. This function
/// also set up the layout offsets of all the fragments in the same range.
/// If the offset of the fragment was set before, return immediately.
-void Layout::setFragmentLayoutOffset(llvm::MCFragment* pFrag)
+void Layout::setFragmentLayoutOffset(Fragment* pFrag)
{
if (NULL == pFrag)
return;
- // compute the most-recent fragment whose offset was set.
- llvm::MCFragment* first = pFrag;
+
+ // find the most-recent fragment whose offset was set.
+ Fragment* first = pFrag;
while (!hasLayoutOffset(*first)) {
if (NULL == first->getPrevNode())
@@ -99,19 +110,19 @@
// set all layout order
uint64_t offset = 0;
- llvm::MCFragment* frag_not_set = NULL;
+ Fragment* frag_not_set = NULL;
if (NULL == first->getPrevNode()) {
offset = 0;
frag_not_set = first;
}
else {
- offset = first->Offset;
+ offset = first->getOffset();
offset += computeFragmentSize(*this, *first);
frag_not_set = first->getNextNode();
}
while(NULL != frag_not_set) {
- frag_not_set->Offset = offset;
+ frag_not_set->setOffset(offset);
offset += computeFragmentSize(*this, *frag_not_set);
frag_not_set = frag_not_set->getNextNode();
}
@@ -120,7 +131,8 @@
/// addInputRange
/// 1. add a new range <pInputHdr, previous rear fragment>
/// 2. compute the layout order of all previous ranges.
-void Layout::addInputRange(const llvm::MCSectionData& pSD,
+/// 2. compute the layout offset of all previous ranges.
+void Layout::addInputRange(const SectionData& pSD,
const LDSection& pInputHdr)
{
RangeList* range_list = NULL;
@@ -141,12 +153,12 @@
// set up previous rear of the range.
// FIXME: in current design, we can not add a range before finishing adding
// fragments in the previous range. If the limitation keeps, we can set
- // prevRear to the last fragment in the MCSectionData simply.
+ // prevRear to the last fragment in the SectionData simply.
//
// if the pSD's fragment list is empty, the range.prevRear keeps NULL.
if (!pSD.getFragmentList().empty()) {
range->prevRear =
- const_cast<llvm::MCFragment*>(&pSD.getFragmentList().back());
+ const_cast<Fragment*>(&pSD.getFragmentList().back());
}
// compute the layout order of the previous range.
@@ -156,24 +168,24 @@
}
}
-/// appendFragment - append the given MCFragment to the given MCSectionData,
+/// appendFragment - append the given Fragment to the given SectionData,
/// and insert a MCAlignFragment to preserve the required align constraint if
/// needed
-uint64_t Layout::appendFragment(llvm::MCFragment& pFrag,
- llvm::MCSectionData& pSD,
+uint64_t Layout::appendFragment(Fragment& pFrag,
+ SectionData& pSD,
uint32_t pAlignConstraint)
{
- // insert MCAlignFragment into MCSectionData first if needed
- llvm::MCAlignFragment* align_frag = NULL;
+ // insert MCAlignFragment into SectionData first if needed
+ AlignFragment* align_frag = NULL;
if (pAlignConstraint > 1) {
- align_frag = new llvm::MCAlignFragment(pAlignConstraint, // alignment
- 0x0, // the filled value
- 1u, // the size of filled value
- pAlignConstraint - 1, // max bytes to emit
- &pSD);
+ align_frag = new AlignFragment(pAlignConstraint, // alignment
+ 0x0, // the filled value
+ 1u, // the size of filled value
+ pAlignConstraint - 1, // max bytes to emit
+ &pSD);
}
- // append the fragment to the MCSectionData
+ // append the fragment to the SectionData
pFrag.setParent(&pSD);
pSD.getFragmentList().push_back(&pFrag);
@@ -188,30 +200,30 @@
setFragmentLayoutOffset(&pFrag);
if (NULL != align_frag)
- return pFrag.Offset - align_frag->Offset + computeFragmentSize(*this, pFrag);
+ return pFrag.getOffset() - align_frag->getOffset() + computeFragmentSize(*this, pFrag);
else
return computeFragmentSize(*this, pFrag);
}
-/// getInputLDSection - give a MCFragment, return the corresponding input
+/// getInputLDSection - give a Fragment, return the corresponding input
/// LDSection*
LDSection*
-Layout::getInputLDSection(const llvm::MCFragment& pFrag)
+Layout::getInputLDSection(const Fragment& pFrag)
{
- const llvm::MCSectionData* sect_data = pFrag.getParent();
- // check the MCSectionData
+ const SectionData* sect_data = pFrag.getParent();
+ // check the SectionData
if (NULL == sect_data) {
llvm::report_fatal_error(llvm::Twine("the fragment does not belong to") +
- llvm::Twine(" any MCSectionData.\n"));
+ llvm::Twine(" any SectionData.\n"));
}
- // check the MCSectionData's range list
+ // check the SectionData's range list
if (0 == m_SDRangeMap.count(sect_data)) {
llvm::report_fatal_error(llvm::Twine("INTERNAL BACKEND ERROR: ") +
- llvm::Twine("the input's MCSectionData is not ") +
+ llvm::Twine("the input's SectionData is not ") +
llvm::Twine("registered in the Layout.\nPlease ") +
llvm::Twine("use MCLinker::getOrCreateSectData() ") +
- llvm::Twine("to get input's MCSectionData.\n"));
+ llvm::Twine("to get input's SectionData.\n"));
}
RangeList* range_list = m_SDRangeMap[sect_data];
@@ -237,25 +249,25 @@
}
}
-/// getInputLDSection - give a MCFragment, return the corresponding input
+/// getInputLDSection - give a Fragment, return the corresponding input
/// LDSection*
const LDSection*
-Layout::getInputLDSection(const llvm::MCFragment& pFrag) const
+Layout::getInputLDSection(const Fragment& pFrag) const
{
- const llvm::MCSectionData* sect_data = pFrag.getParent();
- // check the MCSectionData
+ const SectionData* sect_data = pFrag.getParent();
+ // check the SectionData
if (NULL == sect_data) {
llvm::report_fatal_error(llvm::Twine("the fragment does not belong to") +
- llvm::Twine(" any MCSectionData.\n"));
+ llvm::Twine(" any SectionData.\n"));
}
- // check the MCSectionData's range list
+ // check the SectionData's range list
if (0 == m_SDRangeMap.count(sect_data)) {
llvm::report_fatal_error(llvm::Twine("INTERNAL BACKEND ERROR: ") +
- llvm::Twine("the input's MCSectionData is not ") +
+ llvm::Twine("the input's SectionData is not ") +
llvm::Twine("registered in the Layout.\nPlease ") +
llvm::Twine("use MCLinker::getOrCreateSectData() ") +
- llvm::Twine("to get input's MCSectionData.\n"));
+ llvm::Twine("to get input's SectionData.\n"));
}
SDRangeMap::const_iterator range_list_iter = m_SDRangeMap.find(sect_data);
@@ -283,37 +295,36 @@
}
/// getOutputLDSection
-LDSection* Layout::getOutputLDSection(const llvm::MCFragment& pFrag)
+LDSection* Layout::getOutputLDSection(const Fragment& pFrag)
{
- llvm::MCSectionData* sect_data = pFrag.getParent();
+ SectionData* sect_data = pFrag.getParent();
if (NULL == sect_data)
return NULL;
- return const_cast<LDSection*>(llvm::cast<LDSection>(§_data->getSection()));
+ return const_cast<LDSection*>(§_data->getSection());
}
/// getOutputLDSection
-const LDSection* Layout::getOutputLDSection(const llvm::MCFragment& pFrag) const
+const LDSection* Layout::getOutputLDSection(const Fragment& pFrag) const
{
- const llvm::MCSectionData* sect_data = pFrag.getParent();
+ const SectionData* sect_data = pFrag.getParent();
if (NULL == sect_data)
return NULL;
- return llvm::cast<LDSection>(§_data->getSection());
+ return §_data->getSection();
}
/// getFragmentRef - assume the ragne exist, find the fragment reference
-MCFragmentRef*
-Layout::getFragmentRef(Layout::Range& pRange, uint64_t pOffset)
+FragmentRef* Layout::getFragmentRef(Layout::Range& pRange, uint64_t pOffset)
{
if (isEmptyRange(pRange))
return NULL;
- llvm::MCFragment* front = getFront(pRange);
+ Fragment* front = getFront(pRange);
if (NULL == front)
return NULL;
- llvm::MCFragment* rear = getRear(pRange);
+ Fragment* rear = getRear(pRange);
if (NULL == rear)
return NULL;
@@ -323,13 +334,11 @@
// @param pFront is the first fragment in the range.
// @param pRear is the last fragment in the range.
// @pOffset is the offset started from pFront.
-MCFragmentRef*
-Layout::getFragmentRef(llvm::MCFragment& pFront,
- llvm::MCFragment& pRear,
- uint64_t pOffset)
+FragmentRef*
+Layout::getFragmentRef(Fragment& pFront, Fragment& pRear, uint64_t pOffset)
{
- llvm::MCFragment* front = &pFront;
- llvm::MCFragment* rear = &pRear;
+ Fragment* front = &pFront;
+ Fragment* rear = &pRear;
if (!hasLayoutOffset(*rear)) {
// compute layout order, offset
@@ -338,12 +347,12 @@
}
// compute the offset from overall start fragment.
- uint64_t target_offset = pFront.Offset + pOffset;
+ uint64_t target_offset = pFront.getOffset() + pOffset;
// from front to rear, find the offset which is as large as possible
// but smaller than the target_offset.
while (front != rear) {
- if (llvm::MCFragment::FT_Align == front->getKind()) {
+ if (Fragment::Alignment == front->getKind()) {
// alignment fragments were not counted in target_offset.
// Count in the size of alignment fragmen in target_offset here.
uint64_t align_size = 0x0;
@@ -355,33 +364,33 @@
else {
// If the alignment fragment is not the last fragment, the alignment
// fragment's size is the distance between the two fragment.
- align_size = front->getNextNode()->Offset - front->Offset;
+ align_size = front->getNextNode()->getOffset() - front->getOffset();
}
target_offset += align_size;
front = front->getNextNode();
continue;
}
- if (target_offset >= front->getNextNode()->Offset) {
+ if (target_offset >= front->getNextNode()->getOffset()) {
front = front->getNextNode();
}
else {
// found
- MCFragmentRef* result = m_FragRefFactory.allocate();
- new (result) MCFragmentRef(*front, target_offset - front->Offset);
+ FragmentRef* result = m_FragRefFactory.allocate();
+ new (result) FragmentRef(*front, target_offset - front->getOffset());
return result;
}
}
if (front == rear) {
- if (llvm::MCFragment::FT_Align == front->getKind())
+ if (Fragment::Alignment == front->getKind())
return NULL;
if (!isValidOffset(*front, target_offset))
return NULL;
- MCFragmentRef* result = m_FragRefFactory.allocate();
- new (result) MCFragmentRef(*front, target_offset - front->Offset);
+ FragmentRef* result = m_FragRefFactory.allocate();
+ new (result) FragmentRef(*front, target_offset - front->getOffset());
return result;
}
return NULL;
@@ -389,11 +398,11 @@
/// getFragmentRef - give a LDSection in input file and an offset, return
/// the fragment reference.
-MCFragmentRef*
+FragmentRef*
Layout::getFragmentRef(const LDSection& pInputSection, uint64_t pOffset)
{
// find out which SectionData covers the range of input section header
- const llvm::MCSectionData* sect_data = pInputSection.getSectionData();
+ const SectionData* sect_data = pInputSection.getSectionData();
// check range list
if (0 == m_SDRangeMap.count(sect_data))
@@ -428,21 +437,21 @@
/// @param pBigOffset - the offset, can be larger than the fragment, but can
/// not larger than this input section.
/// @return if found, return the fragment. Otherwise, return NULL.
-MCFragmentRef*
-Layout::getFragmentRef(const llvm::MCFragment& pFrag, uint64_t pBigOffset)
+FragmentRef*
+Layout::getFragmentRef(const Fragment& pFrag, uint64_t pBigOffset)
{
if (!hasLayoutOffset(pFrag)) {
// compute layout order, offset
- setFragmentLayoutOrder(const_cast<llvm::MCFragment*>(&pFrag));
- setFragmentLayoutOffset(const_cast<llvm::MCFragment*>(&pFrag));
+ setFragmentLayoutOrder(const_cast<Fragment*>(&pFrag));
+ setFragmentLayoutOffset(const_cast<Fragment*>(&pFrag));
}
// find out which SectionData covers the range of input section header
- const llvm::MCSectionData* sect_data = pFrag.getParent();
+ const SectionData* sect_data = pFrag.getParent();
// check range list
if (0 == m_SDRangeMap.count(sect_data)) {
- llvm::report_fatal_error(llvm::Twine("MCSectionData has no") +
+ llvm::report_fatal_error(llvm::Twine("SectionData has no") +
llvm::Twine(" correponding range list.\n"));
}
@@ -452,13 +461,13 @@
RangeList* range_list = m_SDRangeMap[sect_data];
// find out the specific part in SectionData range
- uint64_t target_offset = pBigOffset + pFrag.Offset;
+ uint64_t target_offset = pBigOffset + pFrag.getOffset();
RangeList::iterator range, rangeEnd = range_list->end();
for (range = range_list->begin(); range != rangeEnd; ++range) {
if (isEmptyRange(*range))
continue;
- if (getRear(*range)->Offset >= target_offset) {
+ if (getRear(*range)->getOffset() >= target_offset) {
break;
}
}
@@ -472,17 +481,17 @@
return getFragmentRef(*range, pBigOffset);
}
-uint64_t Layout::getOutputOffset(const llvm::MCFragment& pFrag)
+uint64_t Layout::getOutputOffset(const Fragment& pFrag)
{
if (!hasLayoutOffset(pFrag)) {
// compute layout order, offset
- setFragmentLayoutOrder(const_cast<llvm::MCFragment*>(&pFrag));
- setFragmentLayoutOffset(const_cast<llvm::MCFragment*>(&pFrag));
+ setFragmentLayoutOrder(const_cast<Fragment*>(&pFrag));
+ setFragmentLayoutOffset(const_cast<Fragment*>(&pFrag));
}
- return pFrag.Offset;
+ return pFrag.getOffset();
}
-uint64_t Layout::getOutputOffset(const llvm::MCFragment& pFrag) const
+uint64_t Layout::getOutputOffset(const Fragment& pFrag) const
{
if (!hasLayoutOffset(pFrag)) {
llvm::report_fatal_error(llvm::Twine("INTERNAL BACKEND ERROR: ") +
@@ -490,15 +499,15 @@
llvm::Twine(__func__) +
llvm::Twine(" can not be used before layout().\n"));
}
- return pFrag.Offset;
+ return pFrag.getOffset();
}
-uint64_t Layout::getOutputOffset(const MCFragmentRef& pFragRef)
+uint64_t Layout::getOutputOffset(const FragmentRef& pFragRef)
{
return getOutputOffset(*(pFragRef.frag())) + pFragRef.offset();
}
-uint64_t Layout::getOutputOffset(const MCFragmentRef& pFragRef) const
+uint64_t Layout::getOutputOffset(const FragmentRef& pFragRef) const
{
return getOutputOffset(*(pFragRef.frag())) + pFragRef.offset();
}
@@ -534,6 +543,10 @@
}
}
+/// layout - layout the sections
+/// 1. finalize fragment offset
+/// 2. compute section order
+/// 3. finalize section offset
bool Layout::layout(Output& pOutput,
const TargetLDBackend& pBackend,
const MCLDInfo& pInfo)
@@ -544,6 +557,7 @@
LDContext& output_context = *pOutput.context();
LDContext::sect_iterator it, itEnd = output_context.sectEnd();
for (it = output_context.sectBegin(); it != itEnd; ++it) {
+ // calculate 1. all fragment offset, and 2. the section order
LDSection* sect = *it;
switch (sect->kind()) {
@@ -559,8 +573,7 @@
if (NULL != sect->getSectionData() &&
!sect->getSectionData()->getFragmentList().empty()) {
// make sure that all fragments are valid
- llvm::MCFragment& frag =
- sect->getSectionData()->getFragmentList().back();
+ Fragment& frag = sect->getSectionData()->getFragmentList().back();
setFragmentLayoutOrder(&frag);
setFragmentLayoutOffset(&frag);
}
@@ -604,15 +617,17 @@
// Backend defines the section start offset for section 1.
uint64_t offset = pBackend.sectionStartOffset();
- // compute the section offset and handle alignment also. And ignore section 0
- // (NULL in ELF/COFF), and MachO starts from section 1.
+
for (size_t index = 1; index < m_SectionOrder.size(); ++index) {
- // we should not preserve file space for the BSS section.
- if (LDFileFormat::BSS != m_SectionOrder[index - 1]->kind())
+ // compute the section offset and handle alignment also. And ignore section 0
+ // (NULL in ELF/COFF), and MachO starts from section 1.
+
+ if (LDFileFormat::BSS != m_SectionOrder[index - 1]->kind()) {
+ // we should not preserve file space for the BSS section.
offset += m_SectionOrder[index - 1]->size();
+ }
alignAddress(offset, m_SectionOrder[index]->align());
-
m_SectionOrder[index]->setOffset(offset);
}
@@ -627,15 +642,15 @@
return true;
}
-bool Layout::isValidOffset(const llvm::MCFragment& pFrag, uint64_t pTargetOffset) const
+bool Layout::isValidOffset(const Fragment& pFrag, uint64_t pTargetOffset) const
{
uint64_t size = computeFragmentSize(*this, pFrag);
if (0x0 == size)
- return (pTargetOffset == pFrag.Offset);
+ return (pTargetOffset == pFrag.getOffset());
if (NULL != pFrag.getNextNode())
- return (pTargetOffset >= pFrag.Offset && pTargetOffset < pFrag.getNextNode()->Offset);
+ return (pTargetOffset >= pFrag.getOffset() && pTargetOffset < pFrag.getNextNode()->getOffset());
- return (pTargetOffset >= pFrag.Offset && pTargetOffset < (pFrag.Offset + size));
+ return (pTargetOffset >= pFrag.getOffset() && pTargetOffset < (pFrag.getOffset() + size));
}
diff --git a/lib/LD/RegionFragment.cpp b/lib/LD/RegionFragment.cpp
new file mode 100644
index 0000000..7508ed5
--- /dev/null
+++ b/lib/LD/RegionFragment.cpp
@@ -0,0 +1,24 @@
+//===- RegionFragment.cpp -------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <mcld/LD/RegionFragment.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// RegionFragment
+//===----------------------------------------------------------------------===//
+RegionFragment::RegionFragment(MemoryRegion& pRegion, SectionData* pSD)
+ : Fragment(Fragment::Region, pSD), m_Region(pRegion) {
+}
+
+RegionFragment::~RegionFragment()
+{
+}
+
diff --git a/lib/LD/Relocation.cpp b/lib/LD/Relocation.cpp
index 4a901ba..0c95e06 100644
--- a/lib/LD/Relocation.cpp
+++ b/lib/LD/Relocation.cpp
@@ -6,7 +6,7 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <llvm/MC/MCAssembler.h>
+
#include <mcld/LD/Relocation.h>
#include <mcld/LD/RelocationFactory.h>
#include <mcld/LD/Layout.h>
@@ -15,10 +15,10 @@
using namespace mcld;
Relocation::Relocation(Relocation::Type pType,
- MCFragmentRef* pTargetRef,
+ FragmentRef* pTargetRef,
Relocation::Address pAddend,
Relocation::DWord pTargetData)
- : MCFragment(llvm::MCFragment::FT_Reloc),
+ : Fragment(Fragment::Relocation),
m_Type(pType),
m_TargetData(pTargetData),
m_pSymInfo(NULL),
@@ -42,8 +42,7 @@
{
if (m_pSymInfo->type() == ResolveInfo::Section &&
m_pSymInfo->outSymbol()->hasFragRef()) {
- return llvm::cast<LDSection>(
- m_pSymInfo->outSymbol()->fragRef()->frag()->getParent()->getSection()).addr();
+ return m_pSymInfo->outSymbol()->fragRef()->frag()->getParent()->getSection().addr();
}
return m_pSymInfo->outSymbol()->value();
}
diff --git a/lib/LD/RelocationFactory.cpp b/lib/LD/RelocationFactory.cpp
index 2bcfeb3..828acb2 100644
--- a/lib/LD/RelocationFactory.cpp
+++ b/lib/LD/RelocationFactory.cpp
@@ -6,17 +6,22 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#include <mcld/LD/RelocationFactory.h>
-#include <mcld/Target/GOT.h>
-#include <mcld/Target/TargetLDBackend.h>
-#include <llvm/Support/Host.h>
+
#include <cstring>
#include <cassert>
+#include <llvm/Support/Host.h>
+
+#include <mcld/Target/GOT.h>
+#include <mcld/Target/TargetLDBackend.h>
+
using namespace mcld;
-//==========================
+//===----------------------------------------------------------------------===//
// RelocationFactory
+//===----------------------------------------------------------------------===//
RelocationFactory::RelocationFactory(size_t pNum)
: GCFactory<Relocation, 0>(pNum),
m_pLayout(NULL) {
@@ -27,7 +32,7 @@
}
Relocation* RelocationFactory::produce(RelocationFactory::Type pType,
- MCFragmentRef& pFragRef,
+ FragmentRef& pFragRef,
Address pAddend)
{
// target_data is the place where the relocation applys to.
diff --git a/lib/LD/SectionData.cpp b/lib/LD/SectionData.cpp
new file mode 100644
index 0000000..d1858ba
--- /dev/null
+++ b/lib/LD/SectionData.cpp
@@ -0,0 +1,19 @@
+//===- SectionData.cpp ----------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/LD/SectionData.h>
+#include <mcld/LD/LDSection.h>
+
+using namespace mcld;
+
+//===----------------------------------------------------------------------===//
+// SectionData
+//===----------------------------------------------------------------------===//
+SectionData::SectionData(const LDSection &pSection)
+ : m_pSection(&pSection), m_Alignment(1) {
+}
diff --git a/lib/LD/SectionMap.cpp b/lib/LD/SectionMap.cpp
index 9d32391..7bcd809 100644
--- a/lib/LD/SectionMap.cpp
+++ b/lib/LD/SectionMap.cpp
@@ -47,7 +47,7 @@
// TODO: handle the cases such as overriding the exist mapping and drawing
// exception from the given SECTIONS command
iterator it;
- for (it = begin(); it != end(); ++it) {
+ for (it = m_SectMap.begin(); it != m_SectMap.end(); ++it) {
if (pInput == (*it).inputSubStr)
return false;
}
@@ -131,8 +131,8 @@
bool SectionMap::initStdSectionMap()
{
for (int i = 0; i < m_StdSectionMapSize; ++i) {
- if (!push_back(m_StdSectionMap[i].from, m_StdSectionMap[i].to))
- return false;
+ struct Mapping mapping = { m_StdSectionMap[i].from, m_StdSectionMap[i].to};
+ m_SectMap.push_back(mapping);
}
return true;
}
diff --git a/lib/LD/SectionMerger.cpp b/lib/LD/SectionMerger.cpp
index f3a5b65..1817e0b 100644
--- a/lib/LD/SectionMerger.cpp
+++ b/lib/LD/SectionMerger.cpp
@@ -60,7 +60,7 @@
return section;
}
-llvm::MCSectionData* SectionMerger::getOutputSectData(const std::string& pName)
+SectionData* SectionMerger::getOutputSectData(const std::string& pName)
{
return getOutputSectHdr(pName)->getSectionData();
}
diff --git a/lib/LD/StaticResolver.cpp b/lib/LD/StaticResolver.cpp
index 09cbc11..6401262 100644
--- a/lib/LD/StaticResolver.cpp
+++ b/lib/LD/StaticResolver.cpp
@@ -103,7 +103,6 @@
}
case DUND:
case DUNDW: {
- old->override(pNew);
old->overrideVisibility(pNew);
old->setDynamic();
pOverride = false;
diff --git a/lib/MC/Android.mk b/lib/MC/Android.mk
index b184116..30ca202 100644
--- a/lib/MC/Android.mk
+++ b/lib/MC/Android.mk
@@ -5,8 +5,6 @@
ContextFactory.cpp \
InputFactory.cpp \
InputTree.cpp \
- MCBitcodeInterceptor.cpp \
- MCFragmentRef.cpp \
MCLDAttribute.cpp \
MCLDDirectory.cpp \
MCLDDriver.cpp \
@@ -16,7 +14,6 @@
MCLDOptions.cpp \
MCLDOutput.cpp \
MCLinker.cpp \
- MCRegionFragment.cpp \
SearchDirs.cpp \
SymbolCategory.cpp \
ZOption.cpp
diff --git a/lib/MC/MCBitcodeInterceptor.cpp b/lib/MC/MCBitcodeInterceptor.cpp
deleted file mode 100644
index a79c904..0000000
--- a/lib/MC/MCBitcodeInterceptor.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//===- MCBitcodeInterceptor.cpp -------------------------------------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <mcld/LD/Relocation.h>
-#include <mcld/MC/MCBitcodeInterceptor.h>
-#include <mcld/MC/MCLDInfo.h>
-#include <mcld/Target/TargetLDBackend.h>
-#include <llvm/MC/MCAssembler.h>
-#include <llvm/MC/MCExpr.h>
-#include <llvm/MC/MCValue.h>
-#include <llvm/MC/MCFixup.h>
-#include <llvm/MC/MCFixupKindInfo.h>
-#include <llvm/MC/MCSymbol.h>
-#include <llvm/MC/MCAsmLayout.h>
-#include <llvm/MC/MCAsmBackend.h>
-#include <llvm/MC/MCAssembler.h>
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/MC/MCObjectStreamer.h>
-#include <llvm/Support/Casting.h>
-#include <llvm/Support/ELF.h>
-
-using namespace llvm;
-using namespace mcld;
-
-//===----------------------------------------------------------------------===//
-// non-member functions
-
-//===----------------------------------------------------------------------===//
-// MCBitcodeInterceptor
-MCBitcodeInterceptor::MCBitcodeInterceptor(MCObjectStreamer &pStreamer,
- TargetLDBackend& pBackend,
- MCLDInfo& pLDInfo)
- : MCObjectWriter(llvm::nulls(),
- pStreamer.getAssembler().getWriter().isLittleEndian()),
- m_Backend(pBackend),
- m_LDInfo(pLDInfo) {
- pStreamer.getAssembler().setWriter(*this);
-}
-
-MCBitcodeInterceptor::~MCBitcodeInterceptor()
-{
-}
-
-void MCBitcodeInterceptor::ExecutePostLayoutBinding(MCAssembler &Asm,
- const MCAsmLayout &Layout)
-{
-}
-
-
-void MCBitcodeInterceptor::RecordRelocation(const MCAssembler &Asm,
- const MCAsmLayout &Layout,
- const MCFragment *Fragment,
- const MCFixup &Fixup,
- MCValue Target,
- uint64_t &FixedValue)
-{
-}
-
-/// WriteObject - not really write out a object. Instead, load data to LDContext
-void MCBitcodeInterceptor::WriteObject(MCAssembler &Asm,
- const MCAsmLayout &Layout)
-{
-}
-
-
diff --git a/lib/MC/MCFragmentRef.cpp b/lib/MC/MCFragmentRef.cpp
deleted file mode 100644
index 69a865e..0000000
--- a/lib/MC/MCFragmentRef.cpp
+++ /dev/null
@@ -1,199 +0,0 @@
-//===- MCFragmentRef.cpp --------------------------------------------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-#include <llvm/Support/MathExtras.h>
-#include <mcld/MC/MCFragmentRef.h>
-#include <mcld/MC/MCRegionFragment.h>
-#include <mcld/MC/MCTargetFragment.h>
-#include <mcld/LD/Layout.h>
-#include <cstring>
-#include <cassert>
-
-using namespace mcld;
-
-/// compunteFragmentSize - compute the specific MCFragment size
-uint64_t mcld::computeFragmentSize(const Layout& pLayout,
- const llvm::MCFragment& pFrag)
-{
- switch (pFrag.getKind()) {
- case llvm::MCFragment::FT_Data:
- return static_cast<const llvm::MCDataFragment&>(pFrag).getContents().size();
- case llvm::MCFragment::FT_Fill:
- return static_cast<const llvm::MCFillFragment&>(pFrag).getSize();
- case llvm::MCFragment::FT_Inst:
- return static_cast<const llvm::MCInstFragment&>(pFrag).getInstSize();
-
- case llvm::MCFragment::FT_LEB:
- return static_cast<const llvm::MCLEBFragment&>(pFrag).getContents().size();
-
- case llvm::MCFragment::FT_Align: {
- uint64_t offset = pLayout.getOutputOffset(pFrag);
- const llvm::MCAlignFragment& align_frag = static_cast<const llvm::MCAlignFragment&>(pFrag);
- uint64_t size = llvm::OffsetToAlignment(offset, align_frag.getAlignment());
- if (size > align_frag.getMaxBytesToEmit())
- return 0;
- return size;
- }
-
- case llvm::MCFragment::FT_Org: {
- // TODO
- assert(0 && "FT_Org: Not implemented yet");
- return 0;
- }
-
- case llvm::MCFragment::FT_Dwarf:
- return static_cast<const llvm::MCDwarfLineAddrFragment&>(pFrag).getContents().size();
- case llvm::MCFragment::FT_DwarfFrame:
- return static_cast<const llvm::MCDwarfCallFrameFragment&>(pFrag).getContents().size();
-
- case llvm::MCFragment::FT_Region:
- return static_cast<const MCRegionFragment&>(pFrag).getRegion().size();
-
- case llvm::MCFragment::FT_Target:
- return static_cast<const MCTargetFragment&>(pFrag).getSize();
-
- case llvm::MCFragment::FT_Reloc:
- assert(0 && "the size of FT_Reloc fragment is handled by backend");
- return 0;
-
- default:
- assert(0 && "invalid fragment kind");
- return 0;
- }
-}
-
-//==========================
-// MCFragmentRef
-MCFragmentRef::MCFragmentRef()
- : m_pFragment(NULL), m_Offset(0) {
-}
-
-MCFragmentRef::MCFragmentRef(llvm::MCFragment& pFrag,
- MCFragmentRef::Offset pOffset)
- : m_pFragment(&pFrag), m_Offset(pOffset) {
-}
-
-MCFragmentRef::~MCFragmentRef()
-{
- m_pFragment = NULL;
- m_Offset = 0;
-}
-
-MCFragmentRef& MCFragmentRef::assign(const MCFragmentRef& pCopy)
-{
- m_pFragment = const_cast<llvm::MCFragment*>(pCopy.m_pFragment);
- m_Offset = pCopy.m_Offset;
- return *this;
-}
-
-MCFragmentRef& MCFragmentRef::assign(llvm::MCFragment& pFrag, MCFragmentRef::Offset pOffset)
-{
- m_pFragment = &pFrag;
- m_Offset = pOffset;
- return *this;
-}
-
-void MCFragmentRef::memcpy(void* pDest, size_t pNBytes, Offset pOffset) const
-{
- // check if the offset is still in a legal range.
- if (NULL == m_pFragment)
- return;
- unsigned int total_offset = m_Offset + pOffset;
- switch(m_pFragment->getKind()) {
- case llvm::MCFragment::FT_Inst: {
- llvm::MCInstFragment* inst_frag = static_cast<llvm::MCInstFragment*>(m_pFragment);
- unsigned int total_length = inst_frag->getCode().size();
- if (total_length < (total_offset+pNBytes))
- pNBytes = total_length - total_offset;
-
- std::memcpy(pDest, (inst_frag->getCode().data()+total_offset), pNBytes);
- return;
- }
- case llvm::MCFragment::FT_Data: {
- llvm::MCDataFragment* data_frag = static_cast<llvm::MCDataFragment*>(m_pFragment);
- unsigned int total_length = data_frag->getContents().size();
- if (total_length < (total_offset+pNBytes))
- pNBytes = total_length - total_offset;
-
- std::memcpy(pDest, (data_frag->getContents().data()+total_offset), pNBytes);
- return;
- }
- case llvm::MCFragment::FT_Region: {
- MCRegionFragment* region_frag = static_cast<mcld::MCRegionFragment*>(m_pFragment);
- unsigned int total_length = region_frag->getRegion().size();
- if (total_length < (total_offset+pNBytes))
- pNBytes = total_length - total_offset;
-
- std::memcpy(pDest, region_frag->getRegion().getBuffer(total_offset), pNBytes);
- return;
- }
- case llvm::MCFragment::FT_Align:
- case llvm::MCFragment::FT_Fill:
- case llvm::MCFragment::FT_Org:
- case llvm::MCFragment::FT_Dwarf:
- case llvm::MCFragment::FT_DwarfFrame:
- case llvm::MCFragment::FT_LEB:
- default:
- return;
- }
-}
-
-MCFragmentRef::Address MCFragmentRef::deref()
-{
- if (NULL == m_pFragment)
- return NULL;
- Address base = NULL;
- switch(m_pFragment->getKind()) {
- case llvm::MCFragment::FT_Inst:
- base = (Address)static_cast<llvm::MCInstFragment*>(m_pFragment)->getCode().data();
- break;
- case llvm::MCFragment::FT_Data:
- base = (Address)static_cast<llvm::MCDataFragment*>(m_pFragment)->getContents().data();
- break;
- case llvm::MCFragment::FT_Region:
- base = static_cast<mcld::MCRegionFragment*>(m_pFragment)->getRegion().getBuffer();
- break;
- case llvm::MCFragment::FT_Align:
- case llvm::MCFragment::FT_Fill:
- case llvm::MCFragment::FT_Org:
- case llvm::MCFragment::FT_Dwarf:
- case llvm::MCFragment::FT_DwarfFrame:
- case llvm::MCFragment::FT_LEB:
- default:
- return NULL;
- }
- return base + m_Offset;
-}
-
-MCFragmentRef::ConstAddress MCFragmentRef::deref() const
-{
- if (NULL == m_pFragment)
- return NULL;
- ConstAddress base = NULL;
- switch(m_pFragment->getKind()) {
- case llvm::MCFragment::FT_Inst:
- base = (ConstAddress)static_cast<const llvm::MCInstFragment*>(m_pFragment)->getCode().data();
- break;
- case llvm::MCFragment::FT_Data:
- base = (ConstAddress)static_cast<const llvm::MCDataFragment*>(m_pFragment)->getContents().data();
- break;
- case llvm::MCFragment::FT_Region:
- base = static_cast<const mcld::MCRegionFragment*>(m_pFragment)->getRegion().getBuffer();
- break;
- case llvm::MCFragment::FT_Align:
- case llvm::MCFragment::FT_Fill:
- case llvm::MCFragment::FT_Org:
- case llvm::MCFragment::FT_Dwarf:
- case llvm::MCFragment::FT_DwarfFrame:
- case llvm::MCFragment::FT_LEB:
- default:
- return NULL;
- }
- return base + m_Offset;
-}
-
diff --git a/lib/MC/MCLDDriver.cpp b/lib/MC/MCLDDriver.cpp
index a86983d..a1af124 100644
--- a/lib/MC/MCLDDriver.cpp
+++ b/lib/MC/MCLDDriver.cpp
@@ -21,14 +21,18 @@
#include <mcld/Support/MemoryAreaFactory.h>
#include <mcld/Target/TargetLDBackend.h>
#include <mcld/Support/MsgHandling.h>
+#include <mcld/LD/Archive.h>
using namespace llvm;
using namespace mcld;
-MCLDDriver::MCLDDriver(MCLDInfo& pLDInfo, TargetLDBackend& pLDBackend)
+MCLDDriver::MCLDDriver(MCLDInfo& pLDInfo,
+ TargetLDBackend& pLDBackend,
+ MemoryAreaFactory& pAreaFactory)
: m_LDInfo(pLDInfo),
m_LDBackend(pLDBackend),
- m_pLinker(NULL) {
+ m_pLinker(NULL),
+ m_AreaFactory(pAreaFactory) {
}
@@ -36,82 +40,6 @@
{
if (NULL != m_pLinker)
delete m_pLinker;
-
-}
-
-void MCLDDriver::normalize()
-{
- // ----- set up inputs ----- //
- InputTree::dfs_iterator input, inEnd = m_LDInfo.inputs().dfs_end();
- for (input = m_LDInfo.inputs().dfs_begin(); input!=inEnd; ++input) {
- // already got type - for example, bitcode or external OIR (object
- // intermediate representation)
- if ((*input)->type() == Input::Script ||
- (*input)->type() == Input::Object ||
- (*input)->type() == Input::DynObj ||
- (*input)->type() == Input::Archive ||
- (*input)->type() == Input::External)
- continue;
-
- // is a relocatable object file
- if (m_LDBackend.getObjectReader()->isMyFormat(**input)) {
- (*input)->setType(Input::Object);
- m_LDBackend.getObjectReader()->readObject(**input);
- }
- // is a shared object file
- else if (m_LDBackend.getDynObjReader()->isMyFormat(**input)) {
- (*input)->setType(Input::DynObj);
- m_LDBackend.getDynObjReader()->readDSO(**input);
- }
- // is an archive
- else if (m_LDBackend.getArchiveReader()->isMyFormat(*(*input))) {
- (*input)->setType(Input::Archive);
- mcld::InputTree* archive_member =
- m_LDBackend.getArchiveReader()->readArchive(**input);
- if(NULL == archive_member) {
- error(diag::err_empty_input) << (*input)->name() << (*input)->path();
- return;
- }
-
- m_LDInfo.inputs().merge<InputTree::Inclusive>(input, *archive_member);
- }
- else {
- fatal(diag::err_unrecognized_input_file) << (*input)->path()
- << m_LDInfo.triple().str();
- }
- } // end of for
-}
-
-bool MCLDDriver::linkable() const
-{
- // check we have input and output files
- if (m_LDInfo.inputs().empty()) {
- error(diag::err_no_inputs);
- return false;
- }
-
- // check all attributes are legal
- mcld::AttributeFactory::const_iterator attr, attrEnd = m_LDInfo.attrFactory().end();
- for (attr=m_LDInfo.attrFactory().begin(); attr!=attrEnd; ++attr) {
- if (!m_LDInfo.attrFactory().constraint().isLegal((**attr))) {
- return false;
- }
- }
-
- // can not mix -static with shared objects
- mcld::InputTree::const_bfs_iterator input, inEnd = m_LDInfo.inputs().bfs_end();
- for (input=m_LDInfo.inputs().bfs_begin(); input!=inEnd; ++input) {
- if ((*input)->type() == mcld::Input::DynObj) {
- if((*input)->attribute()->isStatic()) {
- error(diag::err_mixed_shared_static_objects)
- << (*input)->name() << (*input)->path();
- return false;
- }
- }
- }
-
- // can not mix -r with shared objects
- return true;
}
/// initMCLinker - initialize MCLinker
@@ -126,7 +54,8 @@
// initialize the readers and writers
// Because constructor can not be failed, we initalize all readers and
// writers outside the MCLinker constructors.
- if (!m_LDBackend.initArchiveReader(*m_pLinker, m_LDInfo) ||
+ if (!m_LDBackend.initObjectReader(*m_pLinker) ||
+ !m_LDBackend.initArchiveReader(*m_pLinker, m_LDInfo, m_AreaFactory) ||
!m_LDBackend.initObjectReader(*m_pLinker) ||
!m_LDBackend.initDynObjReader(*m_pLinker) ||
!m_LDBackend.initObjectWriter(*m_pLinker) ||
@@ -189,18 +118,78 @@
return true;
}
-/// readSections - read all input section headers
-bool MCLDDriver::readSections()
+void MCLDDriver::normalize()
{
- // Bitcode is read by the other path. This function reads sections in object
- // files.
- mcld::InputTree::bfs_iterator input, inEnd = m_LDInfo.inputs().bfs_end();
- for (input=m_LDInfo.inputs().bfs_begin(); input!=inEnd; ++input) {
- if ((*input)->type() == Input::Object) {
- if (!m_LDBackend.getObjectReader()->readSections(**input))
- return false;
+ // ----- set up inputs ----- //
+ InputTree::iterator input, inEnd = m_LDInfo.inputs().end();
+ for (input = m_LDInfo.inputs().begin(); input!=inEnd; ++input) {
+ // already got type - for example, bitcode or external OIR (object
+ // intermediate representation)
+ if ((*input)->type() == Input::Script ||
+ (*input)->type() == Input::Object ||
+ (*input)->type() == Input::DynObj ||
+ (*input)->type() == Input::Archive ||
+ (*input)->type() == Input::External)
+ continue;
+
+ // is a relocatable object file
+ if (m_LDBackend.getObjectReader()->isMyFormat(**input)) {
+ (*input)->setType(Input::Object);
+ m_LDBackend.getObjectReader()->readObject(**input);
+ m_LDBackend.getObjectReader()->readSections(**input);
+ m_LDBackend.getObjectReader()->readSymbols(**input);
+ }
+ // is a shared object file
+ else if (m_LDBackend.getDynObjReader()->isMyFormat(**input)) {
+ (*input)->setType(Input::DynObj);
+ m_LDBackend.getDynObjReader()->readDSO(**input);
+ m_LDBackend.getDynObjReader()->readSymbols(**input);
+ }
+ // is an archive
+ else if (m_LDBackend.getArchiveReader()->isMyFormat(**input)) {
+ (*input)->setType(Input::Archive);
+ Archive archive(**input, m_LDInfo.inputFactory());
+ m_LDBackend.getArchiveReader()->readArchive(archive);
+ if(archive.numOfObjectMember() > 0) {
+ m_LDInfo.inputs().merge<InputTree::Inclusive>(input, archive.inputs());
+ }
+ }
+ else {
+ fatal(diag::err_unrecognized_input_file) << (*input)->path()
+ << m_LDInfo.triple().str();
+ }
+ } // end of for
+}
+
+bool MCLDDriver::linkable() const
+{
+ // check we have input and output files
+ if (m_LDInfo.inputs().empty()) {
+ error(diag::err_no_inputs);
+ return false;
+ }
+
+ // check all attributes are legal
+ mcld::AttributeFactory::const_iterator attr, attrEnd = m_LDInfo.attrFactory().end();
+ for (attr=m_LDInfo.attrFactory().begin(); attr!=attrEnd; ++attr) {
+ if (!m_LDInfo.attrFactory().constraint().isLegal((**attr))) {
+ return false;
}
}
+
+ // can not mix -static with shared objects
+ mcld::InputTree::const_bfs_iterator input, inEnd = m_LDInfo.inputs().bfs_end();
+ for (input=m_LDInfo.inputs().bfs_begin(); input!=inEnd; ++input) {
+ if ((*input)->type() == mcld::Input::DynObj) {
+ if((*input)->attribute()->isStatic()) {
+ error(diag::err_mixed_shared_static_objects)
+ << (*input)->name() << (*input)->path();
+ return false;
+ }
+ }
+ }
+
+ // can not mix -r with shared objects
return true;
}
@@ -212,26 +201,6 @@
return true;
}
-/// readSymbolTables - read symbol tables from the input files.
-/// for each input file, loads its symbol table from file.
-bool MCLDDriver::readSymbolTables()
-{
- mcld::InputTree::dfs_iterator input, inEnd = m_LDInfo.inputs().dfs_end();
- for (input=m_LDInfo.inputs().dfs_begin(); input!=inEnd; ++input) {
- switch((*input)->type()) {
- case Input::DynObj:
- if (!m_LDBackend.getDynObjReader()->readSymbols(**input))
- return false;
- break;
- case Input::Object:
- if (!m_LDBackend.getObjectReader()->readSymbols(**input))
- return false;
- break;
- }
- }
- return true;
-}
-
/// addStandardSymbols - shared object and executable files need some
/// standard symbols
/// @return if there are some input symbols with the same name to the
diff --git a/lib/MC/MCLinker.cpp b/lib/MC/MCLinker.cpp
index 7321e49..e9fb327 100644
--- a/lib/MC/MCLinker.cpp
+++ b/lib/MC/MCLinker.cpp
@@ -1,4 +1,4 @@
-//===- MCLinker.cpp -----------------------------------------------------===//
+//===- MCLinker.cpp -------------------------------------------------------===//
//
// The MCLinker Project
//
@@ -11,6 +11,10 @@
//
//===----------------------------------------------------------------------===//
#include <mcld/MC/MCLinker.h>
+
+#include <llvm/Support/Host.h>
+#include <llvm/Support/raw_ostream.h>
+
#include <mcld/MC/MCLDInput.h>
#include <mcld/MC/MCLDInfo.h>
#include <mcld/LD/Resolver.h>
@@ -19,13 +23,13 @@
#include <mcld/LD/LDSectionFactory.h>
#include <mcld/LD/SectionMap.h>
#include <mcld/LD/RelocationFactory.h>
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/RegionFragment.h>
#include <mcld/LD/EhFrame.h>
#include <mcld/LD/EhFrameHdr.h>
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MsgHandling.h>
#include <mcld/Target/TargetLDBackend.h>
-#include <llvm/Support/Host.h>
-#include <llvm/Support/raw_ostream.h>
using namespace mcld;
@@ -50,6 +54,9 @@
delete m_pSectionMerger;
}
+//===----------------------------------------------------------------------===//
+// Symbol Operations
+//===----------------------------------------------------------------------===//
/// addSymbolFromObject - add a symbol from object file and resolve it
/// immediately
LDSymbol* MCLinker::addSymbolFromObject(const llvm::StringRef& pName,
@@ -58,7 +65,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
@@ -165,7 +172,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
// We merge sections when reading them. So we do not need symbols with
@@ -236,7 +243,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
ResolveInfo* info = m_LDInfo.getNamePool().findInfo(pName);
@@ -306,13 +313,13 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
ResolveInfo* info = m_LDInfo.getNamePool().findInfo(pName);
- if (NULL == info || !info->isUndef()) {
- // only undefined symbol can make a reference.
+ if (NULL == info || !(info->isUndef() || info->isDyn())) {
+ // only undefined symbol and dynamic symbol can make a reference.
return NULL;
}
@@ -357,7 +364,7 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
// Result is <info, existent, override>
@@ -403,13 +410,13 @@
ResolveInfo::Binding pBinding,
ResolveInfo::SizeType pSize,
LDSymbol::ValueType pValue,
- MCFragmentRef* pFragmentRef,
+ FragmentRef* pFragmentRef,
ResolveInfo::Visibility pVisibility)
{
ResolveInfo* info = m_LDInfo.getNamePool().findInfo(pName);
- if (NULL == info || !info->isUndef()) {
- // only undefined symbol can make a reference
+ if (NULL == info || !(info->isUndef() || info->isDyn())) {
+ // only undefined symbol and dynamic symbol can make a reference.
return NULL;
}
@@ -424,6 +431,54 @@
pVisibility);
}
+bool MCLinker::finalizeSymbols()
+{
+ SymbolCategory::iterator symbol, symEnd = m_OutputSymbols.end();
+ for (symbol = m_OutputSymbols.begin(); symbol != symEnd; ++symbol) {
+
+ if ((*symbol)->resolveInfo()->isAbsolute() ||
+ (*symbol)->resolveInfo()->type() == ResolveInfo::File) {
+ // absolute symbols or symbols with function type should have
+ // zero value
+ (*symbol)->setValue(0x0);
+ continue;
+ }
+
+ if ((*symbol)->hasFragRef()) {
+ // set the virtual address of the symbol. If the output file is
+ // relocatable object file, the section's virtual address becomes zero.
+ // And the symbol's value become section relative offset.
+ uint64_t value = getLayout().getOutputOffset(*(*symbol)->fragRef());
+ assert(NULL != (*symbol)->fragRef()->frag());
+ uint64_t addr = getLayout().getOutputLDSection(*(*symbol)->fragRef()->frag())->addr();
+ (*symbol)->setValue(value + addr);
+ continue;
+ }
+ }
+
+ // finialize target-dependent symbols
+ return m_Backend.finalizeSymbols(*this, m_LDInfo.output());
+}
+
+bool MCLinker::shouldForceLocal(const ResolveInfo& pInfo) const
+{
+ // forced local symbol matches all rules:
+ // 1. We are not doing incremental linking.
+ // 2. The symbol is with Hidden or Internal visibility.
+ // 3. The symbol should be global or weak. Otherwise, local symbol is local.
+ // 4. The symbol is defined or common
+ if (m_LDInfo.output().type() != Output::Object &&
+ (pInfo.visibility() == ResolveInfo::Hidden ||
+ pInfo.visibility() == ResolveInfo::Internal) &&
+ (pInfo.isGlobal() || pInfo.isWeak()) &&
+ (pInfo.isDefine() || pInfo.isCommon()))
+ return true;
+ return false;
+}
+
+//===----------------------------------------------------------------------===//
+// Section Operations
+//===----------------------------------------------------------------------===//
/// createSectHdr - create the input section header
LDSection& MCLinker::createSectHdr(const std::string& pName,
LDFileFormat::Kind pKind,
@@ -475,12 +530,12 @@
return *output_sect;
}
-/// getOrCreateSectData - get or create MCSectionData
+/// getOrCreateSectData - get or create SectionData
/// pSection is input LDSection
-llvm::MCSectionData& MCLinker::getOrCreateSectData(LDSection& pSection)
+SectionData& MCLinker::getOrCreateSectData(LDSection& pSection)
{
// if there is already a section data pointed by section, return it.
- llvm::MCSectionData* sect_data = pSection.getSectionData();
+ SectionData* sect_data = pSection.getSectionData();
if (NULL != sect_data) {
m_Layout.addInputRange(*sect_data, pSection);
return *sect_data;
@@ -500,22 +555,37 @@
return *sect_data;
}
- // if the output LDSection also has no MCSectionData, then create one.
+ // if the output LDSection also has no SectionData, then create one.
sect_data = m_LDSectDataFactory.allocate();
- new (sect_data) llvm::MCSectionData(*output_sect);
+ new (sect_data) SectionData(*output_sect);
pSection.setSectionData(sect_data);
output_sect->setSectionData(sect_data);
m_Layout.addInputRange(*sect_data, pSection);
return *sect_data;
}
+void MCLinker::initSectionMap()
+{
+ assert(m_LDInfo.output().hasContext());
+ if (NULL == m_pSectionMerger)
+ m_pSectionMerger = new SectionMerger(m_SectionMap, *m_LDInfo.output().context());
+}
+
+bool MCLinker::layout()
+{
+ return m_Layout.layout(m_LDInfo.output(), m_Backend, m_LDInfo);
+}
+
+//===----------------------------------------------------------------------===//
+// Relocation Operations
+//===----------------------------------------------------------------------===//
/// addRelocation - add a relocation entry in MCLinker (only for object file)
///
/// All symbols should be read and resolved before calling this function.
Relocation* MCLinker::addRelocation(Relocation::Type pType,
const LDSymbol& pSym,
ResolveInfo& pResolveInfo,
- MCFragmentRef& pFragmentRef,
+ FragmentRef& pFragmentRef,
const LDSection& pSection,
Relocation::Address pAddend)
{
@@ -548,7 +618,7 @@
RelocationListType::iterator relocIter, relocEnd = m_RelocationList.end();
for (relocIter = m_RelocationList.begin(); relocIter != relocEnd; ++relocIter) {
- llvm::MCFragment* frag = (llvm::MCFragment*)relocIter;
+ Fragment* frag = (Fragment*)relocIter;
static_cast<Relocation*>(frag)->apply(*m_Backend.getRelocFactory(), m_LDInfo);
}
return true;
@@ -565,7 +635,7 @@
RelocationListType::iterator relocIter, relocEnd = m_RelocationList.end();
for (relocIter = m_RelocationList.begin(); relocIter != relocEnd; ++relocIter) {
- llvm::MCFragment* frag = (llvm::MCFragment*)relocIter;
+ Fragment* frag = (Fragment*)relocIter;
Relocation* reloc = static_cast<Relocation*>(frag);
// get output file offset
@@ -600,63 +670,9 @@
m_LDInfo.output().memArea()->clear();
}
-void MCLinker::initSectionMap()
-{
- assert(m_LDInfo.output().hasContext());
- if (NULL == m_pSectionMerger)
- m_pSectionMerger = new SectionMerger(m_SectionMap, *m_LDInfo.output().context());
-}
-
-bool MCLinker::layout()
-{
- return m_Layout.layout(m_LDInfo.output(), m_Backend, m_LDInfo);
-}
-
-bool MCLinker::finalizeSymbols()
-{
- SymbolCategory::iterator symbol, symEnd = m_OutputSymbols.end();
- for (symbol = m_OutputSymbols.begin(); symbol != symEnd; ++symbol) {
-
- if ((*symbol)->resolveInfo()->isAbsolute() ||
- (*symbol)->resolveInfo()->type() == ResolveInfo::File) {
- // absolute symbols or symbols with function type should have
- // zero value
- (*symbol)->setValue(0x0);
- continue;
- }
-
- if ((*symbol)->hasFragRef()) {
- // set the virtual address of the symbol. If the output file is
- // relocatable object file, the section's virtual address becomes zero.
- // And the symbol's value become section relative offset.
- uint64_t value = getLayout().getOutputOffset(*(*symbol)->fragRef());
- assert(NULL != (*symbol)->fragRef()->frag());
- uint64_t addr = getLayout().getOutputLDSection(*(*symbol)->fragRef()->frag())->addr();
- (*symbol)->setValue(value + addr);
- continue;
- }
- }
-
- // finialize target-dependent symbols
- return m_Backend.finalizeSymbols(*this, m_LDInfo.output());
-}
-
-bool MCLinker::shouldForceLocal(const ResolveInfo& pInfo) const
-{
- // forced local symbol matches all rules:
- // 1. We are not doing incremental linking.
- // 2. The symbol is with Hidden or Internal visibility.
- // 3. The symbol should be global or weak. Otherwise, local symbol is local.
- // 4. The symbol is defined or common
- if (m_LDInfo.output().type() != Output::Object &&
- (pInfo.visibility() == ResolveInfo::Hidden ||
- pInfo.visibility() == ResolveInfo::Internal) &&
- (pInfo.isGlobal() || pInfo.isWeak()) &&
- (pInfo.isDefine() || pInfo.isCommon()))
- return true;
- return false;
-}
-
+//===----------------------------------------------------------------------===//
+// Exception Handling Operations
+//===----------------------------------------------------------------------===//
/// addEhFrame - add an exception handling section
/// @param pSection - the input section
/// @param pArea - the memory area which pSection is within.
@@ -667,7 +683,7 @@
uint64_t size = 0;
// get the SectionData of this eh_frame
- llvm::MCSectionData& sect_data = getOrCreateSectData(pSection);
+ SectionData& sect_data = getOrCreateSectData(pSection);
// parse the eh_frame if the option --eh-frame-hdr is given
if (m_LDInfo.options().hasEhFrameHdr()) {
@@ -687,14 +703,14 @@
MemoryRegion* region = pArea.request(pInput.fileOffset() + pSection.offset(),
pSection.size());
- llvm::MCFragment* frag = NULL;
+ Fragment* frag = NULL;
if (NULL == region) {
// If the input section's size is zero, we got a NULL region.
// use a virtual fill fragment
- frag = new llvm::MCFillFragment(0x0, 0, 0);
+ frag = new FillFragment(0x0, 0, 0);
}
else
- frag = new MCRegionFragment(*region);
+ frag = new RegionFragment(*region);
size = m_Layout.appendFragment(*frag, sect_data, pSection.align());
return size;
diff --git a/lib/MC/MCRegionFragment.cpp b/lib/MC/MCRegionFragment.cpp
deleted file mode 100644
index 59b109a..0000000
--- a/lib/MC/MCRegionFragment.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//===- MCRegionFragment.cpp - MCRegionFragment implementation -------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "mcld/MC/MCRegionFragment.h"
-
-using namespace mcld;
-using namespace llvm;
-
-//==========================
-// MCRegionFragment
-MCRegionFragment::MCRegionFragment(MemoryRegion& pRegion, MCSectionData* pSD)
- : MCFragment((llvm::MCFragment::FragmentType)FT_Region, pSD), m_Region(pRegion) {
-}
-
-MCRegionFragment::~MCRegionFragment()
-{
-}
-
diff --git a/lib/Support/CommandLine.cpp b/lib/Support/CommandLine.cpp
index cc15e37..891b2bb 100644
--- a/lib/Support/CommandLine.cpp
+++ b/lib/Support/CommandLine.cpp
@@ -16,9 +16,9 @@
using namespace mcld;
-//--------------------------------------------------
+//===----------------------------------------------------------------------===//
// parser<mcld::sys::fs::Path>
-//
+//===----------------------------------------------------------------------===//
bool parser<mcld::sys::fs::Path>::parse(llvm::cl::Option &O,
llvm::StringRef ArgName,
llvm::StringRef Arg,
@@ -52,9 +52,9 @@
// do nothing
}
-//--------------------------------------------------
+//===----------------------------------------------------------------------===//
// parser<mcld::MCLDDirectory>
-//
+//===----------------------------------------------------------------------===//
bool parser<mcld::MCLDDirectory>::parse(llvm::cl::Option &O,
llvm::StringRef ArgName,
llvm::StringRef Arg,
@@ -86,9 +86,9 @@
// do nothing
}
-//--------------------------------------------------
+//===----------------------------------------------------------------------===//
// parser<mcld::ZOption>
-//
+//===----------------------------------------------------------------------===//
bool parser<mcld::ZOption>::parse(llvm::cl::Option &O,
llvm::StringRef ArgName,
llvm::StringRef Arg,
diff --git a/lib/Support/FileHandle.cpp b/lib/Support/FileHandle.cpp
index f6b898c..6d43a4c 100644
--- a/lib/Support/FileHandle.cpp
+++ b/lib/Support/FileHandle.cpp
@@ -219,9 +219,6 @@
return true;
}
-#include <iostream>
-using namespace std;
-
bool FileHandle::mmap(void*& pMemBuffer, size_t pStartOffset, size_t pLength)
{
if (!isOpened()) {
diff --git a/lib/Support/Path.cpp b/lib/Support/Path.cpp
index e35132f..7f516f6 100644
--- a/lib/Support/Path.cpp
+++ b/lib/Support/Path.cpp
@@ -140,6 +140,14 @@
m_PathName.erase(begin+1,pSepPos-begin-1);
}
+Path Path::parent_path() const
+{
+ size_t end_pos = m_PathName.find_last_of(separator);
+ if (end_pos != StringType::npos)
+ return Path(m_PathName.substr(0, end_pos));
+ return Path();
+}
+
Path Path::stem() const
{
size_t begin_pos = m_PathName.find_last_of(separator)+1;
diff --git a/lib/Support/Unix/System.inc b/lib/Support/Unix/System.inc
index 716aaa2..a7ec15f 100644
--- a/lib/Support/Unix/System.inc
+++ b/lib/Support/Unix/System.inc
@@ -6,7 +6,7 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <string>
+#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
@@ -16,7 +16,7 @@
char *strerror(int errnum)
{
- return ::strerror(errnum);
+ return std::strerror(errnum);
}
} // namespace of sys
diff --git a/lib/Target/ARM/ARMGOT.cpp b/lib/Target/ARM/ARMGOT.cpp
index af37768..200bcb5 100644
--- a/lib/Target/ARM/ARMGOT.cpp
+++ b/lib/Target/ARM/ARMGOT.cpp
@@ -7,10 +7,14 @@
//
//===----------------------------------------------------------------------===//
#include "ARMGOT.h"
+
+#include <new>
+
+#include <llvm/Support/Casting.h>
+
#include <mcld/LD/LDFileFormat.h>
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MsgHandling.h>
-#include <new>
namespace {
const size_t ARMGOTEntrySize = 4;
@@ -20,7 +24,7 @@
//===----------------------------------------------------------------------===//
// ARMGOT
-ARMGOT::ARMGOT(LDSection& pSection, llvm::MCSectionData& pSectionData)
+ARMGOT::ARMGOT(LDSection& pSection, SectionData& pSectionData)
: GOT(pSection, pSectionData, ARMGOTEntrySize),
m_NormalGOTIterator(), m_GOTPLTIterator(),
m_GOTPLTBegin(), m_GOTPLTEnd()
@@ -33,7 +37,7 @@
&m_SectionData);
if (!Entry)
- fatal(diag::fail_allocate_memory) << "GOT0";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + ARMGOTEntrySize);
}
@@ -66,7 +70,7 @@
&m_SectionData);
if (!Entry)
- fatal(diag::fail_allocate_memory) << "GOTEntry";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + ARMGOTEntrySize);
}
@@ -79,7 +83,7 @@
got_entry= new GOTEntry(0, getEntrySize(),&(getSectionData()));
if (!got_entry)
- fatal(diag::fail_allocate_memory) << "GOTEntry";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + getEntrySize());
diff --git a/lib/Target/ARM/ARMGOT.h b/lib/Target/ARM/ARMGOT.h
index 90f0f53..13d3424 100644
--- a/lib/Target/ARM/ARMGOT.h
+++ b/lib/Target/ARM/ARMGOT.h
@@ -12,7 +12,10 @@
#include <gtest.h>
#endif
+#include <llvm/ADT/DenseMap.h>
+
#include <mcld/Target/GOT.h>
+#include <mcld/LD/SectionData.h>
namespace mcld
{
@@ -27,15 +30,15 @@
typedef llvm::DenseMap<const ResolveInfo*, GOTEntry*> SymbolIndexMapType;
public:
- typedef llvm::MCSectionData::iterator iterator;
- typedef llvm::MCSectionData::const_iterator const_iterator;
+ typedef SectionData::iterator iterator;
+ typedef SectionData::const_iterator const_iterator;
enum {
ARMGOT0Num = 3
};
public:
- ARMGOT(LDSection &pSection, llvm::MCSectionData& pSectionData);
+ ARMGOT(LDSection &pSection, SectionData& pSectionData);
~ARMGOT();
diff --git a/lib/Target/ARM/ARMLDBackend.cpp b/lib/Target/ARM/ARMLDBackend.cpp
index 81915c9..a44f1da 100644
--- a/lib/Target/ARM/ARMLDBackend.cpp
+++ b/lib/Target/ARM/ARMLDBackend.cpp
@@ -6,28 +6,34 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <llvm/ADT/Triple.h>
-#include <llvm/ADT/Twine.h>
-#include <llvm/Support/ELF.h>
-
-#include <mcld/LD/SectionMap.h>
-#include <mcld/MC/MCLDInfo.h>
-#include <mcld/MC/MCLDOutput.h>
-#include <mcld/MC/MCLinker.h>
-#include <mcld/MC/MCRegionFragment.h>
-#include <mcld/Support/MemoryRegion.h>
-#include <mcld/Support/MsgHandling.h>
-#include <mcld/Support/TargetRegistry.h>
-
-#include <cstring>
-
#include "ARM.h"
#include "ARMELFDynamic.h"
#include "ARMLDBackend.h"
#include "ARMRelocationFactory.h"
+#include <cstring>
+
+#include <llvm/ADT/Triple.h>
+#include <llvm/ADT/Twine.h>
+#include <llvm/Support/ELF.h>
+#include <llvm/Support/Casting.h>
+
+#include <mcld/LD/SectionMap.h>
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/AlignFragment.h>
+#include <mcld/LD/RegionFragment.h>
+#include <mcld/MC/MCLDInfo.h>
+#include <mcld/MC/MCLDOutput.h>
+#include <mcld/MC/MCLinker.h>
+#include <mcld/Support/MemoryRegion.h>
+#include <mcld/Support/MsgHandling.h>
+#include <mcld/Support/TargetRegistry.h>
+
using namespace mcld;
+//===----------------------------------------------------------------------===//
+// ARMGNULDBackend
+//===----------------------------------------------------------------------===//
ARMGNULDBackend::ARMGNULDBackend()
: m_pRelocFactory(NULL),
m_pGOT(NULL),
@@ -176,7 +182,7 @@
void ARMGNULDBackend::createARMGOT(MCLinker& pLinker, const Output& pOutput)
{
- // get .got LDSection and create MCSectionData
+ // get .got LDSection and create SectionData
ELFFileFormat* file_format = getOutputFormat(pOutput);
LDSection& got = file_format->getGOT();
@@ -218,11 +224,11 @@
// get .plt and .rel.plt LDSection
LDSection& plt = file_format->getPLT();
LDSection& relplt = file_format->getRelPlt();
- // create MCSectionData and ARMPLT
+ // create SectionData and ARMPLT
m_pPLT = new ARMPLT(plt, pLinker.getOrCreateSectData(plt), *m_pGOT);
// set info of .rel.plt to .plt
relplt.setLink(&plt);
- // create MCSectionData and ARMRelDynSection
+ // create SectionData and ARMRelDynSection
m_pRelPLT = new OutputRelocSection(relplt,
pLinker.getOrCreateSectData(relplt),
8);
@@ -233,9 +239,9 @@
{
ELFFileFormat* file_format = getOutputFormat(pOutput);
- // get .rel.dyn LDSection and create MCSectionData
+ // get .rel.dyn LDSection and create SectionData
LDSection& reldyn = file_format->getRelDyn();
- // create MCSectionData and ARMRelDynSection
+ // create SectionData and ARMRelDynSection
m_pRelDyn = new OutputRelocSection(reldyn,
pLinker.getOrCreateSectData(reldyn),
8);
@@ -274,9 +280,9 @@
llvm::ELF::SHF_WRITE | llvm::ELF::SHF_ALLOC);
}
- // get or create corresponding BSS MCSectionData
+ // get or create corresponding BSS SectionData
assert(NULL != bss_sect_hdr);
- llvm::MCSectionData& bss_section = pLinker.getOrCreateSectData(
+ SectionData& bss_section = pLinker.getOrCreateSectData(
*bss_sect_hdr);
// Determine the alignment by the symbol value
@@ -284,7 +290,7 @@
uint32_t addralign = bitclass() / 8;
// allocate space in BSS for the copy symbol
- llvm::MCFragment* frag = new llvm::MCFillFragment(0x0, 1, pSym.size());
+ Fragment* frag = new FillFragment(0x0, 1, pSym.size());
uint64_t size = pLinker.getLayout().appendFragment(*frag,
bss_section,
addralign);
@@ -763,22 +769,21 @@
&pSection == m_pEXTAB) {
// FIXME: Currently Emitting .ARM.attributes, .ARM.exidx, and .ARM.extab
// directly from the input file.
- const llvm::MCSectionData* sect_data = pSection.getSectionData();
- llvm::MCSectionData::const_iterator frag_iter, frag_end = sect_data->end();
+ const SectionData* sect_data = pSection.getSectionData();
+ SectionData::const_iterator frag_iter, frag_end = sect_data->end();
uint8_t* out_offset = pRegion.start();
for (frag_iter = sect_data->begin(); frag_iter != frag_end; ++frag_iter) {
size_t size = computeFragmentSize(pLayout, *frag_iter);
switch(frag_iter->getKind()) {
- case llvm::MCFragment::FT_Region: {
- const MCRegionFragment& region_frag =
- llvm::cast<MCRegionFragment>(*frag_iter);
+ case Fragment::Region: {
+ const RegionFragment& region_frag =
+ llvm::cast<RegionFragment>(*frag_iter);
const uint8_t* start = region_frag.getRegion().start();
memcpy(out_offset, start, size);
break;
}
- case llvm::MCFragment::FT_Align: {
- llvm::MCAlignFragment& align_frag =
- llvm::cast<llvm::MCAlignFragment>(*frag_iter);
+ case Fragment::Alignment: {
+ AlignFragment& align_frag = llvm::cast<AlignFragment>(*frag_iter);
uint64_t count = size / align_frag.getValueSize();
switch (align_frag.getValueSize()) {
case 1u:
@@ -844,16 +849,16 @@
MemoryRegion* region = pInput.memArea()->request(
pInput.fileOffset() + pInputSectHdr.offset(), pInputSectHdr.size());
- llvm::MCSectionData& sect_data = pLinker.getOrCreateSectData(pInputSectHdr);
+ SectionData& sect_data = pLinker.getOrCreateSectData(pInputSectHdr);
- llvm::MCFragment* frag = NULL;
+ Fragment* frag = NULL;
if (NULL == region) {
// If the input section's size is zero, we got a NULL region.
// use a virtual fill fragment
- frag = new llvm::MCFillFragment(0x0, 0, 0);
+ frag = new FillFragment(0x0, 0, 0);
}
else
- frag = new MCRegionFragment(*region);
+ frag = new RegionFragment(*region);
uint64_t size = pLinker.getLayout().appendFragment(*frag,
sect_data,
diff --git a/lib/Target/ARM/ARMLDBackend.h b/lib/Target/ARM/ARMLDBackend.h
index 3e46cd7..981228e 100644
--- a/lib/Target/ARM/ARMLDBackend.h
+++ b/lib/Target/ARM/ARMLDBackend.h
@@ -155,7 +155,7 @@
/// call back target backend to emit the data.
///
/// Backends handle the target-special tables (plt, gp,...) by themselves.
- /// Backend can put the data of the tables in MCSectionData directly
+ /// Backend can put the data of the tables in SectionData directly
/// - LDSection.getSectionData can get the section data.
/// Or, backend can put the data into special data structure
/// - backend can maintain its own map<LDSection, table> to get the table
diff --git a/lib/Target/ARM/ARMPLT.cpp b/lib/Target/ARM/ARMPLT.cpp
index 015d767..c9bc333 100644
--- a/lib/Target/ARM/ARMPLT.cpp
+++ b/lib/Target/ARM/ARMPLT.cpp
@@ -8,10 +8,13 @@
//===----------------------------------------------------------------------===//
#include "ARMGOT.h"
#include "ARMPLT.h"
-#include <llvm/Support/raw_ostream.h>
+
+#include <new>
+
+#include <llvm/Support/Casting.h>
+
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MsgHandling.h>
-#include <new>
namespace {
@@ -33,17 +36,17 @@
using namespace mcld;
-ARMPLT0::ARMPLT0(llvm::MCSectionData* pParent)
+ARMPLT0::ARMPLT0(SectionData* pParent)
: PLTEntry(sizeof(arm_plt0), pParent) {}
-ARMPLT1::ARMPLT1(llvm::MCSectionData* pParent)
+ARMPLT1::ARMPLT1(SectionData* pParent)
: PLTEntry(sizeof(arm_plt1), pParent) {}
//===----------------------------------------------------------------------===//
// ARMPLT
ARMPLT::ARMPLT(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
+ SectionData& pSectionData,
ARMGOT &pGOTPLT)
: PLT(pSection, pSectionData), m_GOT(pGOTPLT), m_PLTEntryIterator() {
ARMPLT0* plt0_entry = new ARMPLT0(&m_SectionData);
@@ -65,7 +68,7 @@
plt1_entry = new (std::nothrow) ARMPLT1(&m_SectionData);
if (!plt1_entry)
- fatal(diag::fail_allocate_memory) << "ARMPLT1";
+ fatal(diag::fail_allocate_memory_plt);
m_Section.setSize(m_Section.size() + plt1_entry->getEntrySize());
@@ -166,7 +169,7 @@
data = static_cast<uint32_t*>(malloc(plt0->getEntrySize()));
if (!data)
- fatal(diag::fail_allocate_memory) << "plt0";
+ fatal(diag::fail_allocate_memory_plt);
memcpy(data, arm_plt0, plt0->getEntrySize());
data[4] = offset;
@@ -203,7 +206,7 @@
Out = static_cast<uint32_t*>(malloc(plt1->getEntrySize()));
if (!Out)
- fatal(diag::fail_allocate_memory) << "plt1";
+ fatal(diag::fail_allocate_memory_plt);
// Offset is the distance between the last PLT entry and the associated
// GOT entry.
diff --git a/lib/Target/ARM/ARMPLT.h b/lib/Target/ARM/ARMPLT.h
index f55aaa3..db36563 100644
--- a/lib/Target/ARM/ARMPLT.h
+++ b/lib/Target/ARM/ARMPLT.h
@@ -9,6 +9,7 @@
#ifndef MCLD_ARM_PLT_H
#define MCLD_ARM_PLT_H
+#include <mcld/LD/SectionData.h>
#include <mcld/Target/PLT.h>
namespace mcld {
@@ -19,12 +20,12 @@
class ARMPLT0 : public PLTEntry {
public:
- ARMPLT0(llvm::MCSectionData* pParent);
+ ARMPLT0(SectionData* pParent);
};
class ARMPLT1 : public PLTEntry {
public:
- ARMPLT1(llvm::MCSectionData* pParent);
+ ARMPLT1(SectionData* pParent);
};
/** \class ARMPLT
@@ -35,13 +36,11 @@
typedef llvm::DenseMap<const ResolveInfo*, ARMPLT1*> SymbolIndexType;
public:
- typedef llvm::MCSectionData::iterator iterator;
- typedef llvm::MCSectionData::const_iterator const_iterator;
+ typedef SectionData::iterator iterator;
+ typedef SectionData::const_iterator const_iterator;
public:
- ARMPLT(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
- ARMGOT& pGOTPLT);
+ ARMPLT(LDSection& pSection, SectionData& pSectionData, ARMGOT& pGOTPLT);
~ARMPLT();
// Override virtual function.
diff --git a/lib/Target/ARM/ARMRelocationFactory.cpp b/lib/Target/ARM/ARMRelocationFactory.cpp
index 3d4b0dc..cc561db 100644
--- a/lib/Target/ARM/ARMRelocationFactory.cpp
+++ b/lib/Target/ARM/ARMRelocationFactory.cpp
@@ -169,7 +169,7 @@
rel_entry.targetRef().assign(got_entry);
}
else {
- fatal(diag::reserve_entry_number_mismatch) << "GOT";
+ fatal(diag::reserve_entry_number_mismatch_got);
}
}
return got_entry;
@@ -216,7 +216,7 @@
rel_entry.setSymInfo(rsym);
}
else {
- fatal(diag::reserve_entry_number_mismatch) << "PLT";
+ fatal(diag::reserve_entry_number_mismatch_plt);
}
}
return plt_entry;
diff --git a/lib/Target/GNULDBackend.cpp b/lib/Target/GNULDBackend.cpp
index 69d0927..f81133f 100644
--- a/lib/Target/GNULDBackend.cpp
+++ b/lib/Target/GNULDBackend.cpp
@@ -6,27 +6,34 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <llvm/Support/ELF.h>
-#include <mcld/ADT/SizeTraits.h>
+
#include <mcld/Target/GNULDBackend.h>
+
+#include <string>
+#include <cstring>
+#include <cassert>
+
+#include <llvm/Support/ELF.h>
+
+#include <mcld/ADT/SizeTraits.h>
+#include <mcld/LD/LDSymbol.h>
+#include <mcld/LD/Layout.h>
+#include <mcld/LD/FillFragment.h>
#include <mcld/MC/MCLDInfo.h>
#include <mcld/MC/MCLDOutput.h>
#include <mcld/MC/InputTree.h>
#include <mcld/MC/SymbolCategory.h>
-#include <mcld/LD/LDSymbol.h>
-#include <mcld/LD/Layout.h>
+#include <mcld/MC/MCLinker.h>
#include <mcld/Support/MemoryArea.h>
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MsgHandling.h>
-#include <mcld/MC/MCLinker.h>
-#include <string>
-#include <cstring>
-#include <cassert>
+#include <mcld/Support/MemoryAreaFactory.h>
using namespace mcld;
//===----------------------------------------------------------------------===//
// GNULDBackend
+//===----------------------------------------------------------------------===//
GNULDBackend::GNULDBackend()
: m_pArchiveReader(NULL),
m_pObjectReader(NULL),
@@ -97,10 +104,16 @@
return defaultTextSegmentAddr();
}
-bool GNULDBackend::initArchiveReader(MCLinker&, MCLDInfo &pInfo)
+bool GNULDBackend::initArchiveReader(MCLinker& pLinker,
+ MCLDInfo& pInfo,
+ MemoryAreaFactory& pMemAreaFactory)
{
- if (NULL == m_pArchiveReader)
- m_pArchiveReader = new GNUArchiveReader(pInfo);
+ if (NULL == m_pArchiveReader) {
+ assert(NULL != m_pObjectReader);
+ m_pArchiveReader = new GNUArchiveReader(pInfo,
+ pMemAreaFactory,
+ *m_pObjectReader);
+ }
return true;
}
@@ -164,7 +177,7 @@
// ----- section symbols ----- //
// .preinit_array
- MCFragmentRef* preinit_array = NULL;
+ FragmentRef* preinit_array = NULL;
if (file_format->hasPreInitArray()) {
preinit_array = pLinker.getLayout().getFragmentRef(
*(file_format->getPreInitArray().getSectionData()->begin()),
@@ -194,7 +207,7 @@
ResolveInfo::Hidden);
// .init_array
- MCFragmentRef* init_array = NULL;
+ FragmentRef* init_array = NULL;
if (file_format->hasInitArray()) {
init_array = pLinker.getLayout().getFragmentRef(
*(file_format->getInitArray().getSectionData()->begin()),
@@ -225,7 +238,7 @@
ResolveInfo::Hidden);
// .fini_array
- MCFragmentRef* fini_array = NULL;
+ FragmentRef* fini_array = NULL;
if (file_format->hasFiniArray()) {
fini_array = pLinker.getLayout().getFragmentRef(
*(file_format->getFiniArray().getSectionData()->begin()),
@@ -256,7 +269,7 @@
ResolveInfo::Hidden);
// .stack
- MCFragmentRef* stack = NULL;
+ FragmentRef* stack = NULL;
if (file_format->hasStack()) {
stack = pLinker.getLayout().getFragmentRef(
*(file_format->getStack().getSectionData()->begin()),
@@ -1283,9 +1296,9 @@
assert(NULL != bss_sect && NULL !=tbss_sect);
- // get or create corresponding BSS MCSectionData
- llvm::MCSectionData& bss_sect_data = pLinker.getOrCreateSectData(*bss_sect);
- llvm::MCSectionData& tbss_sect_data = pLinker.getOrCreateSectData(*tbss_sect);
+ // get or create corresponding BSS SectionData
+ SectionData& bss_sect_data = pLinker.getOrCreateSectData(*bss_sect);
+ SectionData& tbss_sect_data = pLinker.getOrCreateSectData(*tbss_sect);
// remember original BSS size
uint64_t bss_offset = bss_sect->size();
@@ -1302,8 +1315,8 @@
// when emitting the regular name pools. We must change the symbols'
// description here.
(*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
- llvm::MCFragment* frag = new llvm::MCFillFragment(0x0, 1, (*com_sym)->size());
- (*com_sym)->setFragmentRef(new MCFragmentRef(*frag, 0));
+ Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
+ (*com_sym)->setFragmentRef(new FragmentRef(*frag, 0));
if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
// allocate TLS common symbol in tbss section
@@ -1328,8 +1341,8 @@
// when emitting the regular name pools. We must change the symbols'
// description here.
(*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
- llvm::MCFragment* frag = new llvm::MCFillFragment(0x0, 1, (*com_sym)->size());
- (*com_sym)->setFragmentRef(new MCFragmentRef(*frag, 0));
+ Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
+ (*com_sym)->setFragmentRef(new FragmentRef(*frag, 0));
if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
// allocate TLS common symbol in tbss section
@@ -1366,33 +1379,38 @@
interp_seg->addSection(&file_format->getInterp());
}
+ // FIXME: Should we consider -z relro here?
if (pInfo.options().hasRelro()) {
// if -z relro is given, we need to adjust sections' offset again, and let
// PT_GNU_RELRO end on a common page boundary
LDContext::SectionTable& sect_table = pOutput.context()->getSectionTable();
- size_t idx = 0;
- while (idx < pOutput.context()->numOfSections()) {
- // find the first non-relro section, and align its offset to a page
- // boundary
+
+ size_t idx;
+ for (idx = 0; idx < pOutput.context()->numOfSections(); ++idx) {
+ // find the first non-relro section
if (getSectionOrder(pOutput, *sect_table[idx], pInfo) > SHO_RELRO_LAST) {
- uint64_t offset = sect_table[idx]->offset();
- alignAddress(offset, commonPageSize(pInfo));
- sect_table[idx]->setOffset(offset);
- ++idx;
break;
}
- ++idx;
}
- while (idx < pOutput.context()->numOfSections()) {
- // adjust the remaining sections' offset
- uint64_t offset = sect_table[idx - 1]->offset();
- if (LDFileFormat::BSS != sect_table[idx - 1]->kind())
- offset += sect_table[idx - 1]->size();
+
+ // align the first non-relro section to page boundary
+ uint64_t offset = sect_table[idx]->offset();
+ alignAddress(offset, commonPageSize(pInfo));
+ sect_table[idx]->setOffset(offset);
+
+ // set up remaining section's offset
+ for (++idx; idx < pOutput.context()->numOfSections(); ++idx) {
+ uint64_t offset;
+ size_t prev_idx = idx - 1;
+ if (LDFileFormat::BSS == sect_table[prev_idx]->kind())
+ offset = sect_table[prev_idx]->offset();
+ else
+ offset = sect_table[prev_idx]->offset() + sect_table[prev_idx]->size();
+
alignAddress(offset, sect_table[idx]->align());
sect_table[idx]->setOffset(offset);
- ++idx;
}
- }
+ } // relro
uint32_t cur_seg_flag, prev_seg_flag = getSegmentFlag(0);
uint64_t padding = 0;
@@ -1411,7 +1429,7 @@
LDFileFormat::Null == (*sect)->kind()) {
// create new PT_LOAD segment
load_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_LOAD);
- load_seg->setAlign(commonPageSize(pInfo));
+ load_seg->setAlign(abiPageSize(pInfo));
// check if this segment needs padding
padding = 0;
@@ -1585,7 +1603,7 @@
}
}
-/// postLayout -Backend can do any needed modification after layout
+/// postLayout - Backend can do any needed modification after layout
void GNULDBackend::postLayout(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker)
diff --git a/lib/Target/GOT.cpp b/lib/Target/GOT.cpp
index a05b574..f9e7b91 100644
--- a/lib/Target/GOT.cpp
+++ b/lib/Target/GOT.cpp
@@ -6,7 +6,9 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#include <mcld/Target/GOT.h>
+
#include <cstring>
#include <cstdlib>
@@ -14,9 +16,9 @@
//===----------------------------------------------------------------------===//
// GOTEntry
-GOTEntry::GOTEntry(uint64_t pContent, size_t pEntrySize,
- llvm::MCSectionData* pParent)
- : MCTargetFragment(llvm::MCFragment::FT_Target, pParent),
+//===----------------------------------------------------------------------===//
+GOTEntry::GOTEntry(uint64_t pContent, size_t pEntrySize, SectionData* pParent)
+ : TargetFragment(Fragment::Target, pParent),
f_Content(pContent), m_EntrySize(pEntrySize) {
}
@@ -26,8 +28,9 @@
//===----------------------------------------------------------------------===//
// GOT
+//===----------------------------------------------------------------------===//
GOT::GOT(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
+ SectionData& pSectionData,
size_t pEntrySize)
: m_Section(pSection),
m_SectionData(pSectionData),
diff --git a/lib/Target/Mips/MipsGOT.cpp b/lib/Target/Mips/MipsGOT.cpp
index 57e5c70..42ef972 100644
--- a/lib/Target/Mips/MipsGOT.cpp
+++ b/lib/Target/Mips/MipsGOT.cpp
@@ -7,10 +7,13 @@
//
//===----------------------------------------------------------------------===//
+#include "MipsGOT.h"
+
+#include <llvm/Support/Casting.h>
+
#include <mcld/LD/ResolveInfo.h>
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MsgHandling.h>
-#include "MipsGOT.h"
namespace {
const size_t MipsGOTEntrySize = 4;
@@ -21,7 +24,7 @@
//===----------------------------------------------------------------------===//
// MipsGOT
-MipsGOT::MipsGOT(LDSection& pSection, llvm::MCSectionData& pSectionData)
+MipsGOT::MipsGOT(LDSection& pSection, SectionData& pSectionData)
: GOT(pSection, pSectionData, MipsGOTEntrySize),
m_pLocalNum(0)
{
@@ -31,7 +34,7 @@
new (std::nothrow) GOTEntry(0, MipsGOTEntrySize, &m_SectionData);
if (NULL == entry)
- fatal(diag::fail_allocate_memory) << "GOT0";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + MipsGOTEntrySize);
}
@@ -94,7 +97,7 @@
new (std::nothrow) GOTEntry(0, MipsGOTEntrySize, &m_SectionData);
if (NULL == entry)
- fatal(diag::fail_allocate_memory) << "GOTEntry";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + MipsGOTEntrySize);
}
diff --git a/lib/Target/Mips/MipsGOT.h b/lib/Target/Mips/MipsGOT.h
index 2f04ef4..23a3ded 100644
--- a/lib/Target/Mips/MipsGOT.h
+++ b/lib/Target/Mips/MipsGOT.h
@@ -12,7 +12,10 @@
#include <gtest.h>
#endif
+#include <llvm/ADT/DenseMap.h>
+
#include <mcld/Target/GOT.h>
+#include <mcld/LD/SectionData.h>
namespace mcld
{
@@ -29,11 +32,11 @@
typedef llvm::DenseMap<const ResolveInfo*, bool> SymbolTypeMapType;
public:
- typedef llvm::MCSectionData::iterator iterator;
- typedef llvm::MCSectionData::const_iterator const_iterator;
+ typedef SectionData::iterator iterator;
+ typedef SectionData::const_iterator const_iterator;
public:
- MipsGOT(LDSection& pSection, llvm::MCSectionData& pSectionData);
+ MipsGOT(LDSection& pSection, SectionData& pSectionData);
iterator begin();
iterator end();
diff --git a/lib/Target/Mips/MipsLDBackend.cpp b/lib/Target/Mips/MipsLDBackend.cpp
index 87e43b8..e8b68ea 100644
--- a/lib/Target/Mips/MipsLDBackend.cpp
+++ b/lib/Target/Mips/MipsLDBackend.cpp
@@ -7,9 +7,15 @@
//
//===----------------------------------------------------------------------===//
+#include "Mips.h"
+#include "MipsELFDynamic.h"
+#include "MipsLDBackend.h"
+#include "MipsRelocationFactory.h"
+
#include <llvm/ADT/Triple.h>
#include <llvm/Support/ELF.h>
+#include <mcld/LD/FillFragment.h>
#include <mcld/LD/SectionMap.h>
#include <mcld/MC/MCLDInfo.h>
#include <mcld/MC/MCLinker.h>
@@ -18,11 +24,6 @@
#include <mcld/Support/TargetRegistry.h>
#include <mcld/Target/OutputRelocSection.h>
-#include "Mips.h"
-#include "MipsELFDynamic.h"
-#include "MipsLDBackend.h"
-#include "MipsRelocationFactory.h"
-
enum {
// The original o32 abi.
E_MIPS_ABI_O32 = 0x00001000,
@@ -67,21 +68,6 @@
void MipsGNULDBackend::initTargetSections(MCLinker& pLinker)
{
- // Set up .dynamic
- ELFFileFormat* file_format = NULL;
- switch(pLinker.getLDInfo().output().type()) {
- case Output::DynObj:
- file_format = getDynObjFileFormat();
- break;
- case Output::Exec:
- file_format = getExecFileFormat();
- break;
- case Output::Object:
- default:
- // TODO: not support yet
- return;
- }
- file_format->getDynamic().setFlag(llvm::ELF::SHF_ALLOC);
}
void MipsGNULDBackend::initTargetSymbols(MCLinker& pLinker, const Output& pOutput)
@@ -213,6 +199,14 @@
return 0x80000;
}
+uint64_t MipsGNULDBackend::abiPageSize(const MCLDInfo& pInfo) const
+{
+ if (pInfo.options().maxPageSize() > 0)
+ return pInfo.options().maxPageSize();
+ else
+ return static_cast<uint64_t>(0x10000);
+}
+
void MipsGNULDBackend::doPreLayout(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker)
@@ -498,7 +492,8 @@
/// finalizeSymbol - finalize the symbol value
bool MipsGNULDBackend::finalizeTargetSymbols(MCLinker& pLinker, const Output& pOutput)
{
- m_pGpDispSymbol->setValue(m_pGOT->getSection().addr() + 0x7FF0);
+ if (NULL != m_pGpDispSymbol)
+ m_pGpDispSymbol->setValue(m_pGOT->getSection().addr() + 0x7FF0);
return true;
}
@@ -550,9 +545,9 @@
assert(NULL != bss_sect && NULL != tbss_sect);
- // get or create corresponding BSS MCSectionData
- llvm::MCSectionData& bss_sect_data = pLinker.getOrCreateSectData(*bss_sect);
- llvm::MCSectionData& tbss_sect_data = pLinker.getOrCreateSectData(*tbss_sect);
+ // get or create corresponding BSS SectionData
+ SectionData& bss_sect_data = pLinker.getOrCreateSectData(*bss_sect);
+ SectionData& tbss_sect_data = pLinker.getOrCreateSectData(*tbss_sect);
// remember original BSS size
uint64_t bss_offset = bss_sect->size();
@@ -569,8 +564,8 @@
// when emitting the regular name pools. We must change the symbols'
// description here.
(*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
- llvm::MCFragment* frag = new llvm::MCFillFragment(0x0, 1, (*com_sym)->size());
- (*com_sym)->setFragmentRef(new MCFragmentRef(*frag, 0));
+ Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
+ (*com_sym)->setFragmentRef(new FragmentRef(*frag, 0));
if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
// allocate TLS common symbol in tbss section
@@ -596,8 +591,8 @@
// when emitting the regular name pools. We must change the symbols'
// description here.
(*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
- llvm::MCFragment* frag = new llvm::MCFillFragment(0x0, 1, (*com_sym)->size());
- (*com_sym)->setFragmentRef(new MCFragmentRef(*frag, 0));
+ Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
+ (*com_sym)->setFragmentRef(new FragmentRef(*frag, 0));
if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
// allocate TLS common symbol in tbss section
@@ -879,9 +874,9 @@
{
ELFFileFormat* file_format = getOutputFormat(pOutput);
- // get .rel.dyn LDSection and create MCSectionData
+ // get .rel.dyn LDSection and create SectionData
LDSection& reldyn = file_format->getRelDyn();
- // create MCSectionData and ARMRelDynSection
+ // create SectionData and ARMRelDynSection
m_pRelDyn = new OutputRelocSection(reldyn,
pLinker.getOrCreateSectData(reldyn),
8);
diff --git a/lib/Target/Mips/MipsLDBackend.h b/lib/Target/Mips/MipsLDBackend.h
index f9742ed..84f2277 100644
--- a/lib/Target/Mips/MipsLDBackend.h
+++ b/lib/Target/Mips/MipsLDBackend.h
@@ -78,6 +78,9 @@
uint64_t defaultTextSegmentAddr() const;
+ /// abiPageSize - the abi page size of the target machine
+ uint64_t abiPageSize(const MCLDInfo& pInfo) const;
+
/// preLayout - Backend can do any needed modification before layout
void doPreLayout(const Output& pOutput,
const MCLDInfo& pInfo,
@@ -101,7 +104,7 @@
/// call back target backend to emit the data.
///
/// Backends handle the target-special tables (plt, gp,...) by themselves.
- /// Backend can put the data of the tables in MCSectionData directly
+ /// Backend can put the data of the tables in SectionData directly
/// - LDSection.getSectionData can get the section data.
/// Or, backend can put the data into special data structure
/// - backend can maintain its own map<LDSection, table> to get the table
diff --git a/lib/Target/Mips/MipsRelocationFactory.cpp b/lib/Target/Mips/MipsRelocationFactory.cpp
index e9d26f8..a9a34b2 100644
--- a/lib/Target/Mips/MipsRelocationFactory.cpp
+++ b/lib/Target/Mips/MipsRelocationFactory.cpp
@@ -131,7 +131,7 @@
got_entry.setContent(pReloc.symValue());
}
else {
- fatal(diag::reserve_entry_number_mismatch) << "GOT";
+ fatal(diag::reserve_entry_number_mismatch_got);
}
}
diff --git a/lib/Target/OutputRelocSection.cpp b/lib/Target/OutputRelocSection.cpp
index dbb8194..c5bb9a8 100644
--- a/lib/Target/OutputRelocSection.cpp
+++ b/lib/Target/OutputRelocSection.cpp
@@ -6,18 +6,21 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include <mcld/LD/LDSection.h>
+
#include <mcld/Target/OutputRelocSection.h>
+
+#include <llvm/Support/Casting.h>
+
+#include <mcld/LD/LDSection.h>
#include <mcld/Support/MsgHandling.h>
using namespace mcld;
-//==========================
+//===----------------------------------------------------------------------===//
// OutputRelocSection
-
-
+//===----------------------------------------------------------------------===//
OutputRelocSection::OutputRelocSection(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
+ SectionData& pSectionData,
unsigned int pEntrySize)
: m_pSection(&pSection),
m_pSectionData(&pSectionData),
diff --git a/lib/Target/PLT.cpp b/lib/Target/PLT.cpp
index a29dfd8..782d974 100644
--- a/lib/Target/PLT.cpp
+++ b/lib/Target/PLT.cpp
@@ -6,16 +6,18 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#include <mcld/Target/PLT.h>
using namespace mcld;
class GOT;
-//===--------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
// PLTEntry
-PLTEntry::PLTEntry(size_t pSize, llvm::MCSectionData* pParent)
- : MCTargetFragment(llvm::MCFragment::FT_Target, pParent),
+//===----------------------------------------------------------------------===//
+PLTEntry::PLTEntry(size_t pSize, SectionData* pParent)
+ : TargetFragment(Fragment::Target, pParent),
m_EntrySize(pSize), m_pContent(NULL)
{
}
@@ -28,9 +30,10 @@
}
}
-//===--------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
// PLT
-PLT::PLT(LDSection& pSection, llvm::MCSectionData& pSectionData)
+//===----------------------------------------------------------------------===//
+PLT::PLT(LDSection& pSection, SectionData& pSectionData)
:m_Section(pSection),
m_SectionData(pSectionData)
{
diff --git a/lib/Target/X86/X86GOT.cpp b/lib/Target/X86/X86GOT.cpp
index 91c7d65..518cc36 100644
--- a/lib/Target/X86/X86GOT.cpp
+++ b/lib/Target/X86/X86GOT.cpp
@@ -7,10 +7,15 @@
//
//===----------------------------------------------------------------------===//
#include "X86GOT.h"
-#include <mcld/LD/LDFileFormat.h>
-#include <mcld/Support/MsgHandling.h>
+
#include <new>
+#include <llvm/Support/Casting.h>
+
+#include <mcld/LD/LDFileFormat.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/Support/MsgHandling.h>
+
namespace {
const size_t X86GOTEntrySize = 4;
}
@@ -19,7 +24,8 @@
//===----------------------------------------------------------------------===//
// X86GOT
-X86GOT::X86GOT(LDSection& pSection, llvm::MCSectionData& pSectionData)
+//===----------------------------------------------------------------------===//
+X86GOT::X86GOT(LDSection& pSection, SectionData& pSectionData)
: GOT(pSection, pSectionData, X86GOTEntrySize),
m_GOTIterator(), m_fIsVisit(false)
{
@@ -38,7 +44,7 @@
&m_SectionData);
if (!Entry)
- fatal(diag::fail_allocate_memory) << "GOTEntry";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + X86GOTEntrySize);
}
diff --git a/lib/Target/X86/X86GOT.h b/lib/Target/X86/X86GOT.h
index d758de0..91cc3e8 100644
--- a/lib/Target/X86/X86GOT.h
+++ b/lib/Target/X86/X86GOT.h
@@ -6,14 +6,16 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef MCLD_X86_GOT_H
-#define MCLD_X86_GOT_H
+#ifndef MCLD_TARGET_X86_GOT_H
+#define MCLD_TARGET_X86_GOT_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
#include "X86PLT.h"
+
#include <mcld/Target/GOT.h>
+#include <mcld/LD/SectionData.h>
namespace mcld
{
@@ -28,11 +30,11 @@
typedef llvm::DenseMap<const ResolveInfo*, GOTEntry*> SymbolIndexMapType;
public:
- typedef llvm::MCSectionData::iterator iterator;
- typedef llvm::MCSectionData::const_iterator const_iterator;
+ typedef SectionData::iterator iterator;
+ typedef SectionData::const_iterator const_iterator;
public:
- X86GOT(LDSection& pSection, llvm::MCSectionData& pSectionData);
+ X86GOT(LDSection& pSection, SectionData& pSectionData);
~X86GOT();
diff --git a/lib/Target/X86/X86GOTPLT.cpp b/lib/Target/X86/X86GOTPLT.cpp
index 2ba5669..49f3449 100644
--- a/lib/Target/X86/X86GOTPLT.cpp
+++ b/lib/Target/X86/X86GOTPLT.cpp
@@ -6,10 +6,15 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#include "X86GOTPLT.h"
+
+#include <new>
+
+#include <llvm/Support/Casting.h>
+
#include <mcld/LD/LDFileFormat.h>
#include <mcld/Support/MsgHandling.h>
-#include <new>
namespace {
const uint64_t X86GOTPLTEntrySize = 4;
@@ -19,7 +24,8 @@
//===----------------------------------------------------------------------===//
// X86GOTPLT
-X86GOTPLT::X86GOTPLT(LDSection& pSection, llvm::MCSectionData& pSectionData)
+//===----------------------------------------------------------------------===//
+X86GOTPLT::X86GOTPLT(LDSection& pSection, SectionData& pSectionData)
: GOT(pSection, pSectionData, X86GOTPLTEntrySize), m_GOTPLTIterator()
{
GOTEntry* Entry = 0;
@@ -30,7 +36,7 @@
&m_SectionData);
if (!Entry)
- fatal(diag::fail_allocate_memory) << "GOT0";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + X86GOTPLTEntrySize);
}
@@ -84,7 +90,7 @@
for (size_t i = 0; i < pNum; ++i) {
got_entry = new GOTEntry(0, getEntrySize(),&(getSectionData()));
if (!got_entry)
- fatal(diag::fail_allocate_memory) << "GOT";
+ fatal(diag::fail_allocate_memory_got);
m_Section.setSize(m_Section.size() + getEntrySize());
}
diff --git a/lib/Target/X86/X86GOTPLT.h b/lib/Target/X86/X86GOTPLT.h
index ae9f0f7..7ca695b 100644
--- a/lib/Target/X86/X86GOTPLT.h
+++ b/lib/Target/X86/X86GOTPLT.h
@@ -12,28 +12,30 @@
#include <gtest.h>
#endif
+#include <llvm/ADT/DenseMap.h>
+
#include <mcld/Target/GOT.h>
+#include <mcld/LD/SectionData.h>
namespace mcld
{
class LDSection;
+const unsigned int X86GOTPLT0Num = 3;
+
/** \class X86GOTPLT
* \brief X86 .got.plt section.
*/
-
-const unsigned int X86GOTPLT0Num = 3;
-
class X86GOTPLT : public GOT
{
typedef llvm::DenseMap<const ResolveInfo*, GOTEntry*> SymbolIndexMapType;
public:
- typedef llvm::MCSectionData::iterator iterator;
- typedef llvm::MCSectionData::const_iterator const_iterator;
+ typedef SectionData::iterator iterator;
+ typedef SectionData::const_iterator const_iterator;
public:
- X86GOTPLT(LDSection &pSection, llvm::MCSectionData& pSectionData);
+ X86GOTPLT(LDSection &pSection, SectionData& pSectionData);
~X86GOTPLT();
diff --git a/lib/Target/X86/X86LDBackend.cpp b/lib/Target/X86/X86LDBackend.cpp
index 2355afc..d02e621 100644
--- a/lib/Target/X86/X86LDBackend.cpp
+++ b/lib/Target/X86/X86LDBackend.cpp
@@ -13,11 +13,14 @@
#include "X86RelocationFactory.h"
#include <llvm/ADT/Triple.h>
+#include <llvm/Support/Casting.h>
+
#include <mcld/LD/SectionMap.h>
+#include <mcld/LD/FillFragment.h>
+#include <mcld/LD/RegionFragment.h>
#include <mcld/MC/MCLDInfo.h>
#include <mcld/MC/MCLDOutput.h>
#include <mcld/MC/MCLinker.h>
-#include <mcld/MC/MCRegionFragment.h>
#include <mcld/Support/MemoryRegion.h>
#include <mcld/Support/MsgHandling.h>
#include <mcld/Support/TargetRegistry.h>
@@ -106,7 +109,7 @@
void X86GNULDBackend::createX86GOT(MCLinker& pLinker, const Output& pOutput)
{
- // get .got LDSection and create MCSectionData
+ // get .got LDSection and create SectionData
ELFFileFormat* file_format = getOutputFormat(pOutput);
LDSection& got = file_format->getGOT();
@@ -115,7 +118,7 @@
void X86GNULDBackend::createX86GOTPLT(MCLinker& pLinker, const Output& pOutput)
{
- // get .got.plt LDSection and create MCSectionData
+ // get .got.plt LDSection and create SectionData
ELFFileFormat* file_format = getOutputFormat(pOutput);
LDSection& gotplt = file_format->getGOTPLT();
@@ -158,12 +161,12 @@
LDSection& plt = file_format->getPLT();
LDSection& relplt = file_format->getRelPlt();
assert(m_pGOTPLT != NULL);
- // create MCSectionData and X86PLT
+ // create SectionData and X86PLT
m_pPLT = new X86PLT(plt, pLinker.getOrCreateSectData(plt), *m_pGOTPLT, pOutput);
// set info of .rel.plt to .plt
relplt.setLink(&plt);
- // create MCSectionData and X86RelDynSection
+ // create SectionData and X86RelDynSection
m_pRelPLT = new OutputRelocSection(relplt,
pLinker.getOrCreateSectData(relplt),
8);
@@ -172,11 +175,11 @@
void X86GNULDBackend::createX86RelDyn(MCLinker& pLinker,
const Output& pOutput)
{
- // get .rel.dyn LDSection and create MCSectionData
+ // get .rel.dyn LDSection and create SectionData
ELFFileFormat* file_format = getOutputFormat(pOutput);
LDSection& reldyn = file_format->getRelDyn();
- // create MCSectionData and X86RelDynSection
+ // create SectionData and X86RelDynSection
m_pRelDyn = new OutputRelocSection(reldyn,
pLinker.getOrCreateSectData(reldyn),
8);
@@ -215,9 +218,9 @@
llvm::ELF::SHF_WRITE | llvm::ELF::SHF_ALLOC);
}
- // get or create corresponding BSS MCSectionData
+ // get or create corresponding BSS SectionData
assert(NULL != bss_sect_hdr);
- llvm::MCSectionData& bss_section = pLinker.getOrCreateSectData(
+ SectionData& bss_section = pLinker.getOrCreateSectData(
*bss_sect_hdr);
// Determine the alignment by the symbol value
@@ -225,7 +228,7 @@
uint32_t addralign = bitclass() / 8;
// allocate space in BSS for the copy symbol
- llvm::MCFragment* frag = new llvm::MCFillFragment(0x0, 1, pSym.size());
+ Fragment* frag = new FillFragment(0x0, 1, pSym.size());
uint64_t size = pLinker.getLayout().appendFragment(*frag,
bss_section,
addralign);
diff --git a/lib/Target/X86/X86PLT.cpp b/lib/Target/X86/X86PLT.cpp
index 2396a21..cbdb568 100644
--- a/lib/Target/X86/X86PLT.cpp
+++ b/lib/Target/X86/X86PLT.cpp
@@ -1,4 +1,4 @@
-//===- X86PLT.cpp -----------------------------------------------------------===//
+//===- X86PLT.cpp ---------------------------------------------------------===//
//
// The MCLinker Project
//
@@ -8,12 +8,18 @@
//===----------------------------------------------------------------------===//
#include "X86GOTPLT.h"
#include "X86PLT.h"
-#include <llvm/Support/raw_ostream.h>
-#include <llvm/Support/ELF.h>
-#include <mcld/MC/MCLDOutput.h>
-#include <mcld/Support/MsgHandling.h>
+
#include <new>
+#include <llvm/Support/ELF.h>
+#include <llvm/Support/Casting.h>
+
+#include <mcld/MC/MCLDOutput.h>
+#include <mcld/Support/MsgHandling.h>
+
+//===----------------------------------------------------------------------===//
+// PLT entry data
+//===----------------------------------------------------------------------===//
namespace {
const uint8_t x86_dyn_plt0[] = {
@@ -44,17 +50,17 @@
namespace mcld {
-X86PLT0::X86PLT0(llvm::MCSectionData* pParent, unsigned int pSize)
+X86PLT0::X86PLT0(SectionData* pParent, unsigned int pSize)
: PLTEntry(pSize, pParent) { }
-X86PLT1::X86PLT1(llvm::MCSectionData* pParent, unsigned int pSize)
+X86PLT1::X86PLT1(SectionData* pParent, unsigned int pSize)
: PLTEntry(pSize, pParent) { }
//===----------------------------------------------------------------------===//
// X86PLT
-
+//===----------------------------------------------------------------------===//
X86PLT::X86PLT(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
+ SectionData& pSectionData,
X86GOTPLT &pGOTPLT,
const Output& pOutput)
: PLT(pSection, pSectionData),
@@ -94,7 +100,7 @@
plt1_entry = new (std::nothrow) X86PLT1(&m_SectionData, m_PLT1Size);
if (!plt1_entry)
- fatal(diag::fail_allocate_memory) << "X86PLT1";
+ fatal(diag::fail_allocate_memory_plt);
m_Section.setSize(m_Section.size() + plt1_entry->getEntrySize());
@@ -152,7 +158,7 @@
data = static_cast<unsigned char*>(malloc(plt0->getEntrySize()));
if (!data)
- fatal(diag::fail_allocate_memory) << "plt0";
+ fatal(diag::fail_allocate_memory_plt);
memcpy(data, m_PLT0, plt0->getEntrySize());
@@ -200,7 +206,7 @@
data = static_cast<unsigned char*>(malloc(plt1->getEntrySize()));
if (!data)
- fatal(diag::fail_allocate_memory) << "plt1";
+ fatal(diag::fail_allocate_memory_plt);
memcpy(data, m_PLT1, plt1->getEntrySize());
diff --git a/lib/Target/X86/X86PLT.h b/lib/Target/X86/X86PLT.h
index 6c7002a..1669a49 100644
--- a/lib/Target/X86/X86PLT.h
+++ b/lib/Target/X86/X86PLT.h
@@ -1,4 +1,4 @@
-//===- X86PLT.h -----------------------------------------------------===//
+//===- X86PLT.h -----------------------------------------------------------===//
//
// The MCLinker Project
//
@@ -6,10 +6,13 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#ifndef X86_PLT_H
-#define X86_PLT_H
+#ifndef MCLD_TARGET_X86_PLT_H
+#define MCLD_TARGET_X86_PLT_H
+
+#include <llvm/ADT/DenseMap.h>
#include <mcld/Target/PLT.h>
+#include <mcld/LD/SectionData.h>
namespace mcld {
@@ -17,14 +20,16 @@
class GOTEntry;
class Output;
-class X86PLT0 : public PLTEntry {
+class X86PLT0 : public PLTEntry
+{
public:
- X86PLT0(llvm::MCSectionData* pParent, unsigned int pSize);
+ X86PLT0(SectionData* pParent, unsigned int pSize);
};
-class X86PLT1 : public PLTEntry {
+class X86PLT1 : public PLTEntry
+{
public:
- X86PLT1(llvm::MCSectionData* pParent, unsigned int pSize);
+ X86PLT1(SectionData* pParent, unsigned int pSize);
};
/** \class X86PLT
@@ -35,12 +40,12 @@
typedef llvm::DenseMap<const ResolveInfo*, X86PLT1*> SymbolIndexType;
public:
- typedef llvm::MCSectionData::iterator iterator;
- typedef llvm::MCSectionData::const_iterator const_iterator;
+ typedef SectionData::iterator iterator;
+ typedef SectionData::const_iterator const_iterator;
public:
X86PLT(LDSection& pSection,
- llvm::MCSectionData& pSectionData,
+ SectionData& pSectionData,
X86GOTPLT& pGOTPLT,
const Output& pOutput);
~X86PLT();
diff --git a/lib/Target/X86/X86RelocationFactory.cpp b/lib/Target/X86/X86RelocationFactory.cpp
index 71fa344..f603b6e 100644
--- a/lib/Target/X86/X86RelocationFactory.cpp
+++ b/lib/Target/X86/X86RelocationFactory.cpp
@@ -132,7 +132,7 @@
rel_entry.targetRef().assign(got_entry);
}
else {
- fatal(diag::reserve_entry_number_mismatch) << "GOT";
+ fatal(diag::reserve_entry_number_mismatch_got);
}
}
return got_entry;
@@ -182,7 +182,7 @@
rel_entry.setSymInfo(rsym);
}
else {
- fatal(diag::reserve_entry_number_mismatch) << "PLT";
+ fatal(diag::reserve_entry_number_mismatch_plt);
}
}
return plt_entry;
diff --git a/lib/Target/X86/X86SectLinker.cpp b/lib/Target/X86/X86SectLinker.cpp
index a888f47..2954d1f 100644
--- a/lib/Target/X86/X86SectLinker.cpp
+++ b/lib/Target/X86/X86SectLinker.cpp
@@ -47,3 +47,4 @@
// Register the linker frontend
mcld::TargetRegistry::RegisterSectLinker(TheX86Target, createX86SectLinker);
}
+
diff --git a/tools/llvm-mcld/llvm-mcld.cpp b/tools/llvm-mcld/llvm-mcld.cpp
index 726e08e..f4201d2 100644
--- a/tools/llvm-mcld/llvm-mcld.cpp
+++ b/tools/llvm-mcld/llvm-mcld.cpp
@@ -113,11 +113,6 @@
cl::init(false));
static cl::opt<bool>
-PrintCode("print-machineinstrs",
- cl::desc("Print generated machine code"),
- cl::init(false));
-
-static cl::opt<bool>
DisableFPElim("disable-fp-elim",
cl::desc("Disable frame pointer elimination optimization"),
cl::init(false));
@@ -127,10 +122,18 @@
cl::desc("Disable frame pointer elimination optimization for non-leaf funcs"),
cl::init(false));
-static cl::opt<bool>
-DisableExcessPrecision("disable-excess-fp-precision",
- cl::desc("Disable optimizations that may increase FP precision"),
- cl::init(false));
+static cl::opt<llvm::FPOpFusion::FPOpFusionMode>
+FuseFPOps("fuse-fp-ops",
+ cl::desc("Enable aggresive formation of fused FP ops"),
+ cl::init(FPOpFusion::Standard),
+ cl::values(
+ clEnumValN(FPOpFusion::Fast, "fast",
+ "Fuse FP ops whenever profitable"),
+ clEnumValN(FPOpFusion::Standard, "standard",
+ "Only fuse 'blessed' FP ops."),
+ clEnumValN(FPOpFusion::Strict, "strict",
+ "Only fuse FP ops when the result won't be effected."),
+ clEnumValEnd));
static cl::opt<bool>
EnableUnsafeFPMath("enable-unsafe-fp-math",
@@ -214,11 +217,6 @@
cl::desc("Realign stack if needed"),
cl::init(true));
-static cl::opt<bool>
-DisableSwitchTables(cl::Hidden, "disable-jump-tables",
- cl::desc("Do not generate jump tables."),
- cl::init(false));
-
static cl::opt<std::string>
TrapFuncName("trap-func", cl::Hidden,
cl::desc("Emit a call to trap function rather than a trap instruction"),
@@ -1041,10 +1039,9 @@
TargetOptions Options;
Options.LessPreciseFPMADOption = EnableFPMAD;
- Options.PrintMachineCode = PrintCode;
Options.NoFramePointerElim = DisableFPElim;
Options.NoFramePointerElimNonLeaf = DisableFPElimNonLeaf;
- Options.NoExcessFPPrecision = DisableExcessPrecision;
+ Options.AllowFPOpFusion = FuseFPOps;
Options.UnsafeFPMath = EnableUnsafeFPMath;
Options.NoInfsFPMath = EnableNoInfsFPMath;
Options.NoNaNsFPMath = EnableNoNaNsFPMath;
@@ -1060,7 +1057,6 @@
Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
Options.StackAlignmentOverride = OverrideStackAlignment;
Options.RealignStack = EnableRealignStack;
- Options.DisableJumpTables = DisableSwitchTables;
Options.TrapFuncName = TrapFuncName;
Options.EnableSegmentedStacks = SegmentedStacks;
diff --git a/tools/mcld/include/alone/Config/Config.h.in b/tools/mcld/include/alone/Config/Config.h.in
index edb8721..6618b08 100644
--- a/tools/mcld/include/alone/Config/Config.h.in
+++ b/tools/mcld/include/alone/Config/Config.h.in
@@ -1,8 +1,15 @@
#ifndef ALONE_CONFIG_CONFIG_H
#define ALONE_CONFIG_CONFIG_H
-#define PROVIDE_@PROVIDE_ALONE_TARGET@_CODEGEN
-#define DEFAULT_@DEFAULT_ALONE_TARGET@_CODEGEN
+#if defined(TARGET_BUILD)
+ #define PROVIDE_@PROVIDE_ALONE_TARGET@_CODEGEN
+ #define DEFAULT_@DEFAULT_ALONE_TARGET@_CODEGEN
+#else
+ #define PROVIDE_ARM_CODEGEN
+ #define PROVIDE_X86_CODEGEN
+ #define PROVIDE_MIPS_CODEGEN
+ #define DEFAULT_@DEFAULT_ALONE_TARGET@_CODEGEN
+#endif
#define DEFAULT_ARM_TRIPLE_STRING "armv7-none-linux-gnueabi"
#define DEFAULT_X86_TRIPLE_STRING "i686-unknown-linux"
diff --git a/tools/mcld/include/alone/Support/LinkerConfig.h b/tools/mcld/include/alone/Support/LinkerConfig.h
index 37689d2..f29e557 100644
--- a/tools/mcld/include/alone/Support/LinkerConfig.h
+++ b/tools/mcld/include/alone/Support/LinkerConfig.h
@@ -6,13 +6,13 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#ifndef ALONE_SUPPORT_LINKER_CONFIG_H
#define ALONE_SUPPORT_LINKER_CONFIG_H
#include <string>
#include <mcld/MC/MCLDInfo.h>
-#include <mcld/MC/MCLDFile.h>
#include <mcld/Support/TargetRegistry.h>
#include <mcld/LD/DiagnosticLineInfo.h>
#include <mcld/LD/DiagnosticPrinter.h>
@@ -21,15 +21,17 @@
class LinkerConfig {
private:
- //===----------------------------------------------------------------------===//
+ //===--------------------------------------------------------------------===//
// Available Configurations
- //===----------------------------------------------------------------------===//
- std::string mTriple;
+ //===--------------------------------------------------------------------===//
+ const std::string mTriple;
+ bool mShared;
+ std::string mSOName;
private:
- //===----------------------------------------------------------------------===//
+ //===--------------------------------------------------------------------===//
// These are generated by LinkerConfig during initialize().
- //===----------------------------------------------------------------------===//
+ //===--------------------------------------------------------------------===//
const mcld::Target *mTarget;
bool initializeTarget();
@@ -39,10 +41,11 @@
mcld::DiagnosticLineInfo *mDiagLineInfo;
mcld::DiagnosticPrinter *mDiagPrinter;
bool initializeDiagnostic();
+
public:
- //===----------------------------------------------------------------------===//
+ //===--------------------------------------------------------------------===//
// Getters
- //===----------------------------------------------------------------------===//
+ //===--------------------------------------------------------------------===//
inline const std::string &getTriple() const
{ return mTriple; }
@@ -55,16 +58,26 @@
inline const mcld::MCLDInfo* getLDInfo() const
{ return mLDInfo; }
- inline void setSOName(const std::string &pSOName)
- { mLDInfo->output().setSOName(pSOName); }
+ inline bool isShared() const
+ { return mShared; }
- inline void setDyld(const std::string &pDyld)
- { mLDInfo->options().setDyld(pDyld); }
+ inline std::string getSOName() const
+ { return mSOName; }
+
+ void setShared(bool pEnable = true);
+
+ void setBsymbolic(bool pEnable = true);
+
+ void setSOName(const std::string &pSOName);
+
+ void setDyld(const std::string &pDyld);
void setSysRoot(const std::string &pSysRoot);
void addWrap(const std::string &pWrapSymbol);
+ void addPortable(const std::string &pPortableSymbol);
+
void addSearchDir(const std::string &pDir);
public:
diff --git a/tools/mcld/include/alone/Support/Log.h b/tools/mcld/include/alone/Support/Log.h
new file mode 100644
index 0000000..bc91d44
--- /dev/null
+++ b/tools/mcld/include/alone/Support/Log.h
@@ -0,0 +1,18 @@
+//===- Log.h --------------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ALONE_SUPPORT_LOG_H
+#define ALONE_SUPPORT_LOG_H
+
+#include <cstdio>
+
+#define ALOGE(fmt, args...) \
+printf("%s:%s:%d: "fmt, __FILE__, __FUNCTION__, __LINE__, args)
+
+#endif // ALONE_SUPPORT_LOG_H
diff --git a/tools/mcld/include/alone/Support/MemoryFactory.h b/tools/mcld/include/alone/Support/MemoryFactory.h
index 2247d2c..132d20f 100644
--- a/tools/mcld/include/alone/Support/MemoryFactory.h
+++ b/tools/mcld/include/alone/Support/MemoryFactory.h
@@ -19,10 +19,9 @@
namespace alone {
-class MemoryFactory : public mcld::MemoryAreaFactory
-{
+class MemoryFactory : public mcld::MemoryAreaFactory {
public:
- MemoryFactory();
+ MemoryFactory() : mcld::MemoryAreaFactory(32) { }
~MemoryFactory() { }
diff --git a/tools/mcld/include/alone/Support/TargetLinkerConfigs.h b/tools/mcld/include/alone/Support/TargetLinkerConfigs.h
index 229a9bd..40bc812 100644
--- a/tools/mcld/include/alone/Support/TargetLinkerConfigs.h
+++ b/tools/mcld/include/alone/Support/TargetLinkerConfigs.h
@@ -6,6 +6,7 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#ifndef ALONE_SUPPORT_TARGET_LINKER_CONFIGS_H
#define ALONE_SUPPORT_TARGET_LINKER_CONFIGS_H
diff --git a/tools/mcld/lib/Core/Linker.cpp b/tools/mcld/lib/Core/Linker.cpp
index 9ab21cc..a9ebc1f 100644
--- a/tools/mcld/lib/Core/Linker.cpp
+++ b/tools/mcld/lib/Core/Linker.cpp
@@ -95,6 +95,7 @@
delete mDriver;
delete mBackend;
delete mMemAreaFactory;
+ delete mRoot;
}
enum Linker::ErrorCode Linker::extractFiles(const LinkerConfig& pConfig) {
@@ -103,7 +104,7 @@
return kDelegateLDInfo;
}
- mRoot = &mLDInfo->inputs().root();
+ mRoot = new mcld::InputTree::iterator(mLDInfo->inputs().root());
mShared = pConfig.isShared();
mSOName = pConfig.getSOName();
@@ -122,10 +123,10 @@
return kCreateBackend;
}
- mDriver = new mcld::MCLDDriver(*mLDInfo, *mBackend);
-
mMemAreaFactory = new MemoryFactory();
+ mDriver = new mcld::MCLDDriver(*mLDInfo, *mBackend, *mMemAreaFactory);
+
mDriver->initMCLinker();
return kSuccess;
@@ -354,14 +355,10 @@
enum Linker::ErrorCode Linker::link() {
mDriver->normalize();
- if (!mDriver->readSections() || !mDriver->mergeSections()) {
+ if (!mDriver->mergeSections()) {
return kReadSections;
}
- if (!mDriver->readSymbolTables()) {
- return kReadSymbols;
- }
-
if (!mDriver->addStandardSymbols() || !mDriver->addTargetSymbols()) {
return kAddAdditionalSymbols;
}
diff --git a/tools/mcld/lib/Support/Initialization.cpp b/tools/mcld/lib/Support/Initialization.cpp
index 83803f7..9a95f74 100644
--- a/tools/mcld/lib/Support/Initialization.cpp
+++ b/tools/mcld/lib/Support/Initialization.cpp
@@ -7,22 +7,22 @@
//
//===----------------------------------------------------------------------===//
-#include <cstdio>
-#include <cstdlib>
-#include <string>
-
-#include "alone/Config/Config.h"
#include "alone/Support/Initialization.h"
+#include <cstdlib>
+
+#include <llvm/Support/ErrorHandling.h>
+#include <llvm/Support/TargetSelect.h>
+
#include <mcld/Support/TargetSelect.h>
#include <mcld/Support/TargetRegistry.h>
-#include <llvm/Support/TargetSelect.h>
-#include <llvm/Support/ErrorHandling.h>
+#include "alone/Config/Config.h"
+#include "alone/Support/Log.h"
namespace {
-void llvm_error_handler(void *pUserData, const std::string& pMessage) {
+void llvm_error_handler(void *pUserData, const std::string &pMessage) {
ALOGE("%s", pMessage.c_str());
::exit(1);
}
@@ -31,6 +31,7 @@
void alone::init::Initialize() {
static bool is_initialized = false;
+
if (is_initialized) {
return;
}
@@ -41,6 +42,9 @@
#if defined(PROVIDE_ARM_CODEGEN)
LLVMInitializeARMAsmPrinter();
+# if USE_DISASSEMBLER
+ LLVMInitializeARMDisassembler();
+# endif
LLVMInitializeARMTargetMC();
LLVMInitializeARMTargetInfo();
LLVMInitializeARMTarget();
@@ -52,6 +56,9 @@
#if defined(PROVIDE_MIPS_CODEGEN)
LLVMInitializeMipsAsmPrinter();
+# if USE_DISASSEMBLER
+ LLVMInitializeMipsDisassembler();
+# endif
LLVMInitializeMipsTargetMC();
LLVMInitializeMipsTargetInfo();
LLVMInitializeMipsTarget();
@@ -63,6 +70,9 @@
#if defined(PROVIDE_X86_CODEGEN)
LLVMInitializeX86AsmPrinter();
+# if USE_DISASSEMBLER
+ LLVMInitializeX86Disassembler();
+# endif
LLVMInitializeX86TargetMC();
LLVMInitializeX86TargetInfo();
LLVMInitializeX86Target();
@@ -76,4 +86,3 @@
return;
}
-
diff --git a/tools/mcld/lib/Support/LinkerConfig.cpp b/tools/mcld/lib/Support/LinkerConfig.cpp
index 30506a8..ea30e69 100644
--- a/tools/mcld/lib/Support/LinkerConfig.cpp
+++ b/tools/mcld/lib/Support/LinkerConfig.cpp
@@ -91,7 +91,7 @@
}
void LinkerConfig::setSOName(const std::string &pSOName) {
- mLDInfo->output().setSOName(pSOName);
+ mSOName = pSOName;
return;
}
diff --git a/tools/mcld/lib/Support/MemoryFactory.cpp b/tools/mcld/lib/Support/MemoryFactory.cpp
deleted file mode 100644
index 0d368dc..0000000
--- a/tools/mcld/lib/Support/MemoryFactory.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===- MemoryFactory.cpp --------------------------------------------------===//
-//
-// The MCLinker Project
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "alone/Support/MemoryFactory.h"
-
-using namespace alone;
-
-MemoryFactory::MemoryFactory()
- : mcld::MemoryAreaFactory(32) {
-}
-
diff --git a/tools/mcld/lib/Support/TargetLinkerConfigs.cpp b/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
index 8854f79..f2ddd6f 100644
--- a/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
+++ b/tools/mcld/lib/Support/TargetLinkerConfigs.cpp
@@ -24,8 +24,7 @@
// ARM
//===----------------------------------------------------------------------===//
#if defined(PROVIDE_ARM_CODEGEN)
-ARMLinkerConfig::ARMLinkerConfig()
- : LinkerConfig(DEFAULT_ARM_TRIPLE_STRING) {
+ARMLinkerConfig::ARMLinkerConfig() : LinkerConfig(DEFAULT_ARM_TRIPLE_STRING) {
// set up target-dependent constraints of attributes
getLDInfo()->attrFactory().constraint().enableWholeArchive();
@@ -37,17 +36,13 @@
getLDInfo()->attrFactory().predefined().setDynamic();
// set up target dependent options
- if (getLDInfo()->options().sysroot().empty())
+ if (getLDInfo()->options().sysroot().empty()) {
getLDInfo()->options().setSysroot(gDefaultSysroot);
+ }
- if (!getLDInfo()->options().hasDyld())
+ if (!getLDInfo()->options().hasDyld()) {
getLDInfo()->options().setDyld(gDefaultDyld);
-
- // set up default search path
- addSearchDir("=/lib");
- addSearchDir("=/usr/lib");
-
- return;
+ }
}
#endif // defined(PROVIDE_ARM_CODEGEN)
@@ -68,17 +63,13 @@
getLDInfo()->attrFactory().predefined().setDynamic();
// set up target dependent options
- if (getLDInfo()->options().sysroot().empty())
+ if (getLDInfo()->options().sysroot().empty()) {
getLDInfo()->options().setSysroot(gDefaultSysroot);
+ }
- if (!getLDInfo()->options().hasDyld())
+ if (!getLDInfo()->options().hasDyld()) {
getLDInfo()->options().setDyld(gDefaultDyld);
-
- // set up default search path
- addSearchDir("=/lib");
- addSearchDir("=/usr/lib");
-
- return;
+ }
}
#endif // defined(PROVIDE_MIPS_CODEGEN)
@@ -98,17 +89,13 @@
getLDInfo()->attrFactory().predefined().setDynamic();
// set up target dependent options
- if (getLDInfo()->options().sysroot().empty())
+ if (getLDInfo()->options().sysroot().empty()) {
getLDInfo()->options().setSysroot(gDefaultSysroot);
+ }
- if (!getLDInfo()->options().hasDyld())
+ if (!getLDInfo()->options().hasDyld()) {
getLDInfo()->options().setDyld(gDefaultDyld);
-
- // set up default search path
- addSearchDir("=/lib");
- addSearchDir("=/usr/lib");
-
- return;
+ }
}
X86_32LinkerConfig::X86_32LinkerConfig()
diff --git a/tools/mcld/main.cpp b/tools/mcld/main.cpp
index 37610b8..ef525f5 100644
--- a/tools/mcld/main.cpp
+++ b/tools/mcld/main.cpp
@@ -6,6 +6,7 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
+
#include <stdlib.h>
#include <string>
@@ -16,6 +17,8 @@
#include <llvm/Support/raw_ostream.h>
#include <llvm/Support/system_error.h>
+#include <mcld/Config/Config.h>
+
#include <alone/Config/Config.h>
#include <alone/Support/LinkerConfig.h>
#include <alone/Support/Initialization.h>
@@ -28,18 +31,18 @@
// Compiler Options
//===----------------------------------------------------------------------===//
#ifdef TARGET_BUILD
-const std::string OptTargetTripe(DEFAULT_TARGET_TRIPLE_STRING);
+static const std::string OptTargetTripe(DEFAULT_TARGET_TRIPLE_STRING);
#else
-llvm::cl::opt<std::string>
+static llvm::cl::opt<std::string>
OptTargetTriple("mtriple",
- llvm::cl::desc("Specify the target triple (default: "
- DEFAULT_TARGET_TRIPLE_STRING ")"),
- llvm::cl::init(DEFAULT_TARGET_TRIPLE_STRING),
- llvm::cl::value_desc("triple"));
+ llvm::cl::desc("Specify the target triple (default: "
+ DEFAULT_TARGET_TRIPLE_STRING ")"),
+ llvm::cl::init(DEFAULT_TARGET_TRIPLE_STRING),
+ llvm::cl::value_desc("triple"));
-llvm::cl::alias OptTargetTripleC("C", llvm::cl::NotHidden,
- llvm::cl::desc("Alias for -mtriple"),
- llvm::cl::aliasopt(OptTargetTriple));
+static llvm::cl::alias OptTargetTripleC("C", llvm::cl::NotHidden,
+ llvm::cl::desc("Alias for -mtriple"),
+ llvm::cl::aliasopt(OptTargetTriple));
#endif
//===----------------------------------------------------------------------===//
@@ -58,17 +61,18 @@
llvm::cl::value_desc("filename"));
static llvm::cl::opt<std::string>
-OptSysRoot("sysroot",
- llvm::cl::desc("Use directory as the location of the sysroot, overriding "
- "the configure-time default."),
+OptSysRoot("sysroot", llvm::cl::desc("Use directory as the location of the "
+ "sysroot, overriding the configure-time "
+ "default."),
llvm::cl::value_desc("directory"),
llvm::cl::ValueRequired);
static llvm::cl::list<std::string>
OptSearchDirList("L",
llvm::cl::ZeroOrMore,
- llvm::cl::desc("Add path searchdir to the list of paths that ld will "
- "search for archive libraries and ld control scripts."),
+ llvm::cl::desc("Add path searchdir to the list of paths that "
+ "mcld will search for archive libraries and "
+ "mcld control scripts."),
llvm::cl::value_desc("searchdir"),
llvm::cl::Prefix);
@@ -83,6 +87,11 @@
llvm::cl::desc("Create a shared library."),
llvm::cl::init(false));
+static llvm::cl::opt<bool>
+OptBsymbolic("Bsymbolic",
+ llvm::cl::desc("Bind references within the shared library."),
+ llvm::cl::init(true));
+
static llvm::cl::opt<std::string>
OptDyld("dynamic-linker",
llvm::cl::desc("Set the name of the dynamic linker."),
@@ -94,7 +103,7 @@
static llvm::cl::list<std::string>
OptInputObjectFiles(llvm::cl::Positional,
llvm::cl::desc("[input object files]"),
- llvm::cl::ZeroOrMore);
+ llvm::cl::OneOrMore);
static llvm::cl::list<std::string>
OptNameSpecList("l",
@@ -113,25 +122,32 @@
llvm::cl::desc("Use a wrap function fo symbol."),
llvm::cl::value_desc("symbol"));
+static llvm::cl::list<std::string>
+OptPortableList("portable",
+ llvm::cl::ZeroOrMore,
+ llvm::cl::desc("Use a portable function to symbol."),
+ llvm::cl::value_desc("symbol"));
+
//===----------------------------------------------------------------------===//
// Helper Functions
//===----------------------------------------------------------------------===//
// Override "mcld -version"
-void MCLDVersionPrinter() {
+static void MCLDVersionPrinter() {
llvm::raw_ostream &os = llvm::outs();
os << "mcld (The MCLinker Project, http://mclinker.googlecode.com/):\n"
+ << " version: "MCLD_VERSION"\n"
<< " Default target: " << DEFAULT_TARGET_TRIPLE_STRING << "\n";
os << "\n";
os << "LLVM (http://llvm.org/):\n";
+
return;
}
#define DEFAULT_OUTPUT_PATH "a.out"
static inline
-std::string DetermineOutputFilename(const std::string pOutputPath)
-{
+std::string DetermineOutputFilename(const std::string &pOutputPath) {
if (!pOutputPath.empty()) {
return pOutputPath;
}
@@ -160,8 +176,7 @@
}
static inline
-bool ConfigLinker(Linker &pLinker, const std::string &pOutputFilename)
-{
+bool ConfigLinker(Linker &pLinker, const std::string &pOutputFilename) {
LinkerConfig* config = NULL;
#ifdef TARGET_BUILD
@@ -174,36 +189,57 @@
return false;
}
- // Setup the configuration accroding to the value of command line options.
- // 1. set up soname
- if (!OptSOName.empty())
+ // Setup the configuration accroding to the command line options.
+
+ // 1. Set up soname.
+ if (!OptSOName.empty()) {
config->setSOName(OptSOName);
- else
+ } else {
config->setSOName(pOutputFilename);
+ }
- // 2. if given, set up sysroot
- if (!OptSysRoot.empty())
+ // 2. If given, set up sysroot.
+ if (!OptSysRoot.empty()) {
config->setSysRoot(OptSysRoot);
+ }
- // 3. if given, set up dynamic linker path.
- if (!OptDyld.empty())
+ // 3. If given, set up dynamic linker path.
+ if (!OptDyld.empty()) {
config->setDyld(OptDyld);
+ }
- // 4. if given, set up wrapped symbols
- llvm::cl::list<std::string>::iterator wrap, wEnd = OptWrapList.end();
- for (wrap = OptWrapList.begin(); wrap != wEnd; ++wrap)
+ // 4. If given, set up wrapped symbols.
+ llvm::cl::list<std::string>::iterator wrap, wrap_end = OptWrapList.end();
+ for (wrap = OptWrapList.begin(); wrap != wrap_end; ++wrap) {
config->addWrap(*wrap);
+ }
- // 5. if given, set up search directories
- llvm::cl::list<std::string>::iterator sdir, sdirEnd = OptSearchDirList.end();
- for (sdir = OptSearchDirList.begin(); sdir != sdirEnd; ++sdir)
+ // 5. If given, set up portable symbols.
+ llvm::cl::list<std::string>::iterator portable, portable_end = OptPortableList.end();
+ for (portable = OptPortableList.begin(); portable != portable_end; ++portable) {
+ config->addPortable(*portable);
+ }
+
+ // 6. if given, set up search directories.
+ llvm::cl::list<std::string>::iterator sdir, sdir_end = OptSearchDirList.end();
+ for (sdir = OptSearchDirList.begin(); sdir != sdir_end; ++sdir) {
config->addSearchDir(*sdir);
+ }
+
+ // set up default search directories
+ config->addSearchDir("=/lib");
+ config->addSearchDir("=/usr/lib");
+
+ // 7. Set up output's type.
+ config->setShared(OptShared);
+
+ // 8. Set up -Bsymbolic.
+ config->setBsymbolic(OptBsymbolic);
Linker::ErrorCode result = pLinker.config(*config);
-
if (Linker::kSuccess != result) {
llvm::errs() << "Failed to configure the linker! (detail: "
- << Linker::GetErrorString(result) << ")\n";
+ << Linker::GetErrorString(result) << ")\n";
return false;
}
@@ -211,11 +247,11 @@
}
static inline
-bool PrepareInputOutput(Linker& pLinker, const std::string &pOutputPath)
-{
- // ----- set output ----- //
- // FIXME: In MCLinker, we have to set up output before setting up inputs.
- // This constraint is wired, and we should break this constraint.
+bool PrepareInputOutput(Linker &pLinker, const std::string &pOutputPath) {
+ // ----- Set output ----- //
+
+ // FIXME: Current MCLinker requires one to set up output before inputs. The
+ // constraint will be relaxed in the furture.
Linker::ErrorCode result = pLinker.setOutput(pOutputPath);
if (Linker::kSuccess != result) {
@@ -225,57 +261,54 @@
return false;
}
- // ----- set inputs ----- //
- llvm::cl::list<std::string>::iterator fileIt = OptInputObjectFiles.begin();
- llvm::cl::list<std::string>::iterator libIt = OptNameSpecList.begin();
+ // ----- Set inputs ----- //
+ llvm::cl::list<std::string>::iterator file_it = OptInputObjectFiles.begin();
+ llvm::cl::list<std::string>::iterator lib_it = OptNameSpecList.begin();
- llvm::cl::list<std::string>::iterator fileBegin = OptInputObjectFiles.begin();
- llvm::cl::list<std::string>::iterator libBegin = OptNameSpecList.begin();
- llvm::cl::list<std::string>::iterator fileEnd = OptInputObjectFiles.end();
- llvm::cl::list<std::string>::iterator libEnd = OptNameSpecList.end();
+ llvm::cl::list<std::string>::iterator file_begin = OptInputObjectFiles.begin();
+ llvm::cl::list<std::string>::iterator lib_begin = OptNameSpecList.begin();
+ llvm::cl::list<std::string>::iterator file_end = OptInputObjectFiles.end();
+ llvm::cl::list<std::string>::iterator lib_end = OptNameSpecList.end();
- unsigned libPos = 0, filePos = 0;
+ unsigned lib_pos = 0, file_pos = 0;
while (true) {
- if (libIt != libEnd)
- libPos = OptNameSpecList.getPosition(libIt - libBegin);
- else
- libPos = 0;
-
- if (fileIt != fileEnd)
- filePos = OptInputObjectFiles.getPosition(fileIt - fileBegin);
- else
- filePos = 0;
-
- if ( filePos != 0 && (libPos == 0 || filePos < libPos) ) {
- result = pLinker.addObject(*fileIt);
- if (Linker::kSuccess != result) {
- llvm::errs() << "Failed to open the input file! (detail: "
- << *fileIt << ": "
- << Linker::GetErrorString(result) << ")\n";
- return false;
- }
- ++fileIt;
- }
- else if ( libPos != 0 && (filePos == 0 || libPos < filePos) ) {
- result = pLinker.addNameSpec(*libIt);
- if (Linker::kSuccess != result) {
- llvm::errs() << "Failed to open the namespec! (detail: "
- << *libIt << ": "
- << Linker::GetErrorString(result) << ")\n";
- return false;
- }
- ++libIt;
+ if (lib_it != lib_end) {
+ lib_pos = OptNameSpecList.getPosition(lib_it - lib_begin);
+ } else {
+ lib_pos = 0;
}
- else
+ if (file_it != file_end) {
+ file_pos = OptInputObjectFiles.getPosition(file_it - file_begin);
+ } else {
+ file_pos = 0;
+ }
+
+ if ((file_pos != 0) && ((lib_pos == 0) || (file_pos < lib_pos))) {
+ result = pLinker.addObject(*file_it);
+ if (Linker::kSuccess != result) {
+ llvm::errs() << "Failed to open the input file! (detail: " << *file_it
+ << ": " << Linker::GetErrorString(result) << ")\n";
+ return false;
+ }
+ ++file_it;
+ } else if ((lib_pos != 0) && ((file_pos == 0) || (lib_pos < file_pos))) {
+ result = pLinker.addNameSpec(*lib_it);
+ if (Linker::kSuccess != result) {
+ llvm::errs() << "Failed to open the namespec! (detail: " << *lib_it
+ << ": " << Linker::GetErrorString(result) << ")\n";
+ return false;
+ }
+ ++lib_it;
+ } else {
break; // we're done with the list
+ }
}
return true;
}
-static inline
-bool LinkFiles(Linker& pLinker) {
+static inline bool LinkFiles(Linker &pLinker) {
Linker::ErrorCode result = pLinker.link();
if (Linker::kSuccess != result) {
llvm::errs() << "Failed to linking! (detail: "
@@ -285,8 +318,7 @@
return true;
}
-int main(int argc, char* argv[])
-{
+int main(int argc, char** argv) {
llvm::cl::SetVersionPrinter(MCLDVersionPrinter);
llvm::cl::ParseCommandLineOptions(argc, argv);
init::Initialize();
@@ -308,6 +340,7 @@
if (!LinkFiles(linker)) {
return EXIT_FAILURE;
}
+
return EXIT_SUCCESS;
}
diff --git a/unittests/MCFragmentRefTest.cpp b/unittests/FragmentRefTest.cpp
similarity index 60%
rename from unittests/MCFragmentRefTest.cpp
rename to unittests/FragmentRefTest.cpp
index 3da3463..d64d52b 100644
--- a/unittests/MCFragmentRefTest.cpp
+++ b/unittests/FragmentRefTest.cpp
@@ -1,4 +1,4 @@
-//===- MCFragmentRefTest --------------------------------------------------===//
+//===- FragmentRefTest ----------------------------------------------------===//
//
// The MCLinker Project
//
@@ -6,12 +6,13 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-#include "mcld/MC/MCFragmentRef.h"
-#include "mcld/MC/MCRegionFragment.h"
-#include "mcld/Support/MemoryAreaFactory.h"
-#include "mcld/Support/FileHandle.h"
-#include "mcld/Support/Path.h"
-#include "MCFragmentRefTest.h"
+#include "FragmentRefTest.h"
+
+#include <mcld/LD/FragmentRef.h>
+#include <mcld/LD/RegionFragment.h>
+#include <mcld/Support/MemoryAreaFactory.h>
+#include <mcld/Support/FileHandle.h>
+#include <mcld/Support/Path.h>
using namespace mcld;
using namespace mcld::sys::fs;
@@ -19,49 +20,48 @@
using namespace mcldtest;
// Constructor can do set-up work for all test here.
-MCFragmentRefTest::MCFragmentRefTest()
+FragmentRefTest::FragmentRefTest()
{
}
// Destructor can do clean-up work that doesn't throw exceptions here.
-MCFragmentRefTest::~MCFragmentRefTest()
+FragmentRefTest::~FragmentRefTest()
{
}
// SetUp() will be called immediately before each test.
-void MCFragmentRefTest::SetUp()
+void FragmentRefTest::SetUp()
{
}
// TearDown() will be called immediately after each test.
-void MCFragmentRefTest::TearDown()
+void FragmentRefTest::TearDown()
{
}
//==========================================================================//
// Testcases
//
-TEST_F( MCFragmentRefTest, ) {
+TEST_F( FragmentRefTest, ) {
Path path(TOPDIR);
path.append("unittests/test3.txt");
MemoryAreaFactory* areaFactory = new MemoryAreaFactory(1);
MemoryArea* area = areaFactory->produce(path, FileHandle::ReadWrite);
MemoryRegion* region = area->request(0, 4096);
- MCRegionFragment *frag = new MCRegionFragment(*region);
- MCFragmentRef *ref = new MCFragmentRef(*frag);
+ RegionFragment *frag = new RegionFragment(*region);
+ FragmentRef *ref = new FragmentRef(*frag);
ASSERT_EQ('H', region->getBuffer()[0]);
ASSERT_EQ(4096, region->size());
ASSERT_EQ('H', frag->getRegion().getBuffer()[0]);
ASSERT_EQ(4096, frag->getRegion().size());
ASSERT_EQ(frag, ref->frag());
- ASSERT_EQ('H', static_cast<MCRegionFragment*>(ref->frag())->getRegion().getBuffer()[0]);
- ASSERT_EQ(4096, static_cast<MCRegionFragment*>(ref->frag())->getRegion().size());
+ ASSERT_EQ('H', static_cast<RegionFragment*>(ref->frag())->getRegion().getBuffer()[0]);
+ ASSERT_EQ(4096, static_cast<RegionFragment*>(ref->frag())->getRegion().size());
ASSERT_EQ('H', ref->deref()[0]);
- ASSERT_FALSE(llvm::MCDataFragment::classof(frag));
- ASSERT_TRUE(MCRegionFragment::classof(frag));
+ ASSERT_TRUE(RegionFragment::classof(frag));
delete ref;
delete frag;
diff --git a/unittests/MCFragmentRefTest.h b/unittests/FragmentRefTest.h
similarity index 77%
rename from unittests/MCFragmentRefTest.h
rename to unittests/FragmentRefTest.h
index c0b23f3..340bd77 100644
--- a/unittests/MCFragmentRefTest.h
+++ b/unittests/FragmentRefTest.h
@@ -1,4 +1,4 @@
-//===- MCFragmentRefTest.h ------------------------------------------------===//
+//===- FragmentRefTest.h --------------------------------------------------===//
//
// The MCLinker Project
//
@@ -14,26 +14,26 @@
namespace mcld
{
-class MCFragmentRef;
+class FragmentRef;
} // namespace for mcld
namespace mcldtest
{
-/** \class MCFragmentRefTest
+/** \class FragmentRefTest
* \brief Reference Test
*
- * \see MCFragmentRef
+ * \see FragmentRef
*/
-class MCFragmentRefTest : public ::testing::Test
+class FragmentRefTest : public ::testing::Test
{
public:
// Constructor can do set-up work for all test here.
- MCFragmentRefTest();
+ FragmentRefTest();
// Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~MCFragmentRefTest();
+ virtual ~FragmentRefTest();
// SetUp() will be called immediately before each test.
virtual void SetUp();
diff --git a/unittests/FragmentTest.cpp b/unittests/FragmentTest.cpp
new file mode 100644
index 0000000..5186ea8
--- /dev/null
+++ b/unittests/FragmentTest.cpp
@@ -0,0 +1,79 @@
+//===- FragmentTest.cpp -------------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "FragmentTest.h"
+
+#include <mcld/LD/Fragment.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/LD/LDSection.h>
+
+using namespace mcld;
+using namespace mcldtest;
+
+
+// Constructor can do set-up work for all test here.
+FragmentTest::FragmentTest()
+{
+}
+
+// Destructor can do clean-up work that doesn't throw exceptions here.
+FragmentTest::~FragmentTest()
+{
+}
+
+// SetUp() will be called immediately before each test.
+void FragmentTest::SetUp()
+{
+}
+
+// TearDown() will be called immediately after each test.
+void FragmentTest::TearDown()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// Testcases
+
+TEST_F( FragmentTest, Fragment_constructor ) {
+ LDSection test("test", LDFileFormat::Null, 0, 0);
+ SectionData* s = new SectionData(test);
+ Fragment* f1 = new Fragment(Fragment::Alignment, s);
+ EXPECT_TRUE(1 == s->size());
+ Fragment* f2 = new Fragment(Fragment::Alignment, s);
+ Fragment* f3 = new Fragment(Fragment::Region, s);
+ Fragment* f4 = new Fragment(Fragment::Fillment, s);
+ Fragment* f5 = new Fragment(Fragment::Relocation, s);
+ Fragment* f6 = new Fragment(Fragment::Target, s);
+ EXPECT_TRUE(6 == s->size());
+
+ delete s;
+}
+
+TEST_F( FragmentTest, Fragment_trivial_function ) {
+ LDSection test("test", LDFileFormat::Null, 0, 0);
+ SectionData* s = new SectionData(test);
+ Fragment* f = new Fragment(Fragment::Alignment, s);
+
+ EXPECT_TRUE(Fragment::Alignment == f->getKind());
+
+ EXPECT_TRUE(~uint64_t(0) == f->getOffset());
+ EXPECT_TRUE(~(0U) == f->getLayoutOrder());
+
+ f->setOffset(5566);
+ EXPECT_TRUE(5566 == f->getOffset());
+
+ f->setLayoutOrder(5566);
+ EXPECT_TRUE(5566 == f->getLayoutOrder());
+
+ //always return true
+ EXPECT_TRUE(f->classof(new Fragment(Fragment::Region, s)) );
+
+ delete s;
+}
+
+
diff --git a/unittests/MCFragmentRefTest.h b/unittests/FragmentTest.h
similarity index 66%
copy from unittests/MCFragmentRefTest.h
copy to unittests/FragmentTest.h
index c0b23f3..84ac7b7 100644
--- a/unittests/MCFragmentRefTest.h
+++ b/unittests/FragmentTest.h
@@ -1,4 +1,4 @@
-//===- MCFragmentRefTest.h ------------------------------------------------===//
+//===- headerTest.h -------------------------------------------------------===//
//
// The MCLinker Project
//
@@ -6,40 +6,42 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-
-#ifndef MCLD_MCFRAGMENT_REF_TEST_H
-#define MCLD_MCFRAGMENT_REF_TEST_H
+#ifndef MCLD_FRAGMENT_TEST_H
+#define MCLD_FRAGMENT_TEST_H
#include <gtest.h>
namespace mcld
{
-class MCFragmentRef;
+class Fragment;
} // namespace for mcld
namespace mcldtest
{
-/** \class MCFragmentRefTest
- * \brief Reference Test
+/** \class FragmentTest
+ * \brief Unit test for mcld::Fragment.
*
- * \see MCFragmentRef
+ * \see Fragment
*/
-class MCFragmentRefTest : public ::testing::Test
+class FragmentTest : public ::testing::Test
{
public:
// Constructor can do set-up work for all test here.
- MCFragmentRefTest();
+ FragmentTest();
// Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~MCFragmentRefTest();
+ virtual ~FragmentTest();
// SetUp() will be called immediately before each test.
virtual void SetUp();
// TearDown() will be called immediately after each test.
virtual void TearDown();
+
+protected:
+ mcld::Fragment* m_pTestee;
};
} // namespace of mcldtest
diff --git a/unittests/Linker/TestLinker.cpp b/unittests/Linker/TestLinker.cpp
index 243be86..ad6e13a 100644
--- a/unittests/Linker/TestLinker.cpp
+++ b/unittests/Linker/TestLinker.cpp
@@ -14,15 +14,18 @@
#include <mcld/LD/TextDiagnosticPrinter.h>
#include <mcld/MC/InputTree.h>
+#include <mcld/MC/MCLDDirectory.h>
#include <mcld/Target/TargetLDBackend.h>
#include <mcld/Support/RegionFactory.h>
#include <mcld/Support/TargetSelect.h>
#include <mcld/Support/MsgHandling.h>
#include <mcld/Support/raw_ostream.h>
#include <mcld/Support/SystemUtils.h>
+#include <mcld/Support/MemoryAreaFactory.h>
using namespace std;
using namespace mcld;
+using namespace mcld::sys::fs;
using namespace mcld::test;
//===----------------------------------------------------------------------===//
@@ -30,7 +33,8 @@
//===----------------------------------------------------------------------===//
TestLinker::TestLinker()
: m_pTarget(NULL), m_pDriver(NULL), m_pInfo(NULL), m_pDiagLineInfo(NULL),
- m_pDiagPrinter(NULL), m_pBackend(NULL), m_pRegionFactory(NULL) {
+ m_pDiagPrinter(NULL), m_pBackend(NULL), m_pRegionFactory(NULL),
+ m_pMemAreaFactory(NULL) {
}
TestLinker::~TestLinker()
@@ -49,6 +53,7 @@
delete m_pDiagPrinter;
delete m_pBackend;
delete m_pRegionFactory;
+ delete m_pMemAreaFactory;
}
bool TestLinker::initialize(const std::string &pTriple)
@@ -99,14 +104,40 @@
return false;
}
- m_pDriver = new mcld::MCLDDriver(*m_pInfo, *m_pBackend);
+ m_pMemAreaFactory = new MemoryAreaFactory(32);
+ m_pDriver = new mcld::MCLDDriver(*m_pInfo, *m_pBackend, *m_pMemAreaFactory);
m_pDriver->initMCLinker();
is_initialized = true;
return true;
}
+void TestLinker::addSearchDir(const std::string &pDirPath)
+{
+ assert(NULL != m_pInfo && "initialize() must be called before addSearchDir");
+ assert(!m_pInfo->options().sysroot().empty() &&
+ "must setSysRoot before addSearchDir");
+
+ mcld::MCLDDirectory* sd = new mcld::MCLDDirectory(pDirPath);
+
+ if (sd->isInSysroot()) {
+ sd->setSysroot(m_pInfo->options().sysroot());
+ }
+
+ if (exists(sd->path()) && is_directory(sd->path())) {
+ m_pInfo->options().directories().add(*sd);
+ } else {
+ mcld::warning(mcld::diag::warn_cannot_open_search_dir) << sd->name();
+ }
+}
+
+void TestLinker::setSysRoot(const mcld::sys::fs::Path &pPath)
+{
+ assert(NULL != m_pInfo && "initialize() must be called before setSysRoot");
+ m_pInfo->options().setSysroot(pPath);
+}
+
void TestLinker::addObject(const std::string &pPath)
{
mcld::Input* input = m_pInfo->inputFactory().produce(pPath, pPath,
@@ -255,6 +286,11 @@
return true;
}
+bool TestLinker::setOutput(const sys::fs::Path &pPath)
+{
+ return setOutput(pPath.native());
+}
+
bool TestLinker::setOutput(int pFileHandler)
{
if (m_pInfo->output().hasContext())
diff --git a/unittests/Linker/TestLinker.h b/unittests/Linker/TestLinker.h
index 79b3010..f44d2b0 100644
--- a/unittests/Linker/TestLinker.h
+++ b/unittests/Linker/TestLinker.h
@@ -49,6 +49,12 @@
return m_pInfo;
}
+ // ----- search directories ----- //
+ void addSearchDir(const std::string &pPath);
+
+ void setSysRoot(const mcld::sys::fs::Path &pPath);
+
+ // ----- input operators ----- //
void addObject(const std::string &pPath);
void addObject(const mcld::sys::fs::Path &pPath)
@@ -64,6 +70,8 @@
bool setOutput(int pFileHandler);
+ bool setOutput(const sys::fs::Path &pPath);
+
/// getDriver
MCLDDriver* getDriver() {
assert(NULL != m_pDriver);
@@ -100,6 +108,7 @@
mcld::TargetLDBackend* m_pBackend;
mcld::InputTree::iterator m_Root;
mcld::RegionFactory* m_pRegionFactory;
+ mcld::MemoryAreaFactory* m_pMemAreaFactory;
std::list<mcld::FileHandle*> m_FileHandleList;
std::list<mcld::MemoryArea*> m_MemAreaList;
diff --git a/unittests/PathTest.cpp b/unittests/PathTest.cpp
index 8906d02..2a4de80 100644
--- a/unittests/PathTest.cpp
+++ b/unittests/PathTest.cpp
@@ -138,3 +138,20 @@
EXPECT_STREQ("/usr/lib/", m_pTestee->generic_string().c_str());
}
+TEST_F( PathTest, parent_path ) {
+ m_pTestee->assign("aa/bb/cc/dd");
+ EXPECT_STREQ("aa/bb/cc", m_pTestee->parent_path().c_str());
+ delete m_pTestee;
+ m_pTestee = new Path("/aa/bb/");
+ EXPECT_STREQ("/aa/bb", m_pTestee->parent_path().c_str());
+ delete m_pTestee;
+ m_pTestee = new Path("/aa/bb");
+ EXPECT_STREQ("/aa", m_pTestee->parent_path().c_str());
+ delete m_pTestee;
+ m_pTestee = new Path("aa/");
+ EXPECT_STREQ("aa", m_pTestee->parent_path().c_str());
+ delete m_pTestee;
+ m_pTestee = new Path("aa");
+ EXPECT_TRUE(m_pTestee->parent_path().empty());
+}
+
diff --git a/unittests/ReadStageTest.cpp b/unittests/ReadStageTest.cpp
new file mode 100644
index 0000000..c687c0b
--- /dev/null
+++ b/unittests/ReadStageTest.cpp
@@ -0,0 +1,147 @@
+//===- ReadStageTest.cpp --------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "ReadStageTest.h"
+#include <mcld/LD/LDContext.h>
+#include <mcld/LD/LDSection.h>
+#include <mcld/LD/SectionData.h>
+#include <mcld/LD/Fragment.h>
+#include <mcld/LD/FragmentRef.h>
+#include <mcld/LD/LDSymbol.h>
+#include <mcld/LD/ResolveInfo.h>
+
+#include <sstream>
+#include <iostream>
+
+using namespace std;
+
+using namespace mcld;
+using namespace mcld::test;
+
+
+// Constructor can do set-up work for all test here.
+ReadStageTest::ReadStageTest()
+ : m_pLinker(NULL) {
+}
+
+// Destructor can do clean-up work that doesn't throw exceptions here.
+ReadStageTest::~ReadStageTest()
+{
+}
+
+// SetUp() will be called immediately before each test.
+void ReadStageTest::SetUp()
+{
+ m_pLinker = new mcld::test::TestLinker();
+ m_pLinker->initialize("arm-none-linux-gnueabi");
+
+ // set up target-dependent constraints of attributes
+ m_pLinker->config()->attrFactory().constraint().enableWholeArchive();
+ m_pLinker->config()->attrFactory().constraint().disableAsNeeded();
+ m_pLinker->config()->attrFactory().constraint().setSharedSystem();
+
+ // set up the predefined attributes
+ m_pLinker->config()->attrFactory().predefined().setWholeArchive();
+ m_pLinker->config()->attrFactory().predefined().setDynamic();
+
+ // set up target dependent options
+ mcld::sys::fs::Path path = TOPDIR;
+ path.append("test/libs/ARM/Android/android-14");
+ m_pLinker->setSysRoot(path);
+ m_pLinker->addSearchDir("=/");
+
+ m_pLinker->config()->options().setDyld("/usr/lib/ld.so.1");
+ m_pLinker->config()->options().setBsymbolic(true);
+}
+
+// TearDown() will be called immediately after each test.
+void ReadStageTest::TearDown()
+{
+ delete m_pLinker;
+}
+
+void ReadStageTest::dumpInput(const mcld::Input &pInput, mcld::FileHandle &pFile, size_t pIdent)
+{
+ stringstream sstream;
+ for (int i=0; i < pIdent; ++i)
+ sstream << " ";
+ sstream << "<input name=\"" << pInput.name() << "\">\n";
+
+ LDContext::const_sect_iterator sect, sectEnd = pInput.context()->sectEnd();
+ for (sect = pInput.context()->sectBegin(); sect != sectEnd; ++sect) {
+ for (int i=0; i < (pIdent+1); ++i)
+ sstream << " ";
+ sstream << "<section name=\"" << (*sect)->name() << "\"/>\n";
+ }
+ for (int i=0; i < pIdent; ++i)
+ sstream << " ";
+ sstream << "</input>\n";
+
+ size_t org_size = pFile.size();
+ pFile.truncate(sstream.str().size() + org_size);
+ pFile.write(sstream.str().data(), org_size, sstream.str().size());
+}
+
+void ReadStageTest::dumpOutput(const mcld::Output &pOutput, mcld::FileHandle &pFile, size_t pIdent)
+{
+ stringstream sstream;
+ for (int i=0; i < pIdent; ++i)
+ sstream << " ";
+ sstream << "<output name=\"" << pOutput.name() << "\">\n";
+
+ LDContext::const_sect_iterator sect, sectEnd = pOutput.context()->sectEnd();
+ for (sect = pOutput.context()->sectBegin(); sect != sectEnd; ++sect) {
+ for (int i=0; i < (pIdent+1); ++i)
+ sstream << " ";
+ sstream << "<section name=\"" << (*sect)->name() << "\"/>\n";
+ }
+ for (int i=0; i < pIdent; ++i)
+ sstream << " ";
+ sstream << "</output>\n";
+
+ size_t org_size = pFile.size();
+ pFile.truncate(sstream.str().size() + org_size);
+ pFile.write(sstream.str().data(), org_size, sstream.str().size());
+}
+//===----------------------------------------------------------------------===//
+// Testcases
+//===----------------------------------------------------------------------===//
+TEST_F(ReadStageTest, quake) {
+ mcld::sys::fs::Path top_level = TOPDIR;
+
+ // set up output
+ m_pLinker->config()->output().setType(mcld::Output::DynObj);
+ m_pLinker->setOutput(top_level + "unittests/plasma.so");
+
+
+ // set up input
+ m_pLinker->addObject(top_level + "test/libs/ARM/Android/android-14/crtbegin_so.o");
+ m_pLinker->addObject(top_level + "test/Android/Plasma/ARM/plasma.o");
+ m_pLinker->addNameSpec("m");
+ m_pLinker->addNameSpec("log");
+ m_pLinker->addNameSpec("jnigraphics");
+ m_pLinker->addNameSpec("c");
+ m_pLinker->addObject(top_level + "test/libs/ARM/Android/android-14/crtend_so.o");
+
+ // dump status
+ m_pLinker->getDriver()->normalize();
+
+ FileHandle file;
+ file.open(top_level + "unittests/read_stage.xml",
+ FileHandle::ReadWrite | FileHandle::Create | FileHandle::Truncate, 0644);
+
+ InputTree::iterator input, inEnd = m_pLinker->config()->inputs().end();
+ for (input = m_pLinker->config()->inputs().begin(); input != inEnd; ++input) {
+ dumpInput(**input, file, 1);
+ }
+
+ dumpOutput(m_pLinker->config()->output(), file, 1);
+ // dump status
+ ASSERT_TRUE(m_pLinker->getDriver()->mergeSections());
+}
+
diff --git a/unittests/ReadStageTest.h b/unittests/ReadStageTest.h
new file mode 100644
index 0000000..5fd4595
--- /dev/null
+++ b/unittests/ReadStageTest.h
@@ -0,0 +1,44 @@
+//===- ReadStageTest.h ----------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_UNITTEST_READSTAGE_TEST_H
+#define MCLD_UNITTEST_READSTAGE_TEST_H
+
+#include <gtest.h>
+#include "Linker/TestLinker.h"
+
+namespace mcld {
+namespace test {
+
+class ReadStageTest : public ::testing::Test
+{
+public:
+ // Constructor can do set-up work for all test here.
+ ReadStageTest();
+
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~ReadStageTest();
+
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
+
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
+
+ void dumpInput(const mcld::Input &pInput, mcld::FileHandle &pFile, size_t pIdent);
+
+ void dumpOutput(const mcld::Output &pOutput, mcld::FileHandle &pFile, size_t pIdent);
+protected:
+ TestLinker* m_pLinker;
+};
+
+} // end of namespace test
+} // end of namespace mcld
+
+#endif
+
diff --git a/unittests/SectionDataTest.cpp b/unittests/SectionDataTest.cpp
new file mode 100644
index 0000000..d100f56
--- /dev/null
+++ b/unittests/SectionDataTest.cpp
@@ -0,0 +1,86 @@
+//===- SectionDataTest.cpp ------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "SectionDataTest.h"
+
+#include <mcld/LD/SectionData.h>
+#include <mcld/LD/LDFileFormat.h>
+#include <mcld/LD/LDSection.h>
+
+using namespace mcld;
+using namespace mcldtest;
+
+
+// Constructor can do set-up work for all test here.
+SectionDataTest::SectionDataTest()
+{
+}
+
+// Destructor can do clean-up work that doesn't throw exceptions here.
+SectionDataTest::~SectionDataTest()
+{
+}
+
+// SetUp() will be called immediately before each test.
+void SectionDataTest::SetUp()
+{
+}
+
+// TearDown() will be called immediately after each test.
+void SectionDataTest::TearDown()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// Testcases
+//===----------------------------------------------------------------------===//
+
+TEST_F( SectionDataTest, constructor_and_trivial_func ) {
+ LDSection test("test", LDFileFormat::Null, 0, 0);
+
+ SectionData* s = new SectionData(test);
+ EXPECT_TRUE(s->getSection().name() == "test" && \
+ s->getSection().kind() == LDFileFormat::Null);
+
+ s->setAlignment(5566);
+ EXPECT_TRUE(5566 == s->getAlignment());
+
+ delete s;
+}
+
+TEST_F( SectionDataTest, Fragment_list_and_iterator ) {
+ LDSection test("test", LDFileFormat::Null, 0, 0);
+ SectionData* s = new SectionData(test);
+ EXPECT_TRUE(s->empty());
+
+ Fragment* f1 = new Fragment(Fragment::Alignment, s);
+ Fragment* f2 = new Fragment(Fragment::Alignment, s);
+ Fragment* f3 = new Fragment(Fragment::Region, s);
+ Fragment* f4 = new Fragment(Fragment::Fillment, s);
+ Fragment* f5 = new Fragment(Fragment::Relocation, s);
+ Fragment* f6 = new Fragment(Fragment::Target, s);
+ EXPECT_TRUE(6 == s->size());
+
+ //iterator
+ llvm::iplist<Fragment>::iterator iter=s->begin();
+ EXPECT_TRUE(Fragment::Alignment == iter->getKind());
+ ++iter;
+ EXPECT_TRUE(Fragment::Alignment == iter->getKind());
+ ++iter;
+ EXPECT_TRUE(Fragment::Region == iter->getKind());
+ ++iter;
+ EXPECT_TRUE(Fragment::Fillment == iter->getKind());
+ ++iter;
+ EXPECT_TRUE(Fragment::Relocation == iter->getKind());
+ ++iter;
+ EXPECT_TRUE(Fragment::Target == iter->getKind());
+ ++iter;
+ EXPECT_TRUE(iter == s->end());
+
+ delete s;
+}
diff --git a/unittests/MCFragmentRefTest.h b/unittests/SectionDataTest.h
similarity index 65%
copy from unittests/MCFragmentRefTest.h
copy to unittests/SectionDataTest.h
index c0b23f3..bbc2736 100644
--- a/unittests/MCFragmentRefTest.h
+++ b/unittests/SectionDataTest.h
@@ -1,4 +1,4 @@
-//===- MCFragmentRefTest.h ------------------------------------------------===//
+//===- SectionDataTest.h --------------------------------------------------===//
//
// The MCLinker Project
//
@@ -6,34 +6,26 @@
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
-
-#ifndef MCLD_MCFRAGMENT_REF_TEST_H
-#define MCLD_MCFRAGMENT_REF_TEST_H
+#ifndef MCLD_SECTIONDATA_TEST_H
+#define MCLD_SECTIONDATA_TEST_H
#include <gtest.h>
-namespace mcld
-{
-class MCFragmentRef;
-
+namespace mcld {
+class SectionData;
} // namespace for mcld
namespace mcldtest
{
-/** \class MCFragmentRefTest
- * \brief Reference Test
- *
- * \see MCFragmentRef
- */
-class MCFragmentRefTest : public ::testing::Test
+class SectionDataTest : public ::testing::Test
{
public:
// Constructor can do set-up work for all test here.
- MCFragmentRefTest();
+ SectionDataTest();
// Destructor can do clean-up work that doesn't throw exceptions here.
- virtual ~MCFragmentRefTest();
+ virtual ~SectionDataTest();
// SetUp() will be called immediately before each test.
virtual void SetUp();
diff --git a/unittests/StaticResolverTest.cpp b/unittests/StaticResolverTest.cpp
index 5839507..439f21a 100644
--- a/unittests/StaticResolverTest.cpp
+++ b/unittests/StaticResolverTest.cpp
@@ -50,6 +50,7 @@
delete m_pResolver;
delete m_pFactory;
delete m_pLDInfo;
+ delete m_pLineInfo;
}
// SetUp() will be called immediately before each test.
diff --git a/unittests/SystemUtilsTest.cpp b/unittests/SystemUtilsTest.cpp
new file mode 100644
index 0000000..1222794
--- /dev/null
+++ b/unittests/SystemUtilsTest.cpp
@@ -0,0 +1,42 @@
+//===- SystemUtilsTest.cpp ------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include <mcld/Support/SystemUtils.h>
+#include "SystemUtilsTest.h"
+
+using namespace mcld;
+using namespace mcld::test;
+
+
+// Constructor can do set-up work for all test here.
+SystemUtilsTest::SystemUtilsTest()
+{
+}
+
+// Destructor can do clean-up work that doesn't throw exceptions here.
+SystemUtilsTest::~SystemUtilsTest()
+{
+}
+
+// SetUp() will be called immediately before each test.
+void SystemUtilsTest::SetUp()
+{
+}
+
+// TearDown() will be called immediately after each test.
+void SystemUtilsTest::TearDown()
+{
+}
+
+//===----------------------------------------------------------------------===//
+// Testcases
+//===----------------------------------------------------------------------===//
+TEST_F( SystemUtilsTest, test_strerror) {
+ ASSERT_TRUE(NULL != mcld::sys::strerror(0));
+}
+
diff --git a/unittests/SystemUtilsTest.h b/unittests/SystemUtilsTest.h
new file mode 100644
index 0000000..660d7bb
--- /dev/null
+++ b/unittests/SystemUtilsTest.h
@@ -0,0 +1,37 @@
+//===- SystemUtilsTest.h --------------------------------------------------===//
+//
+// The MCLinker Project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#ifndef MCLD_UNITTEST_SYSTEM_UTILS_TEST_H
+#define MCLD_UNITTEST_SYSTEM_UTILS_TEST_H
+
+#include <gtest.h>
+
+namespace mcld {
+namespace test {
+
+class SystemUtilsTest : public ::testing::Test
+{
+public:
+ // Constructor can do set-up work for all test here.
+ SystemUtilsTest();
+
+ // Destructor can do clean-up work that doesn't throw exceptions here.
+ virtual ~SystemUtilsTest();
+
+ // SetUp() will be called immediately before each test.
+ virtual void SetUp();
+
+ // TearDown() will be called immediately after each test.
+ virtual void TearDown();
+};
+
+} // namespace of test
+} // namespace of mcld
+
+#endif
+
diff --git a/unittests/TestLinkerTest.cpp b/unittests/TestLinkerTest.cpp
index b6df3cf..272cd89 100644
--- a/unittests/TestLinkerTest.cpp
+++ b/unittests/TestLinkerTest.cpp
@@ -46,9 +46,10 @@
// set up target dependent options
mcld::sys::fs::Path path = TOPDIR;
path.append("test/libs/ARM/Android/android-14");
- m_pLinker->config()->options().setSysroot(path);
+ m_pLinker->setSysRoot(path);
+ m_pLinker->addSearchDir("=/");
+
m_pLinker->config()->options().setDyld("/usr/lib/ld.so.1");
- m_pLinker->config()->options().directories().add("=/");
m_pLinker->config()->options().setBsymbolic(true);
}
diff --git a/unittests/UniqueGCFactoryBaseTest.cpp b/unittests/UniqueGCFactoryBaseTest.cpp
index 067467b..32447c2 100644
--- a/unittests/UniqueGCFactoryBaseTest.cpp
+++ b/unittests/UniqueGCFactoryBaseTest.cpp
@@ -30,6 +30,8 @@
// Destructor can do clean-up work that doesn't throw exceptions here.
UniqueGCFactoryBaseTest::~UniqueGCFactoryBaseTest()
{
+ delete m_pLDInfo;
+ delete m_pLineInfo;
}
// SetUp() will be called immediately before each test.
diff --git a/unittests/read_stage.xml b/unittests/read_stage.xml
new file mode 100644
index 0000000..cc061d6
--- /dev/null
+++ b/unittests/read_stage.xml
@@ -0,0 +1,273 @@
+ <input name="/Users/lubatang/Project/MCLinker/build/../src-tree/test/libs/ARM/Android/android-14/crtbegin_so.o">
+ <section name=""/>
+ <section name=".text"/>
+ <section name=".rel.text"/>
+ <section name=".data"/>
+ <section name=".bss"/>
+ <section name=".init_array"/>
+ <section name=".fini_array"/>
+ <section name=".rel.fini_array"/>
+ <section name=".ARM.attributes"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ </input>
+ <input name="/Users/lubatang/Project/MCLinker/build/../src-tree/test/Android/Plasma/ARM/plasma.o">
+ <section name=""/>
+ <section name=".text"/>
+ <section name=".rel.text"/>
+ <section name=".text.now_ms"/>
+ <section name=".rel.text.now_ms"/>
+ <section name=".text.init_angles"/>
+ <section name=".rel.text.init_angles"/>
+ <section name=".text.angle_sin"/>
+ <section name=".rel.text.angle_sin"/>
+ <section name=".text.fixed_sin"/>
+ <section name=".rel.text.fixed_sin"/>
+ <section name=".text.make565"/>
+ <section name=".text.init_palette"/>
+ <section name=".rel.text.init_palette"/>
+ <section name=".text.palette_from_fixed"/>
+ <section name=".rel.text.palette_from_fixed"/>
+ <section name=".text.init_tables"/>
+ <section name=".rel.text.init_tables"/>
+ <section name=".text.fill_plasma"/>
+ <section name=".rel.text.fill_plasma"/>
+ <section name=".text.stats_init"/>
+ <section name=".rel.text.stats_init"/>
+ <section name=".text.stats_startFrame"/>
+ <section name=".rel.text.stats_startFrame"/>
+ <section name=".text.stats_endFrame"/>
+ <section name=".rel.text.stats_endFrame"/>
+ <section name=".text.Java_com_example_plasma_PlasmaView_renderPlasma"/>
+ <section name=".rel.text.Java_com_example_plasma_PlasmaView_renderPlasma"/>
+ <section name=".rodata"/>
+ <section name=".ARM.extab.text.now_ms"/>
+ <section name=".ARM.exidx.text.now_ms"/>
+ <section name=".rel.ARM.exidx.text.now_ms"/>
+ <section name=".ARM.extab.text.init_angles"/>
+ <section name=".ARM.exidx.text.init_angles"/>
+ <section name=".rel.ARM.exidx.text.init_angles"/>
+ <section name=".ARM.extab.text.angle_sin"/>
+ <section name=".ARM.exidx.text.angle_sin"/>
+ <section name=".rel.ARM.exidx.text.angle_sin"/>
+ <section name=".ARM.extab.text.fixed_sin"/>
+ <section name=".ARM.exidx.text.fixed_sin"/>
+ <section name=".rel.ARM.exidx.text.fixed_sin"/>
+ <section name=".ARM.extab.text.make565"/>
+ <section name=".ARM.exidx.text.make565"/>
+ <section name=".rel.ARM.exidx.text.make565"/>
+ <section name=".ARM.extab.text.init_palette"/>
+ <section name=".ARM.exidx.text.init_palette"/>
+ <section name=".rel.ARM.exidx.text.init_palette"/>
+ <section name=".ARM.extab.text.palette_from_fixed"/>
+ <section name=".ARM.exidx.text.palette_from_fixed"/>
+ <section name=".rel.ARM.exidx.text.palette_from_fixed"/>
+ <section name=".ARM.extab.text.init_tables"/>
+ <section name=".ARM.exidx.text.init_tables"/>
+ <section name=".rel.ARM.exidx.text.init_tables"/>
+ <section name=".ARM.extab.text.fill_plasma"/>
+ <section name=".ARM.exidx.text.fill_plasma"/>
+ <section name=".rel.ARM.exidx.text.fill_plasma"/>
+ <section name=".ARM.extab.text.stats_init"/>
+ <section name=".ARM.exidx.text.stats_init"/>
+ <section name=".rel.ARM.exidx.text.stats_init"/>
+ <section name=".ARM.extab.text.stats_startFrame"/>
+ <section name=".ARM.exidx.text.stats_startFrame"/>
+ <section name=".rel.ARM.exidx.text.stats_startFrame"/>
+ <section name=".ARM.extab.text.stats_endFrame"/>
+ <section name=".ARM.exidx.text.stats_endFrame"/>
+ <section name=".rel.ARM.exidx.text.stats_endFrame"/>
+ <section name=".ARM.extab.text.Java_com_example_plasma_PlasmaView_renderPlasma"/>
+ <section name=".ARM.exidx.text.Java_com_example_plasma_PlasmaView_renderPlasma"/>
+ <section name=".rel.ARM.exidx.text.Java_com_example_plasma_PlasmaView_renderPlasma"/>
+ <section name=".ARM.extab"/>
+ <section name=".ARM.exidx"/>
+ <section name=".rel.ARM.exidx"/>
+ <section name=".data"/>
+ <section name=".bss"/>
+ <section name=".comment"/>
+ <section name=".debug_aranges"/>
+ <section name=".rel.debug_aranges"/>
+ <section name=".debug_pubnames"/>
+ <section name=".rel.debug_pubnames"/>
+ <section name=".debug_info"/>
+ <section name=".rel.debug_info"/>
+ <section name=".debug_abbrev"/>
+ <section name=".debug_line"/>
+ <section name=".rel.debug_line"/>
+ <section name=".debug_frame"/>
+ <section name=".rel.debug_frame"/>
+ <section name=".debug_str"/>
+ <section name=".debug_loc"/>
+ <section name=".rel.debug_loc"/>
+ <section name=".debug_ranges"/>
+ <section name=".rel.debug_ranges"/>
+ <section name=".note.GNU-stack"/>
+ <section name=".ARM.attributes"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ </input>
+ <input name="libm.so">
+ <section name=""/>
+ <section name=".hash"/>
+ <section name=".dynsym"/>
+ <section name=".dynstr"/>
+ <section name=".text"/>
+ <section name=".dynamic"/>
+ <section name=".got"/>
+ <section name=".bss"/>
+ <section name=".ARM.attributes"/>
+ <section name=".comment"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ </input>
+ <input name="liblog.so">
+ <section name=""/>
+ <section name=".hash"/>
+ <section name=".dynsym"/>
+ <section name=".dynstr"/>
+ <section name=".text"/>
+ <section name=".dynamic"/>
+ <section name=".got"/>
+ <section name=".ARM.attributes"/>
+ <section name=".comment"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ </input>
+ <input name="libjnigraphics.so">
+ <section name=""/>
+ <section name=".hash"/>
+ <section name=".dynsym"/>
+ <section name=".dynstr"/>
+ <section name=".text"/>
+ <section name=".dynamic"/>
+ <section name=".got"/>
+ <section name=".ARM.attributes"/>
+ <section name=".comment"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ </input>
+ <input name="libc.so">
+ <section name=""/>
+ <section name=".hash"/>
+ <section name=".dynsym"/>
+ <section name=".dynstr"/>
+ <section name=".text"/>
+ <section name=".dynamic"/>
+ <section name=".got"/>
+ <section name=".bss"/>
+ <section name=".ARM.attributes"/>
+ <section name=".comment"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ </input>
+ <input name="/Users/lubatang/Project/MCLinker/build/../src-tree/test/libs/ARM/Android/android-14/crtend_so.o">
+ <section name=""/>
+ <section name=".text"/>
+ <section name=".data"/>
+ <section name=".bss"/>
+ <section name=".init_array"/>
+ <section name=".fini_array"/>
+ <section name=".ARM.attributes"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ </input>
+ <output name="">
+ <section name=".text"/>
+ <section name=""/>
+ <section name=".rodata"/>
+ <section name=".bss"/>
+ <section name=".comment"/>
+ <section name=".data"/>
+ <section name=".debug"/>
+ <section name=".init"/>
+ <section name=".init_array"/>
+ <section name=".fini"/>
+ <section name=".fini_array"/>
+ <section name=".line"/>
+ <section name=".preinit_array"/>
+ <section name=".shstrtab"/>
+ <section name=".symtab"/>
+ <section name=".strtab"/>
+ <section name=".tbss"/>
+ <section name=".tdata"/>
+ <section name=".ctor"/>
+ <section name=".data.rel.ro"/>
+ <section name=".dtors"/>
+ <section name=".eh_frame"/>
+ <section name=".gcc_except_table"/>
+ <section name=".gnu.version"/>
+ <section name=".gnu.version_d"/>
+ <section name=".gnu.version_r"/>
+ <section name=".jcr"/>
+ <section name=".stab"/>
+ <section name=".stabstr"/>
+ <section name=".dynsym"/>
+ <section name=".dynstr"/>
+ <section name=".interp"/>
+ <section name=".hash"/>
+ <section name=".dynamic"/>
+ <section name=".rela.dyn"/>
+ <section name=".rela.plt"/>
+ <section name=".rel.dyn"/>
+ <section name=".rel.plt"/>
+ <section name=".got"/>
+ <section name=".plt"/>
+ <section name=".got.plt"/>
+ <section name=".eh_frame_hdr"/>
+ <section name=".ARM.exidx"/>
+ <section name=".ARM.extab"/>
+ <section name=".ARM.attributes"/>
+ <section name=".rel.text"/>
+ <section name=".rel.fini_array"/>
+ <section name=".rel.text.now_ms"/>
+ <section name=".rel.text.init_angles"/>
+ <section name=".rel.text.angle_sin"/>
+ <section name=".rel.text.fixed_sin"/>
+ <section name=".rel.text.init_palette"/>
+ <section name=".rel.text.palette_from_fixed"/>
+ <section name=".rel.text.init_tables"/>
+ <section name=".rel.text.fill_plasma"/>
+ <section name=".rel.text.stats_init"/>
+ <section name=".rel.text.stats_startFrame"/>
+ <section name=".rel.text.stats_endFrame"/>
+ <section name=".rel.text.Java_com_example_plasma_PlasmaView_renderPlasma"/>
+ <section name=".rel.ARM.exidx.text.now_ms"/>
+ <section name=".rel.ARM.exidx.text.init_angles"/>
+ <section name=".rel.ARM.exidx.text.angle_sin"/>
+ <section name=".rel.ARM.exidx.text.fixed_sin"/>
+ <section name=".rel.ARM.exidx.text.make565"/>
+ <section name=".rel.ARM.exidx.text.init_palette"/>
+ <section name=".rel.ARM.exidx.text.palette_from_fixed"/>
+ <section name=".rel.ARM.exidx.text.init_tables"/>
+ <section name=".rel.ARM.exidx.text.fill_plasma"/>
+ <section name=".rel.ARM.exidx.text.stats_init"/>
+ <section name=".rel.ARM.exidx.text.stats_startFrame"/>
+ <section name=".rel.ARM.exidx.text.stats_endFrame"/>
+ <section name=".rel.ARM.exidx.text.Java_com_example_plasma_PlasmaView_renderPlasma"/>
+ <section name=".rel.ARM.exidx"/>
+ <section name=".debug_aranges"/>
+ <section name=".rel.debug_aranges"/>
+ <section name=".debug_pubnames"/>
+ <section name=".rel.debug_pubnames"/>
+ <section name=".debug_info"/>
+ <section name=".rel.debug_info"/>
+ <section name=".debug_abbrev"/>
+ <section name=".debug_line"/>
+ <section name=".rel.debug_line"/>
+ <section name=".debug_frame"/>
+ <section name=".rel.debug_frame"/>
+ <section name=".debug_str"/>
+ <section name=".debug_loc"/>
+ <section name=".rel.debug_loc"/>
+ <section name=".debug_ranges"/>
+ <section name=".rel.debug_ranges"/>
+ <section name=".note.GNU-stack"/>
+ </output>
