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