• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1  //===- Linker.cpp ---------------------------------------------------------===//
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  #include "mcld/Linker.h"
10  
11  #include "mcld/IRBuilder.h"
12  #include "mcld/LinkerConfig.h"
13  #include "mcld/Module.h"
14  #include "mcld/Fragment/FragmentRef.h"
15  #include "mcld/Fragment/Relocation.h"
16  #include "mcld/LD/LDSection.h"
17  #include "mcld/LD/LDSymbol.h"
18  #include "mcld/LD/ObjectWriter.h"
19  #include "mcld/LD/RelocData.h"
20  #include "mcld/LD/SectionData.h"
21  #include "mcld/MC/InputBuilder.h"
22  #include "mcld/Object/ObjectLinker.h"
23  #include "mcld/Support/FileHandle.h"
24  #include "mcld/Support/FileOutputBuffer.h"
25  #include "mcld/Support/MsgHandling.h"
26  #include "mcld/Support/TargetRegistry.h"
27  #include "mcld/Support/raw_ostream.h"
28  #include "mcld/Target/TargetLDBackend.h"
29  
30  #include <cassert>
31  
32  namespace mcld {
33  
Linker()34  Linker::Linker()
35      : m_pConfig(NULL),
36        m_pIRBuilder(NULL),
37        m_pTarget(NULL),
38        m_pBackend(NULL),
39        m_pObjLinker(NULL) {
40  }
41  
~Linker()42  Linker::~Linker() {
43    reset();
44  }
45  
46  /// emulate - To set up target-dependent options and default linker script.
47  /// Follow GNU ld quirks.
emulate(LinkerScript & pScript,LinkerConfig & pConfig)48  bool Linker::emulate(LinkerScript& pScript, LinkerConfig& pConfig) {
49    m_pConfig = &pConfig;
50  
51    if (!initTarget())
52      return false;
53  
54    if (!initBackend())
55      return false;
56  
57    if (!initOStream())
58      return false;
59  
60    if (!initEmulator(pScript))
61      return false;
62  
63    return true;
64  }
65  
link(Module & pModule,IRBuilder & pBuilder)66  bool Linker::link(Module& pModule, IRBuilder& pBuilder) {
67    if (!normalize(pModule, pBuilder))
68      return false;
69  
70    if (!resolve(pModule))
71      return false;
72  
73    return layout();
74  }
75  
76  /// normalize - to convert the command line language to the input tree.
normalize(Module & pModule,IRBuilder & pBuilder)77  bool Linker::normalize(Module& pModule, IRBuilder& pBuilder) {
78    assert(m_pConfig != NULL);
79  
80    m_pIRBuilder = &pBuilder;
81  
82    m_pObjLinker = new ObjectLinker(*m_pConfig, *m_pBackend);
83  
84    // 2. - initialize ObjectLinker
85    if (!m_pObjLinker->initialize(pModule, pBuilder))
86      return false;
87  
88    // 3. - initialize output's standard sections
89    if (!m_pObjLinker->initStdSections())
90      return false;
91  
92    if (!Diagnose())
93      return false;
94  
95    // 4.a - add undefined symbols
96    //   before reading the inputs, we should add undefined symbols set by -u to
97    //   ensure that correspoding objects (e.g. in an archive) will be included
98    m_pObjLinker->addUndefinedSymbols();
99  
100    // 4.b - normalize the input tree
101    //   read out sections and symbol/string tables (from the files) and
102    //   set them in Module. When reading out the symbol, resolve their symbols
103    //   immediately and set their ResolveInfo (i.e., Symbol Resolution).
104    m_pObjLinker->normalize();
105  
106    if (m_pConfig->options().trace()) {
107      static int counter = 0;
108      mcld::outs() << "** name\ttype\tpath\tsize ("
109                   << pModule.getInputTree().size() << ")\n";
110  
111      InputTree::const_dfs_iterator input,
112          inEnd = pModule.getInputTree().dfs_end();
113      for (input = pModule.getInputTree().dfs_begin(); input != inEnd; ++input) {
114        mcld::outs() << counter++ << " *  " << (*input)->name();
115        switch ((*input)->type()) {
116          case Input::Archive:
117            mcld::outs() << "\tarchive\t(";
118            break;
119          case Input::Object:
120            mcld::outs() << "\tobject\t(";
121            break;
122          case Input::DynObj:
123            mcld::outs() << "\tshared\t(";
124            break;
125          case Input::Script:
126            mcld::outs() << "\tscript\t(";
127            break;
128          case Input::External:
129            mcld::outs() << "\textern\t(";
130            break;
131          default:
132            unreachable(diag::err_cannot_trace_file)
133                << (*input)->type() << (*input)->name() << (*input)->path();
134        }
135        mcld::outs() << (*input)->path() << ")\n";
136      }
137    }
138  
139    // 5. - set up code position
140    if (LinkerConfig::DynObj == m_pConfig->codeGenType() ||
141        m_pConfig->options().isPIE()) {
142      m_pConfig->setCodePosition(LinkerConfig::Independent);
143    } else if (pModule.getLibraryList().empty()) {
144      // If the output is dependent on its loaded address, and it does not need
145      // to call outside functions, then we can treat the output static dependent
146      // and perform better optimizations.
147      m_pConfig->setCodePosition(LinkerConfig::StaticDependent);
148  
149      if (LinkerConfig::Exec == m_pConfig->codeGenType()) {
150        // Since the output is static dependent, there should not have any
151        // undefined
152        // references in the output module.
153        m_pConfig->options().setNoUndefined();
154      }
155    } else {
156      m_pConfig->setCodePosition(LinkerConfig::DynamicDependent);
157    }
158  
159    if (!m_pObjLinker->linkable())
160      return Diagnose();
161  
162    return true;
163  }
164  
resolve(Module & pModule)165  bool Linker::resolve(Module& pModule) {
166    assert(m_pConfig != NULL);
167    assert(m_pObjLinker != NULL);
168  
169    // 6. - read all relocation entries from input files
170    //   For all relocation sections of each input file (in the tree),
171    //   read out reloc entry info from the object file and accordingly
172    //   initiate their reloc entries in SectOrRelocData of LDSection.
173    //
174    //   To collect all edges in the reference graph.
175    m_pObjLinker->readRelocations();
176  
177    // 7. - data stripping optimizations
178    m_pObjLinker->dataStrippingOpt();
179  
180    // 8. - merge all sections
181    //   Push sections into Module's SectionTable.
182    //   Merge sections that have the same name.
183    //   Maintain them as fragments in the section.
184    //
185    //   To merge nodes of the reference graph.
186    if (!m_pObjLinker->mergeSections())
187      return false;
188  
189    // 9.a - add symbols to output
190    //  After all input symbols have been resolved, add them to output symbol
191    //  table at once
192    m_pObjLinker->addSymbolsToOutput(pModule);
193  
194    // 9.b - allocateCommonSymbols
195    //   Allocate fragments for common symbols to the corresponding sections.
196    if (!m_pObjLinker->allocateCommonSymbols())
197      return false;
198  
199    return true;
200  }
201  
layout()202  bool Linker::layout() {
203    assert(m_pConfig != NULL && m_pObjLinker != NULL);
204  
205    // 10. - add standard symbols, target-dependent symbols and script symbols
206    if (!m_pObjLinker->addStandardSymbols() ||
207        !m_pObjLinker->addTargetSymbols() || !m_pObjLinker->addScriptSymbols())
208      return false;
209  
210    // 11. - scan all relocation entries by output symbols.
211    //   reserve GOT space for layout.
212    //   the space info is needed by pre-layout to compute the section size
213    m_pObjLinker->scanRelocations();
214  
215    // 12.a - init relaxation stuff.
216    m_pObjLinker->initStubs();
217  
218    // 12.b - pre-layout
219    m_pObjLinker->prelayout();
220  
221    // 12.c - linear layout
222    //   Decide which sections will be left in. Sort the sections according to
223    //   a given order. Then, create program header accordingly.
224    //   Finally, set the offset for sections (@ref LDSection)
225    //   according to the new order.
226    m_pObjLinker->layout();
227  
228    // 12.d - post-layout (create segment, instruction relaxing)
229    m_pObjLinker->postlayout();
230  
231    // 13. - finalize symbol value
232    m_pObjLinker->finalizeSymbolValue();
233  
234    // 14. - apply relocations
235    m_pObjLinker->relocation();
236  
237    if (!Diagnose())
238      return false;
239    return true;
240  }
241  
emit(FileOutputBuffer & pOutput)242  bool Linker::emit(FileOutputBuffer& pOutput) {
243    // 15. - write out output
244    m_pObjLinker->emitOutput(pOutput);
245  
246    // 16. - post processing
247    m_pObjLinker->postProcessing(pOutput);
248  
249    if (!Diagnose())
250      return false;
251  
252    return true;
253  }
254  
emit(const Module & pModule,const std::string & pPath)255  bool Linker::emit(const Module& pModule, const std::string& pPath) {
256    FileHandle file;
257    FileHandle::OpenMode open_mode(
258        FileHandle::ReadWrite | FileHandle::Truncate | FileHandle::Create);
259    FileHandle::Permission permission;
260    switch (m_pConfig->codeGenType()) {
261      case mcld::LinkerConfig::Unknown:
262      case mcld::LinkerConfig::Object:
263        permission = FileHandle::Permission(0x644);
264        break;
265      case mcld::LinkerConfig::DynObj:
266      case mcld::LinkerConfig::Exec:
267      case mcld::LinkerConfig::Binary:
268        permission = FileHandle::Permission(0x755);
269        break;
270      default:
271        assert(0 && "Unknown file type");
272    }
273  
274    bool result = file.open(sys::fs::Path(pPath), open_mode, permission);
275    if (!result) {
276      error(diag::err_cannot_open_output_file) << "Linker::emit()" << pPath;
277      return false;
278    }
279  
280    std::unique_ptr<FileOutputBuffer> output;
281    FileOutputBuffer::create(
282        file, m_pObjLinker->getWriter()->getOutputSize(pModule), output);
283  
284    result = emit(*output);
285    file.close();
286    return result;
287  }
288  
emit(const Module & pModule,int pFileDescriptor)289  bool Linker::emit(const Module& pModule, int pFileDescriptor) {
290    FileHandle file;
291    file.delegate(pFileDescriptor);
292  
293    std::unique_ptr<FileOutputBuffer> output;
294    FileOutputBuffer::create(
295        file, m_pObjLinker->getWriter()->getOutputSize(pModule), output);
296  
297    return emit(*output);
298  }
299  
reset()300  bool Linker::reset() {
301    m_pConfig = NULL;
302    m_pIRBuilder = NULL;
303    m_pTarget = NULL;
304  
305    // Because llvm::iplist will touch the removed node, we must clear
306    // RelocData before deleting target backend.
307    RelocData::Clear();
308    SectionData::Clear();
309    EhFrame::Clear();
310  
311    delete m_pBackend;
312    m_pBackend = NULL;
313  
314    delete m_pObjLinker;
315    m_pObjLinker = NULL;
316  
317    LDSection::Clear();
318    LDSymbol::Clear();
319    FragmentRef::Clear();
320    Relocation::Clear();
321    return true;
322  }
323  
initTarget()324  bool Linker::initTarget() {
325    assert(m_pConfig != NULL);
326  
327    std::string error;
328    llvm::Triple triple(m_pConfig->targets().triple());
329  
330    m_pTarget = mcld::TargetRegistry::lookupTarget(
331        m_pConfig->targets().getArch(), triple, error);
332    m_pConfig->targets().setTriple(triple);
333  
334    if (m_pTarget == NULL) {
335      fatal(diag::fatal_cannot_init_target) << triple.str() << error;
336      return false;
337    }
338    return true;
339  }
340  
initBackend()341  bool Linker::initBackend() {
342    assert(m_pTarget != NULL);
343    m_pBackend = m_pTarget->createLDBackend(*m_pConfig);
344    if (m_pBackend == NULL) {
345      fatal(diag::fatal_cannot_init_backend)
346          << m_pConfig->targets().triple().str();
347      return false;
348    }
349    return true;
350  }
351  
initOStream()352  bool Linker::initOStream() {
353    assert(m_pConfig != NULL);
354  
355    mcld::outs().setColor(m_pConfig->options().color());
356    mcld::errs().setColor(m_pConfig->options().color());
357  
358    return true;
359  }
360  
initEmulator(LinkerScript & pScript)361  bool Linker::initEmulator(LinkerScript& pScript) {
362    assert(m_pTarget != NULL && m_pConfig != NULL);
363    return m_pTarget->emulate(pScript, *m_pConfig);
364  }
365  
366  }  // namespace mcld
367