1 //===-- TargetLDBackend.h - Target LD Backend -------------------*- C++ -*-===//
2 //
3 //                     The MCLinker Project
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 #ifndef MCLD_TARGET_TARGETLDBACKEND_H_
10 #define MCLD_TARGET_TARGETLDBACKEND_H_
11 #include "mcld/Fragment/Relocation.h"
12 #include "mcld/LD/GarbageCollection.h"
13 #include "mcld/Support/Compiler.h"
14 #include "mcld/Support/GCFactoryListTraits.h"
15 
16 #include <llvm/ADT/StringRef.h>
17 #include <llvm/ADT/ilist.h>
18 #include <llvm/Support/DataTypes.h>
19 
20 namespace mcld {
21 
22 class ArchiveReader;
23 class BinaryReader;
24 class BinaryWriter;
25 class BranchIslandFactory;
26 class DynObjReader;
27 class DynObjWriter;
28 class ExecWriter;
29 class FileOutputBuffer;
30 class IRBuilder;
31 class Input;
32 class LDSection;
33 class LDSymbol;
34 class LinkerConfig;
35 class Module;
36 class ObjectBuilder;
37 class ObjectReader;
38 class ObjectWriter;
39 class Relocator;
40 class ResolveInfo;
41 class SectionData;
42 class SectionReachedListMap;
43 class StubFactory;
44 
45 //===----------------------------------------------------------------------===//
46 /// TargetLDBackend - Generic interface to target specific assembler backends.
47 //===----------------------------------------------------------------------===//
48 class TargetLDBackend {
49  public:
50   typedef llvm::iplist<Relocation, GCFactoryListTraits<Relocation> >
51       ExtraRelocList;
52   typedef ExtraRelocList::iterator extra_reloc_iterator;
53 
54  protected:
55   explicit TargetLDBackend(const LinkerConfig& pConfig);
56 
57  public:
58   virtual ~TargetLDBackend();
59 
60   // -----  target dependent  ----- //
initTargetSegments(IRBuilder & pBuilder)61   virtual void initTargetSegments(IRBuilder& pBuilder) {}
initTargetSections(Module & pModule,ObjectBuilder & pBuilder)62   virtual void initTargetSections(Module& pModule, ObjectBuilder& pBuilder) {}
initTargetSymbols(IRBuilder & pBuilder,Module & pModule)63   virtual void initTargetSymbols(IRBuilder& pBuilder, Module& pModule) {}
initTargetRelocation(IRBuilder & pBuilder)64   virtual void initTargetRelocation(IRBuilder& pBuilder) {}
65   virtual bool initStandardSymbols(IRBuilder& pBuilder, Module& pModule) = 0;
66 
67   virtual bool initRelocator() = 0;
68 
69   virtual Relocator* getRelocator() = 0;
70   virtual const Relocator* getRelocator() const = 0;
71 
72   // -----  format dependent  ----- //
73   virtual ArchiveReader* createArchiveReader(Module&) = 0;
74   virtual ObjectReader* createObjectReader(IRBuilder&) = 0;
75   virtual DynObjReader* createDynObjReader(IRBuilder&) = 0;
76   virtual BinaryReader* createBinaryReader(IRBuilder&) = 0;
77   virtual ObjectWriter* createWriter() = 0;
78 
79   virtual bool initStdSections(ObjectBuilder& pBuilder) = 0;
80 
81   /// layout - layout method
82   virtual void layout(Module& pModule) = 0;
83 
84   /// preLayout - Backend can do any needed modification before layout
85   virtual void preLayout(Module& pModule, IRBuilder& pBuilder) = 0;
86 
87   /// postLayout - Backend can do any needed modification after layout
88   virtual void postLayout(Module& pModule, IRBuilder& pBuilder) = 0;
89 
90   /// postProcessing - Backend can do any needed modification in the final stage
91   virtual void postProcessing(FileOutputBuffer& pOutput) = 0;
92 
93   /// section start offset in the output file
94   virtual size_t sectionStartOffset() const = 0;
95 
96   /// computeSectionOrder - compute the layout order of the given section
97   virtual unsigned int getSectionOrder(const LDSection& pSectHdr) const = 0;
98 
99   /// sizeNamePools - compute the size of regular name pools
100   /// In ELF executable files, regular name pools are .symtab, .strtab.,
101   /// .dynsym, .dynstr, and .hash
102   virtual void sizeNamePools(Module& pModule) = 0;
103 
104   /// finalizeSymbol - Linker checks pSymbol.reserved() if it's not zero,
105   /// then it will ask backend to finalize the symbol value.
106   /// @return ture - if backend set the symbol value sucessfully
107   /// @return false - if backend do not recognize the symbol
108   virtual bool finalizeSymbols() = 0;
109 
110   /// finalizeTLSSymbol - Linker asks backend to set the symbol value when it
111   /// meets a TLS symbol
112   virtual bool finalizeTLSSymbol(LDSymbol& pSymbol) = 0;
113 
114   /// allocateCommonSymbols - allocate common symbols in the corresponding
115   /// sections.
116   virtual bool allocateCommonSymbols(Module& pModule) = 0;
117 
118   /// preMergeSections - hooks to be executed before merging sections
preMergeSections(Module & pModule)119   virtual void preMergeSections(Module& pModule) { }
120 
121   /// postMergeSections - hooks to be executed after merging sections
postMergeSections(Module & pModule)122   virtual void postMergeSections(Module& pModule) { }
123 
124   /// mergeSection - merge target dependent sections.
mergeSection(Module & pModule,const Input & pInputFile,LDSection & pInputSection)125   virtual bool mergeSection(Module& pModule,
126                             const Input& pInputFile,
127                             LDSection& pInputSection) {
128     return true;
129   }
130 
131   /// setUpReachedSectionsForGC - set the reference between two sections for
132   /// some special target sections. GC will set up the reference for the Regular
133   /// and BSS sections. Backends can also set up the reference if need.
setUpReachedSectionsForGC(const Module & pModule,GarbageCollection::SectionReachedListMap & pSectReachedListMap)134   virtual void setUpReachedSectionsForGC(
135       const Module& pModule,
136       GarbageCollection::SectionReachedListMap& pSectReachedListMap) const {}
137 
138   /// updateSectionFlags - update pTo's flags when merging pFrom
139   /// update the output section flags based on input section flags.
140   /// FIXME: (Luba) I know ELF need to merge flags, but I'm not sure if
141   /// MachO and COFF also need this.
updateSectionFlags(LDSection & pTo,const LDSection & pFrom)142   virtual bool updateSectionFlags(LDSection& pTo, const LDSection& pFrom) {
143     return true;
144   }
145 
146   /// readSection - read a target dependent section
readSection(Input & pInput,SectionData & pSD)147   virtual bool readSection(Input& pInput, SectionData& pSD) { return true; }
148 
149   /// sizeInterp - compute the size of program interpreter's name
150   /// In ELF executables, this is the length of dynamic linker's path name
151   virtual void sizeInterp() = 0;
152 
153   /// getEntry - get the entry point name
154   virtual llvm::StringRef getEntry(const Module& pModule) const = 0;
155 
156   // -----  relaxation  ----- //
157   virtual bool initBRIslandFactory() = 0;
158   virtual bool initStubFactory() = 0;
initTargetStubs()159   virtual bool initTargetStubs() { return true; }
160 
161   virtual BranchIslandFactory* getBRIslandFactory() = 0;
162   virtual StubFactory* getStubFactory() = 0;
163 
164   /// relax - the relaxation pass
165   virtual bool relax(Module& pModule, IRBuilder& pBuilder) = 0;
166 
167   /// mayRelax - return true if the backend needs to do relaxation
168   virtual bool mayRelax() = 0;
169 
170   /// commonPageSize - the common page size of the target machine
171   virtual uint64_t commonPageSize() const = 0;
172 
173   /// abiPageSize - the abi page size of the target machine
174   virtual uint64_t abiPageSize() const = 0;
175 
176   /// sortRelocation - sort the dynamic relocations to let dynamic linker
177   /// process relocations more efficiently
178   virtual void sortRelocation(LDSection& pSection) = 0;
179 
180   /// createAndSizeEhFrameHdr - This is seperated since we may add eh_frame
181   /// entry in the middle
182   virtual void createAndSizeEhFrameHdr(Module& pModule) = 0;
183 
184   /// isSymbolPreemptible - whether the symbol can be preemted by other link
185   /// units
186   virtual bool isSymbolPreemptible(const ResolveInfo& pSym) const = 0;
187 
188   /// mayHaveUnsafeFunctionPointerAccess - check if the section may have unsafe
189   /// function pointer access
190   virtual bool mayHaveUnsafeFunctionPointerAccess(
191       const LDSection& pSection) const = 0;
192 
extra_reloc_begin()193   extra_reloc_iterator extra_reloc_begin() {
194     return m_ExtraReloc.begin();
195   }
196 
extra_reloc_end()197   extra_reloc_iterator extra_reloc_end() {
198     return m_ExtraReloc.end();
199   }
200 
201  protected:
config()202   const LinkerConfig& config() const { return m_Config; }
203 
204   /// addExtraRelocation - Add an extra relocation which are automatically
205   /// generated by the LD backend.
addExtraRelocation(Relocation * reloc)206   void addExtraRelocation(Relocation* reloc) {
207     m_ExtraReloc.push_back(reloc);
208   }
209 
210  private:
211   const LinkerConfig& m_Config;
212 
213   /// m_ExtraReloc - Extra relocations that are automatically generated by the
214   /// linker.
215   ExtraRelocList m_ExtraReloc;
216 
217  private:
218   DISALLOW_COPY_AND_ASSIGN(TargetLDBackend);
219 };
220 
221 }  // namespace mcld
222 
223 #endif  // MCLD_TARGET_TARGETLDBACKEND_H_
224