//===- GNULDBackend.h -----------------------------------------------------===//
//
// The MCLinker Project
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef MCLD_TARGET_GNU_LDBACKEND_H
#define MCLD_TARGET_GNU_LDBACKEND_H
#ifdef ENABLE_UNITTEST
#include <gtest.h>
#endif
#include <llvm/Support/ELF.h>
#include <mcld/ADT/HashTable.h>
#include <mcld/ADT/HashEntry.h>
#include <mcld/LD/EhFrameHdr.h>
#include <mcld/LD/ELFDynObjFileFormat.h>
#include <mcld/LD/ELFDynObjReader.h>
#include <mcld/LD/ELFDynObjWriter.h>
#include <mcld/LD/ELFExecFileFormat.h>
#include <mcld/LD/ELFExecWriter.h>
#include <mcld/LD/ELFObjectReader.h>
#include <mcld/LD/ELFObjectWriter.h>
#include <mcld/LD/ELFSegment.h>
#include <mcld/LD/ELFSegmentFactory.h>
#include <mcld/LD/GNUArchiveReader.h>
#include <mcld/Support/GCFactory.h>
#include <mcld/Target/ELFDynamic.h>
#include <mcld/Target/TargetLDBackend.h>
namespace mcld
{
struct SymCompare
{
bool operator()(const LDSymbol* X, const LDSymbol* Y) const
{ return (X==Y); }
};
struct PtrHash
{
size_t operator()(const LDSymbol* pKey) const
{
return (unsigned((uintptr_t)pKey) >> 4) ^
(unsigned((uintptr_t)pKey) >> 9);
}
};
class MCLDInfo;
class Layout;
class SymbolCategory;
/** \class GNULDBackend
* \brief GNULDBackend provides a common interface for all GNU Unix-OS
* LDBackend.
*/
class GNULDBackend : public TargetLDBackend
{
protected:
GNULDBackend();
public:
virtual ~GNULDBackend();
// ----- readers/writers ----- //
bool initArchiveReader(MCLinker& pLinker,
MCLDInfo& pInfo,
MemoryAreaFactory& pMemAreaFactory);
bool initObjectReader(MCLinker& pLinker);
bool initDynObjReader(MCLinker& pLinker);
bool initObjectWriter(MCLinker& pLinker);
bool initDynObjWriter(MCLinker& pLinker);
bool initExecWriter(MCLinker& pLinker);
GNUArchiveReader *getArchiveReader();
const GNUArchiveReader *getArchiveReader() const;
ELFObjectReader *getObjectReader();
const ELFObjectReader *getObjectReader() const;
ELFDynObjReader *getDynObjReader();
const ELFDynObjReader *getDynObjReader() const;
ELFObjectWriter *getObjectWriter();
const ELFObjectWriter *getObjectWriter() const;
ELFDynObjWriter *getDynObjWriter();
const ELFDynObjWriter *getDynObjWriter() const;
ELFExecWriter *getExecWriter();
const ELFExecWriter *getExecWriter() const;
// ----- output sections ----- //
/// initExecSections - initialize sections of the output executable file.
bool initExecSections(MCLinker& pMCLinker);
/// initDynObjSections - initialize sections of the output shared object.
bool initDynObjSections(MCLinker& pMCLinker);
/// getOutputFormat - get the sections of the output file.
ELFFileFormat* getOutputFormat(const Output& pOutput);
const ELFFileFormat* getOutputFormat(const Output& pOutput) const;
ELFDynObjFileFormat* getDynObjFileFormat();
const ELFDynObjFileFormat* getDynObjFileFormat() const;
ELFExecFileFormat* getExecFileFormat();
const ELFExecFileFormat* getExecFileFormat() const;
// ----- target symbols ----- //
/// initStandardSymbols - initialize standard symbols.
/// Some section symbols is undefined in input object, and linkers must set
/// up its value. Take __init_array_begin for example. This symbol is an
/// undefined symbol in input objects. MCLinker must finalize its value
/// to the begin of the .init_array section, then relocation enties to
/// __init_array_begin can be applied without emission of "undefined
/// reference to `__init_array_begin'".
bool initStandardSymbols(MCLinker& pLinker, const Output& pOutput);
/// finalizeSymbol - Linker checks pSymbol.reserved() if it's not zero,
/// then it will ask backend to finalize the symbol value.
/// @return ture - if backend set the symbol value sucessfully
/// @return false - if backend do not recognize the symbol
bool finalizeSymbols(MCLinker& pLinker, const Output& pOutput) {
return (finalizeStandardSymbols(pLinker, pOutput) &&
finalizeTargetSymbols(pLinker, pOutput));
}
/// finalizeStandardSymbols - set the value of standard symbols
virtual bool finalizeStandardSymbols(MCLinker& pLinker,
const Output& pOutput);
/// finalizeTargetSymbols - set the value of target symbols
virtual bool finalizeTargetSymbols(MCLinker& pLinker,
const Output& pOutput) = 0;
size_t sectionStartOffset() const;
/// The return value of machine() it the same as e_machine in the ELF header*/
virtual uint32_t machine() const = 0;
/// ELFVersion - the value of e_ident[EI_VERSION]
virtual uint8_t ELFVersion() const
{ return llvm::ELF::EV_CURRENT; }
/// OSABI - the value of e_ident[EI_OSABI]
virtual uint8_t OSABI() const = 0;
/// ABIVersion - the value of e_ident[EI_ABIVRESION]
virtual uint8_t ABIVersion() const = 0;
/// flags - the value of ElfXX_Ehdr::e_flags
virtual uint64_t flags() const = 0;
/// entry - the symbol name of the entry point
virtual const char* entry() const
{ return "_start"; }
/// dyld - the name of the default dynamic linker
/// target may override this function if needed.
/// @ref gnu ld, bfd/elf32-i386.c:521
virtual const char* dyld() const
{ return "/usr/lib/libc.so.1"; }
/// defaultTextSegmentAddr - target should specify its own default start address
/// of the text segment. esp. for exec.
virtual uint64_t defaultTextSegmentAddr() const
{ return 0x0; }
/// segmentStartAddr - this function returns the start address of the segment
uint64_t segmentStartAddr(const Output& pOutput,
const MCLDInfo& pInfo) const;
/// sizeNamePools - compute the size of regular name pools
/// In ELF executable files, regular name pools are .symtab, .strtab.,
/// .dynsym, .dynstr, and .hash
virtual void sizeNamePools(const Output& pOutput,
const SymbolCategory& pSymbols,
const MCLDInfo& pLDInfo);
/// emitSectionData - emit target-dependent section data
virtual uint64_t emitSectionData(const Output& pOutput,
const LDSection& pSection,
const MCLDInfo& pInfo,
const Layout& pLayout,
MemoryRegion& pRegion) const = 0;
/// emitRegNamePools - emit regular name pools - .symtab, .strtab
virtual void emitRegNamePools(Output& pOutput,
SymbolCategory& pSymbols,
const Layout& pLayout,
const MCLDInfo& pLDInfo);
/// emitNamePools - emit dynamic name pools - .dyntab, .dynstr, .hash
virtual void emitDynNamePools(Output& pOutput,
SymbolCategory& pSymbols,
const Layout& pLayout,
const MCLDInfo& pLDInfo);
/// sizeInterp - compute the size of program interpreter's name
/// In ELF executables, this is the length of dynamic linker's path name
virtual void sizeInterp(const Output& pOutput, const MCLDInfo& pLDInfo);
/// emitInterp - emit the .interp
virtual void emitInterp(Output& pOutput, const MCLDInfo& pLDInfo);
/// getSectionOrder - compute the layout order of the section
/// Layout calls this function to get the default order of the pSectHdr.
/// If the pSectHdr.type() is LDFileFormat::Target, then getSectionOrder()
/// will call getTargetSectionOrder().
///
/// If targets favors certain order for general sections, please override
/// this function.
///
/// @see getTargetSectionOrder
virtual unsigned int getSectionOrder(const Output& pOutput,
const LDSection& pSectHdr,
const MCLDInfo& pInfo) const;
/// getTargetSectionOrder - compute the layout order of target section
/// If the target favors certain order for the given gSectHdr, please
/// override this function.
///
/// By default, this function returns the maximun order, and pSectHdr
/// will be the last section to be laid out.
virtual unsigned int
getTargetSectionOrder(const Output& pOutput,
const LDSection& pSectHdr,
const MCLDInfo& pInfo) const
{ return (unsigned int)-1; }
/// numOfSegments - return the number of segments
/// if the target favors other ways to emit program header, please override
/// this function
virtual unsigned int numOfSegments() const
{ return m_ELFSegmentTable.size(); }
/// elfSegmentTable - return the reference of the elf segment table
ELFSegmentFactory& elfSegmentTable()
{ return m_ELFSegmentTable; }
/// elfSegmentTable - return the reference of the elf segment table
const ELFSegmentFactory& elfSegmentTable() const
{ return m_ELFSegmentTable; }
/// commonPageSize - the common page size of the target machine, and we set it
/// to 4K here. If target favors the different size, please override this
/// function
virtual uint64_t commonPageSize(const MCLDInfo& pInfo) const;
/// abiPageSize - the abi page size of the target machine, and we set it to 4K
/// here. If target favors the different size, please override this function
virtual uint64_t abiPageSize(const MCLDInfo& pInfo) const;
/// getSymbolIdx - get the symbol index of ouput symbol table
size_t getSymbolIdx(LDSymbol* pSymbol) const;
/// isDefaultExecStack - target should specify whether the stack is default
/// executable. If target favors another choice, please override this function
virtual bool isDefaultExecStack() const
{ return true; }
/// allocateCommonSymbols - allocate common symbols in the corresponding
/// sections.
/// Different concrete target backend may overlap this function.
virtual bool allocateCommonSymbols(const MCLDInfo& pLDInfo, MCLinker& pLinker) const;
/// isSymbolPreemtible - whether the symbol can be preemted by other
/// link unit
/// @ref Google gold linker, symtab.h:551
bool isSymbolPreemptible(const ResolveInfo& pSym,
const MCLDInfo& pLDInfo,
const Output& pOutput) const;
/// symbolNeedsDynRel - return whether the symbol needs a dynamic relocation
/// @ref Google gold linker, symtab.h:645
bool symbolNeedsDynRel(const ResolveInfo& pSym,
bool pSymHasPLT,
const MCLDInfo& pLDInfo,
const Output& pOutput,
bool isAbsReloc) const;
protected:
uint64_t getSymbolSize(const LDSymbol& pSymbol) const;
uint64_t getSymbolInfo(const LDSymbol& pSymbol) const;
uint64_t getSymbolValue(const LDSymbol& pSymbol) const;
uint64_t getSymbolShndx(const LDSymbol& pSymbol, const Layout& pLayout) const;
/// getHashBucketCount - calculate hash bucket count.
/// @ref Google gold linker, dynobj.cc:791
static unsigned getHashBucketCount(unsigned pNumOfSymbols, bool pIsGNUStyle);
/// isDynamicSymbol
/// @ref Google gold linker: symtab.cc:311
static bool isDynamicSymbol(const LDSymbol& pSymbol, const Output& pOutput);
/// isOutputPIC - return whether the output is position-independent
bool isOutputPIC(const Output& pOutput, const MCLDInfo& pInfo) const;
/// isStaticLink - return whether we're doing static link
bool isStaticLink(const Output& pOutput, const MCLDInfo& pInfo) const;
/// symbolNeedsPLT - return whether the symbol needs a PLT entry
/// @ref Google gold linker, symtab.h:596
bool symbolNeedsPLT(const ResolveInfo& pSym,
const MCLDInfo& pLDInfo,
const Output& pOutput) const;
/// symbolNeedsCopyReloc - return whether the symbol needs a copy relocation
bool symbolNeedsCopyReloc(const Layout& pLayout,
const Relocation& pReloc,
const ResolveInfo& pSym,
const MCLDInfo& pLDInfo,
const Output& pOutput) const;
private:
/// createProgramHdrs - base on output sections to create the program headers
void createProgramHdrs(Output& pOutput,
const MCLDInfo& pInfo);
/// setupProgramHdrs - set up the attributes of segments
/// (i.e., offset, addresses, file/mem size, flag, and alignment)
void setupProgramHdrs(const Output& pOutput, const MCLDInfo& pInfo);
/// getSegmentFlag - give a section flag and return the corresponding segment
/// flag
inline uint32_t getSegmentFlag(const uint32_t pSectionFlag)
{
uint32_t flag = llvm::ELF::PF_R;
if (0 != (pSectionFlag & llvm::ELF::SHF_WRITE))
flag |= llvm::ELF::PF_W;
if (0 != (pSectionFlag & llvm::ELF::SHF_EXECINSTR))
flag |= llvm::ELF::PF_X;
return flag;
}
/// createGNUStackInfo - create an output GNU stack section or segment if needed
void createGNUStackInfo(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker);
/// preLayout - Backend can do any needed modification before layout
void preLayout(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker);
/// postLayout -Backend can do any needed modification after layout
void postLayout(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker);
/// preLayout - Backend can do any needed modification before layout
virtual void doPreLayout(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker) = 0;
/// postLayout -Backend can do any needed modification after layout
virtual void doPostLayout(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker) = 0;
/// postProcessing - Backend can do any needed modification in the final stage
void postProcessing(const Output& pOutput,
const MCLDInfo& pInfo,
MCLinker& pLinker);
/// dynamic - the dynamic section of the target machine.
virtual ELFDynamic& dynamic() = 0;
/// dynamic - the dynamic section of the target machine.
virtual const ELFDynamic& dynamic() const = 0;
protected:
// Based on Kind in LDFileFormat to define basic section orders for ELF, and
// refer gold linker to add more enumerations to handle Regular and BSS kind
enum SectionOrder {
SHO_INTERP = 1, // .interp
SHO_RO_NOTE, // .note.ABI-tag, .note.gnu.build-id
SHO_NAMEPOOL, // *.hash, .dynsym, .dynstr
SHO_RELOCATION, // .rel.*, .rela.*
SHO_REL_PLT, // .rel.plt should come after other .rel.*
SHO_INIT, // .init
SHO_PLT, // .plt
SHO_TEXT, // .text
SHO_FINI, // .fini
SHO_RO, // .rodata
SHO_EXCEPTION, // .eh_frame_hdr, .eh_frame, .gcc_except_table
SHO_TLS_DATA, // .tdata
SHO_TLS_BSS, // .tbss
SHO_RELRO_LOCAL, // .data.rel.ro.local
SHO_RELRO, // .data.rel.ro,
SHO_RELRO_LAST, // for x86 to adjust .got if needed
SHO_NON_RELRO_FIRST, // for x86 to adjust .got.plt if needed
SHO_DATA, // .data
SHO_LARGE_DATA, // .ldata
SHO_RW_NOTE, //
SHO_SMALL_DATA, // .sdata
SHO_SMALL_BSS, // .sbss
SHO_BSS, // .bss
SHO_LARGE_BSS, // .lbss
SHO_UNDEFINED = ~(0U) // default order
};
typedef HashEntry<LDSymbol*, size_t, SymCompare> HashEntryType;
typedef HashTable<HashEntryType, PtrHash, EntryFactory<HashEntryType> > HashTableType;
protected:
// ----- readers and writers ----- //
GNUArchiveReader* m_pArchiveReader;
ELFObjectReader* m_pObjectReader;
ELFDynObjReader* m_pDynObjReader;
ELFObjectWriter* m_pObjectWriter;
ELFDynObjWriter* m_pDynObjWriter;
ELFExecWriter* m_pExecWriter;
// ----- file formats ----- //
ELFDynObjFileFormat* m_pDynObjFileFormat;
ELFExecFileFormat* m_pExecFileFormat;
// ELF segment factory
ELFSegmentFactory m_ELFSegmentTable;
// map the LDSymbol to its index in the output symbol table
HashTableType* m_pSymIndexMap;
// section .eh_frame_hdr
EhFrameHdr* m_pEhFrameHdr;
// ----- standard symbols ----- //
// section symbols
LDSymbol* f_pPreInitArrayStart;
LDSymbol* f_pPreInitArrayEnd;
LDSymbol* f_pInitArrayStart;
LDSymbol* f_pInitArrayEnd;
LDSymbol* f_pFiniArrayStart;
LDSymbol* f_pFiniArrayEnd;
LDSymbol* f_pStack;
// segment symbols
LDSymbol* f_pExecutableStart;
LDSymbol* f_pEText;
LDSymbol* f_p_EText;
LDSymbol* f_p__EText;
LDSymbol* f_pEData;
LDSymbol* f_p_EData;
LDSymbol* f_pBSSStart;
LDSymbol* f_pEnd;
LDSymbol* f_p_End;
};
} // namespace of mcld
#endif