1 //===- ObjectLinker.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/Object/ObjectLinker.h>
10
11 #include <mcld/LinkerConfig.h>
12 #include <mcld/LinkerScript.h>
13 #include <mcld/Module.h>
14 #include <mcld/InputTree.h>
15 #include <mcld/IRBuilder.h>
16 #include <mcld/LD/LDSection.h>
17 #include <mcld/LD/LDContext.h>
18 #include <mcld/LD/Archive.h>
19 #include <mcld/LD/ArchiveReader.h>
20 #include <mcld/LD/ObjectReader.h>
21 #include <mcld/LD/DynObjReader.h>
22 #include <mcld/LD/GroupReader.h>
23 #include <mcld/LD/BinaryReader.h>
24 #include <mcld/LD/GarbageCollection.h>
25 #include <mcld/LD/IdenticalCodeFolding.h>
26 #include <mcld/LD/ObjectWriter.h>
27 #include <mcld/LD/ResolveInfo.h>
28 #include <mcld/LD/RelocData.h>
29 #include <mcld/LD/Relocator.h>
30 #include <mcld/LD/SectionData.h>
31 #include <mcld/LD/BranchIslandFactory.h>
32 #include <mcld/Script/ScriptFile.h>
33 #include <mcld/Script/ScriptReader.h>
34 #include <mcld/Script/Assignment.h>
35 #include <mcld/Script/Operand.h>
36 #include <mcld/Script/RpnEvaluator.h>
37 #include <mcld/Support/RealPath.h>
38 #include <mcld/Support/FileOutputBuffer.h>
39 #include <mcld/Support/MsgHandling.h>
40 #include <mcld/Target/TargetLDBackend.h>
41 #include <mcld/Fragment/Relocation.h>
42 #include <mcld/Object/ObjectBuilder.h>
43
44 #include <llvm/Support/Casting.h>
45 #include <llvm/Support/Host.h>
46 #include <system_error>
47
48 using namespace llvm;
49 using namespace mcld;
50
51 //===----------------------------------------------------------------------===//
52 // ObjectLinker
53 //===----------------------------------------------------------------------===//
ObjectLinker(const LinkerConfig & pConfig,TargetLDBackend & pLDBackend)54 ObjectLinker::ObjectLinker(const LinkerConfig& pConfig,
55 TargetLDBackend& pLDBackend)
56 : m_Config(pConfig),
57 m_pModule(NULL),
58 m_pBuilder(NULL),
59 m_LDBackend(pLDBackend),
60 m_pObjectReader(NULL),
61 m_pDynObjReader(NULL),
62 m_pArchiveReader(NULL),
63 m_pGroupReader(NULL),
64 m_pBinaryReader(NULL),
65 m_pScriptReader(NULL),
66 m_pWriter(NULL) {
67 }
68
~ObjectLinker()69 ObjectLinker::~ObjectLinker()
70 {
71 delete m_pObjectReader;
72 delete m_pDynObjReader;
73 delete m_pArchiveReader;
74 delete m_pGroupReader;
75 delete m_pBinaryReader;
76 delete m_pScriptReader;
77 delete m_pWriter;
78 }
79
initialize(Module & pModule,IRBuilder & pBuilder)80 bool ObjectLinker::initialize(Module& pModule, IRBuilder& pBuilder)
81 {
82 m_pModule = &pModule;
83 m_pBuilder = &pBuilder;
84
85 // initialize the readers and writers
86 m_pObjectReader = m_LDBackend.createObjectReader(*m_pBuilder);
87 m_pArchiveReader = m_LDBackend.createArchiveReader(*m_pModule);
88 m_pDynObjReader = m_LDBackend.createDynObjReader(*m_pBuilder);
89 m_pBinaryReader = m_LDBackend.createBinaryReader(*m_pBuilder);
90 m_pGroupReader = new GroupReader(*m_pModule, *m_pObjectReader,
91 *m_pDynObjReader, *m_pArchiveReader, *m_pBinaryReader);
92 m_pScriptReader = new ScriptReader(*m_pGroupReader);
93 m_pWriter = m_LDBackend.createWriter();
94
95 // initialize Relocator
96 m_LDBackend.initRelocator();
97
98 return true;
99 }
100
101 /// initStdSections - initialize standard sections
initStdSections()102 bool ObjectLinker::initStdSections()
103 {
104 ObjectBuilder builder(*m_pModule);
105
106 // initialize standard sections
107 if (!m_LDBackend.initStdSections(builder))
108 return false;
109
110 // initialize target-dependent sections
111 m_LDBackend.initTargetSections(*m_pModule, builder);
112
113 return true;
114 }
115
addUndefinedSymbols()116 void ObjectLinker::addUndefinedSymbols()
117 {
118 // Add the symbol set by -u as an undefind global symbol into symbol pool
119 GeneralOptions::const_undef_sym_iterator usym;
120 GeneralOptions::const_undef_sym_iterator usymEnd =
121 m_Config.options().undef_sym_end();
122 for (usym = m_Config.options().undef_sym_begin(); usym != usymEnd; ++usym) {
123 Resolver::Result result;
124 m_pModule->getNamePool().insertSymbol(*usym, // name
125 false, // isDyn
126 ResolveInfo::NoType,
127 ResolveInfo::Undefined,
128 ResolveInfo::Global,
129 0x0, // size
130 0x0, // value
131 ResolveInfo::Default,
132 NULL,
133 result);
134
135 LDSymbol* output_sym = result.info->outSymbol();
136 bool has_output_sym = (NULL != output_sym);
137
138 // create the output symbol if it dose not have one
139 if (!result.existent || !has_output_sym) {
140 output_sym = LDSymbol::Create(*result.info);
141 result.info->setSymPtr(output_sym);
142 output_sym->setFragmentRef(FragmentRef::Null());
143 }
144 }
145 }
146
normalize()147 void ObjectLinker::normalize()
148 {
149 // ----- set up inputs ----- //
150 Module::input_iterator input, inEnd = m_pModule->input_end();
151 for (input = m_pModule->input_begin(); input!=inEnd; ++input) {
152 // is a group node
153 if (isGroup(input)) {
154 getGroupReader()->readGroup(input, inEnd, m_pBuilder->getInputBuilder(),
155 m_Config);
156 continue;
157 }
158
159 // already got type - for example, bitcode or external OIR (object
160 // intermediate representation)
161 if ((*input)->type() == Input::Script ||
162 (*input)->type() == Input::Archive ||
163 (*input)->type() == Input::External)
164 continue;
165
166 if (Input::Object == (*input)->type()) {
167 m_pModule->getObjectList().push_back(*input);
168 continue;
169 }
170
171 if (Input::DynObj == (*input)->type()) {
172 m_pModule->getLibraryList().push_back(*input);
173 continue;
174 }
175
176 bool doContinue = false;
177 // read input as a binary file
178 if (getBinaryReader()->isMyFormat(**input, doContinue)) {
179 (*input)->setType(Input::Object);
180 getBinaryReader()->readBinary(**input);
181 m_pModule->getObjectList().push_back(*input);
182 }
183 // is a relocatable object file
184 else if (doContinue && getObjectReader()->isMyFormat(**input, doContinue)) {
185 (*input)->setType(Input::Object);
186 getObjectReader()->readHeader(**input);
187 getObjectReader()->readSections(**input);
188 getObjectReader()->readSymbols(**input);
189 m_pModule->getObjectList().push_back(*input);
190 }
191 // is a shared object file
192 else if (doContinue && getDynObjReader()->isMyFormat(**input, doContinue)) {
193 (*input)->setType(Input::DynObj);
194 getDynObjReader()->readHeader(**input);
195 getDynObjReader()->readSymbols(**input);
196 m_pModule->getLibraryList().push_back(*input);
197 }
198 // is an archive
199 else if (doContinue && getArchiveReader()->isMyFormat(**input, doContinue)) {
200 (*input)->setType(Input::Archive);
201 if (m_Config.options().isInExcludeLIBS(**input)) {
202 (*input)->setNoExport();
203 }
204 Archive archive(**input, m_pBuilder->getInputBuilder());
205 getArchiveReader()->readArchive(m_Config, archive);
206 if(archive.numOfObjectMember() > 0) {
207 m_pModule->getInputTree().merge<InputTree::Inclusive>(input,
208 archive.inputs());
209 }
210 }
211 // try to parse input as a linker script
212 else if (doContinue && getScriptReader()->isMyFormat(**input, doContinue)) {
213 ScriptFile script(ScriptFile::LDScript, **input,
214 m_pBuilder->getInputBuilder());
215 if (getScriptReader()->readScript(m_Config, script)) {
216 (*input)->setType(Input::Script);
217 script.activate(*m_pModule);
218 if (script.inputs().size() > 0) {
219 m_pModule->getInputTree().merge<InputTree::Inclusive>(input,
220 script.inputs());
221 }
222 }
223 }
224 else {
225 if (m_Config.options().warnMismatch())
226 warning(diag::warn_unrecognized_input_file) << (*input)->path()
227 << m_Config.targets().triple().str();
228 }
229 } // end of for
230 }
231
linkable() const232 bool ObjectLinker::linkable() const
233 {
234 // check we have input and output files
235 if (m_pModule->getInputTree().empty()) {
236 error(diag::err_no_inputs);
237 return false;
238 }
239
240 // can not mix -static with shared objects
241 Module::const_lib_iterator lib, libEnd = m_pModule->lib_end();
242 for (lib = m_pModule->lib_begin(); lib != libEnd; ++lib) {
243 if((*lib)->attribute()->isStatic()) {
244 error(diag::err_mixed_shared_static_objects)
245 << (*lib)->name() << (*lib)->path();
246 return false;
247 }
248 }
249
250 // --nmagic and --omagic options lead to static executable program.
251 // These options turn off page alignment of sections. Because the
252 // sections are not aligned to pages, these sections can not contain any
253 // exported functions. Also, because the two options disable linking
254 // against shared libraries, the output absolutely does not call outside
255 // functions.
256 if (m_Config.options().nmagic() && !m_Config.isCodeStatic()) {
257 error(diag::err_nmagic_not_static);
258 return false;
259 }
260 if (m_Config.options().omagic() && !m_Config.isCodeStatic()) {
261 error(diag::err_omagic_not_static);
262 return false;
263 }
264
265 return true;
266 }
267
dataStrippingOpt()268 void ObjectLinker::dataStrippingOpt()
269 {
270 // Garbege collection
271 if (m_Config.options().GCSections()) {
272 GarbageCollection GC(m_Config, m_LDBackend, *m_pModule);
273 GC.run();
274 }
275
276 // Identical code folding
277 if (m_Config.options().getICFMode() != GeneralOptions::ICF_None) {
278 IdenticalCodeFolding icf(m_Config, m_LDBackend, *m_pModule);
279 icf.foldIdenticalCode();
280 }
281 return;
282 }
283
284 /// readRelocations - read all relocation entries
285 ///
286 /// All symbols should be read and resolved before this function.
readRelocations()287 bool ObjectLinker::readRelocations()
288 {
289 // Bitcode is read by the other path. This function reads relocation sections
290 // in object files.
291 mcld::InputTree::bfs_iterator input, inEnd = m_pModule->getInputTree().bfs_end();
292 for (input=m_pModule->getInputTree().bfs_begin(); input!=inEnd; ++input) {
293 if ((*input)->type() == Input::Object && (*input)->hasMemArea()) {
294 if (!getObjectReader()->readRelocations(**input))
295 return false;
296 }
297 // ignore the other kinds of files.
298 }
299 return true;
300 }
301
302 /// mergeSections - put allinput sections into output sections
mergeSections()303 bool ObjectLinker::mergeSections()
304 {
305 ObjectBuilder builder(*m_pModule);
306 Module::obj_iterator obj, objEnd = m_pModule->obj_end();
307 for (obj = m_pModule->obj_begin(); obj != objEnd; ++obj) {
308 LDContext::sect_iterator sect, sectEnd = (*obj)->context()->sectEnd();
309 for (sect = (*obj)->context()->sectBegin(); sect != sectEnd; ++sect) {
310 switch ((*sect)->kind()) {
311 // Some *INPUT sections should not be merged.
312 case LDFileFormat::Folded:
313 case LDFileFormat::Ignore:
314 case LDFileFormat::Null:
315 case LDFileFormat::NamePool:
316 case LDFileFormat::Group:
317 case LDFileFormat::StackNote:
318 // skip
319 continue;
320 case LDFileFormat::Relocation: {
321 if (!(*sect)->hasRelocData())
322 continue; // skip
323
324 if ((*sect)->getLink()->kind() == LDFileFormat::Ignore ||
325 (*sect)->getLink()->kind() == LDFileFormat::Folded)
326 (*sect)->setKind(LDFileFormat::Ignore);
327 break;
328 }
329 case LDFileFormat::Target:
330 if (!m_LDBackend.mergeSection(*m_pModule, **obj, **sect)) {
331 error(diag::err_cannot_merge_section) << (*sect)->name()
332 << (*obj)->name();
333 return false;
334 }
335 break;
336 case LDFileFormat::EhFrame: {
337 if (!(*sect)->hasEhFrame())
338 continue; // skip
339
340 LDSection* out_sect = NULL;
341 if (NULL != (out_sect = builder.MergeSection(**obj, **sect))) {
342 if (!m_LDBackend.updateSectionFlags(*out_sect, **sect)) {
343 error(diag::err_cannot_merge_section) << (*sect)->name()
344 << (*obj)->name();
345 return false;
346 }
347 }
348 break;
349 }
350 default: {
351 if (!(*sect)->hasSectionData())
352 continue; // skip
353
354 LDSection* out_sect = NULL;
355 if (NULL != (out_sect = builder.MergeSection(**obj, **sect))) {
356 if (!m_LDBackend.updateSectionFlags(*out_sect, **sect)) {
357 error(diag::err_cannot_merge_section) << (*sect)->name()
358 << (*obj)->name();
359 return false;
360 }
361 }
362 break;
363 }
364 } // end of switch
365 } // for each section
366 } // for each obj
367
368 RpnEvaluator evaluator(*m_pModule, m_LDBackend);
369 SectionMap::iterator out, outBegin, outEnd;
370 outBegin = m_pModule->getScript().sectionMap().begin();
371 outEnd = m_pModule->getScript().sectionMap().end();
372 for (out = outBegin; out != outEnd; ++out) {
373 uint64_t out_align = 0x0, in_align = 0x0;
374 LDSection* out_sect = (*out)->getSection();
375 SectionMap::Output::iterator in, inBegin, inEnd;
376 inBegin = (*out)->begin();
377 inEnd = (*out)->end();
378
379 // force input alignment from ldscript if any
380 if ((*out)->prolog().hasSubAlign()) {
381 evaluator.eval((*out)->prolog().subAlign(), in_align);
382 }
383
384 for (in = inBegin; in != inEnd; ++in) {
385 LDSection* in_sect = (*in)->getSection();
386 if ((*out)->prolog().hasSubAlign())
387 in_sect->setAlign(in_align);
388
389 if (builder.MoveSectionData(*in_sect->getSectionData(),
390 *out_sect->getSectionData())) {
391 builder.UpdateSectionAlign(*out_sect, *in_sect);
392 m_LDBackend.updateSectionFlags(*out_sect, *in_sect);
393 }
394 } // for each input section description
395
396 // force output alignment from ldscript if any
397 if ((*out)->prolog().hasAlign()) {
398 evaluator.eval((*out)->prolog().align(), out_align);
399 out_sect->setAlign(out_align);
400 }
401
402 if ((*out)->hasContent()) {
403 LDSection* target = m_pModule->getSection((*out)->name());
404 assert(target != NULL && target->hasSectionData());
405 if (builder.MoveSectionData(*out_sect->getSectionData(),
406 *target->getSectionData())) {
407 builder.UpdateSectionAlign(*target, *out_sect);
408 m_LDBackend.updateSectionFlags(*target, *out_sect);
409 }
410 }
411 } // for each output section description
412
413 return true;
414 }
415
addSymbolToOutput(ResolveInfo & pInfo,Module & pModule)416 void ObjectLinker::addSymbolToOutput(ResolveInfo& pInfo, Module& pModule)
417 {
418 // section symbols will be defined by linker later, we should not add section
419 // symbols to output here
420 if (ResolveInfo::Section == pInfo.type() || NULL == pInfo.outSymbol())
421 return;
422
423 // if the symbols defined in the Ignore sections (e.g. discared by GC), then
424 // not to put them to output
425 if (pInfo.outSymbol()->hasFragRef() && LDFileFormat::Ignore ==
426 pInfo.outSymbol()->fragRef()->frag()->getParent()->getSection().kind())
427 return;
428
429 if (pInfo.shouldForceLocal(m_Config))
430 pModule.getSymbolTable().forceLocal(*pInfo.outSymbol());
431 else
432 pModule.getSymbolTable().add(*pInfo.outSymbol());
433 }
434
addSymbolsToOutput(Module & pModule)435 void ObjectLinker::addSymbolsToOutput(Module& pModule)
436 {
437 // Traverse all the free ResolveInfo and add the output symobols to output
438 NamePool::freeinfo_iterator free_it,
439 free_end = pModule.getNamePool().freeinfo_end();
440 for (free_it = pModule.getNamePool().freeinfo_begin(); free_it != free_end;
441 ++free_it)
442 addSymbolToOutput(**free_it, pModule);
443
444
445 // Traverse all the resolveInfo and add the output symbol to output
446 NamePool::syminfo_iterator info_it,
447 info_end = pModule.getNamePool().syminfo_end();
448 for (info_it = pModule.getNamePool().syminfo_begin(); info_it != info_end;
449 ++info_it)
450 addSymbolToOutput(*info_it.getEntry(), pModule);
451 }
452
453
454 /// addStandardSymbols - shared object and executable files need some
455 /// standard symbols
456 /// @return if there are some input symbols with the same name to the
457 /// standard symbols, return false
addStandardSymbols()458 bool ObjectLinker::addStandardSymbols()
459 {
460 // create and add section symbols for each output section
461 Module::iterator iter, iterEnd = m_pModule->end();
462 for (iter = m_pModule->begin(); iter != iterEnd; ++iter) {
463 m_pModule->getSectionSymbolSet().add(**iter, m_pModule->getNamePool());
464 }
465
466 return m_LDBackend.initStandardSymbols(*m_pBuilder, *m_pModule);
467 }
468
469 /// addTargetSymbols - some targets, such as MIPS and ARM, need some
470 /// target-dependent symbols
471 /// @return if there are some input symbols with the same name to the
472 /// target symbols, return false
addTargetSymbols()473 bool ObjectLinker::addTargetSymbols()
474 {
475 m_LDBackend.initTargetSymbols(*m_pBuilder, *m_pModule);
476 return true;
477 }
478
479 /// addScriptSymbols - define symbols from the command line option or linker
480 /// scripts.
addScriptSymbols()481 bool ObjectLinker::addScriptSymbols()
482 {
483 LinkerScript& script = m_pModule->getScript();
484 LinkerScript::Assignments::iterator it, ie = script.assignments().end();
485 // go through the entire symbol assignments
486 for (it = script.assignments().begin(); it != ie; ++it) {
487 LDSymbol* symbol = NULL;
488 assert((*it).second.symbol().type() == Operand::SYMBOL);
489 const llvm::StringRef symName = (*it).second.symbol().name();
490 ResolveInfo::Type type = ResolveInfo::NoType;
491 ResolveInfo::Visibility vis = ResolveInfo::Default;
492 size_t size = 0;
493 ResolveInfo* old_info = m_pModule->getNamePool().findInfo(symName);
494 // if the symbol does not exist, we can set type to NOTYPE
495 // else we retain its type, same goes for size - 0 or retain old value
496 // and visibility - Default or retain
497 if (old_info != NULL) {
498 type = static_cast<ResolveInfo::Type>(old_info->type());
499 vis = old_info->visibility();
500 size = old_info->size();
501 }
502
503 // Add symbol and refine the visibility if needed
504 // FIXME: bfd linker would change the binding instead, but currently
505 // ABS is also a kind of Binding in ResolveInfo.
506 switch ((*it).second.type()) {
507 case Assignment::HIDDEN:
508 vis = ResolveInfo::Hidden;
509 // Fall through
510 case Assignment::DEFAULT:
511 symbol =
512 m_pBuilder->AddSymbol<IRBuilder::Force,
513 IRBuilder::Unresolve>(symName,
514 type,
515 ResolveInfo::Define,
516 ResolveInfo::Absolute,
517 size,
518 0x0,
519 FragmentRef::Null(),
520 vis);
521 break;
522 case Assignment::PROVIDE_HIDDEN:
523 vis = ResolveInfo::Hidden;
524 // Fall through
525 case Assignment::PROVIDE:
526 symbol =
527 m_pBuilder->AddSymbol<IRBuilder::AsReferred,
528 IRBuilder::Unresolve>(symName,
529 type,
530 ResolveInfo::Define,
531 ResolveInfo::Absolute,
532 size,
533 0x0,
534 FragmentRef::Null(),
535 vis);
536 break;
537 }
538 // Set symbol of this assignment.
539 (*it).first = symbol;
540 }
541 return true;
542 }
543
scanRelocations()544 bool ObjectLinker::scanRelocations()
545 {
546 // apply all relocations of all inputs
547 Module::obj_iterator input, inEnd = m_pModule->obj_end();
548 for (input = m_pModule->obj_begin(); input != inEnd; ++input) {
549 m_LDBackend.getRelocator()->initializeScan(**input);
550 LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
551 for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
552 // bypass the reloc section if
553 // 1. its section kind is changed to Ignore. (The target section is a
554 // discarded group section.)
555 // 2. it has no reloc data. (All symbols in the input relocs are in the
556 // discarded group sections)
557 if (LDFileFormat::Ignore == (*rs)->kind() || !(*rs)->hasRelocData())
558 continue;
559 RelocData::iterator reloc, rEnd = (*rs)->getRelocData()->end();
560 for (reloc = (*rs)->getRelocData()->begin(); reloc != rEnd; ++reloc) {
561 Relocation* relocation = llvm::cast<Relocation>(reloc);
562
563 // bypass the reloc if the symbol is in the discarded input section
564 ResolveInfo* info = relocation->symInfo();
565 if (!info->outSymbol()->hasFragRef() &&
566 ResolveInfo::Section == info->type() &&
567 ResolveInfo::Undefined == info->desc())
568 continue;
569
570 // scan relocation
571 if (LinkerConfig::Object != m_Config.codeGenType())
572 m_LDBackend.getRelocator()->scanRelocation(
573 *relocation, *m_pBuilder, *m_pModule, **rs, **input);
574 else
575 m_LDBackend.getRelocator()->partialScanRelocation(
576 *relocation, *m_pModule, **rs);
577 } // for all relocations
578 } // for all relocation section
579 m_LDBackend.getRelocator()->finalizeScan(**input);
580 } // for all inputs
581 return true;
582 }
583
584 /// initStubs - initialize stub-related stuff.
initStubs()585 bool ObjectLinker::initStubs()
586 {
587 // initialize BranchIslandFactory
588 m_LDBackend.initBRIslandFactory();
589
590 // initialize StubFactory
591 m_LDBackend.initStubFactory();
592
593 // initialize target stubs
594 m_LDBackend.initTargetStubs();
595 return true;
596 }
597
598 /// allocateCommonSymobols - allocate fragments for common symbols to the
599 /// corresponding sections
allocateCommonSymbols()600 bool ObjectLinker::allocateCommonSymbols()
601 {
602 if (LinkerConfig::Object != m_Config.codeGenType() ||
603 m_Config.options().isDefineCommon())
604 return m_LDBackend.allocateCommonSymbols(*m_pModule);
605 return true;
606 }
607
608 /// prelayout - help backend to do some modification before layout
prelayout()609 bool ObjectLinker::prelayout()
610 {
611 // finalize the section symbols, set their fragment reference and push them
612 // into output symbol table
613 Module::iterator sect, sEnd = m_pModule->end();
614 for (sect = m_pModule->begin(); sect != sEnd; ++sect) {
615 m_pModule->getSectionSymbolSet().finalize(**sect,
616 m_pModule->getSymbolTable(),
617 m_Config.codeGenType() == LinkerConfig::Object);
618 }
619
620 m_LDBackend.preLayout(*m_pModule, *m_pBuilder);
621
622 /// check program interpreter - computer the name size of the runtime dyld
623 if (!m_Config.isCodeStatic() &&
624 (LinkerConfig::Exec == m_Config.codeGenType() ||
625 m_Config.options().isPIE() ||
626 m_Config.options().hasDyld()))
627 m_LDBackend.sizeInterp();
628
629 /// measure NamePools - compute the size of name pool sections
630 /// In ELF, will compute the size of.symtab, .strtab, .dynsym, .dynstr,
631 /// .hash and .shstrtab sections.
632 ///
633 /// dump all symbols and strings from ObjectLinker and build the format-dependent
634 /// hash table.
635 /// @note sizeNamePools replies on LinkerConfig::CodePosition. Must determine
636 /// code position model before calling GNULDBackend::sizeNamePools()
637 m_LDBackend.sizeNamePools(*m_pModule);
638
639 // Do this after backend prelayout since it may add eh_frame entries.
640 LDSection* eh_frame_sect = m_pModule->getSection(".eh_frame");
641 if (eh_frame_sect && eh_frame_sect->hasEhFrame())
642 eh_frame_sect->getEhFrame()->computeOffsetSize();
643 m_LDBackend.createAndSizeEhFrameHdr(*m_pModule);
644
645 return true;
646 }
647
648 /// layout - linearly layout all output sections and reserve some space
649 /// for GOT/PLT
650 /// Because we do not support instruction relaxing in this early version,
651 /// if there is a branch can not jump to its target, we return false
652 /// directly
layout()653 bool ObjectLinker::layout()
654 {
655 m_LDBackend.layout(*m_pModule);
656 return true;
657 }
658
659 /// prelayout - help backend to do some modification after layout
postlayout()660 bool ObjectLinker::postlayout()
661 {
662 m_LDBackend.postLayout(*m_pModule, *m_pBuilder);
663 return true;
664 }
665
666 /// finalizeSymbolValue - finalize the resolved symbol value.
667 /// Before relocate(), after layout(), ObjectLinker should correct value of all
668 /// symbol.
finalizeSymbolValue()669 bool ObjectLinker::finalizeSymbolValue()
670 {
671 Module::sym_iterator symbol, symEnd = m_pModule->sym_end();
672 for (symbol = m_pModule->sym_begin(); symbol != symEnd; ++symbol) {
673
674 if ((*symbol)->resolveInfo()->isAbsolute() ||
675 (*symbol)->resolveInfo()->type() == ResolveInfo::File) {
676 // absolute symbols should just use its value directly (i.e., the result
677 // of symbol resolution)
678 continue;
679 }
680
681 if ((*symbol)->resolveInfo()->type() == ResolveInfo::ThreadLocal) {
682 m_LDBackend.finalizeTLSSymbol(**symbol);
683 continue;
684 }
685
686 if ((*symbol)->hasFragRef()) {
687 // set the virtual address of the symbol. If the output file is
688 // relocatable object file, the section's virtual address becomes zero.
689 // And the symbol's value become section relative offset.
690 uint64_t value = (*symbol)->fragRef()->getOutputOffset();
691 assert(NULL != (*symbol)->fragRef()->frag());
692 uint64_t addr =
693 (*symbol)->fragRef()->frag()->getParent()->getSection().addr();
694 (*symbol)->setValue(value + addr);
695 continue;
696 }
697 }
698
699 RpnEvaluator evaluator(*m_pModule, m_LDBackend);
700 bool finalized = m_LDBackend.finalizeSymbols();
701 bool scriptSymsFinalized = true;
702 LinkerScript& script = m_pModule->getScript();
703 LinkerScript::Assignments::iterator assign, assignEnd;
704 assignEnd = script.assignments().end();
705 for (assign = script.assignments().begin(); assign != assignEnd; ++assign) {
706 LDSymbol* symbol = (*assign).first;
707 Assignment& assignment = (*assign).second;
708
709 if (symbol == NULL)
710 continue;
711
712 scriptSymsFinalized &= assignment.assign(evaluator);
713 if (!scriptSymsFinalized)
714 break;
715
716 symbol->setValue(assignment.symbol().value());
717 } // for each script symbol assignment
718
719 bool assertionsPassed = true;
720 LinkerScript::Assertions::iterator assert, assertEnd;
721 assertEnd = script.assertions().end();
722 for (assert = script.assertions().begin(); assert != assertEnd; ++assert) {
723 uint64_t res = 0x0;
724 evaluator.eval((*assert).getRpnExpr(), res);
725 if (res == 0x0)
726 fatal(diag::err_assert_failed) << (*assert).message();
727 } // for each assertion in ldscript
728
729 return finalized && scriptSymsFinalized && assertionsPassed;
730 }
731
732 /// relocate - applying relocation entries and create relocation
733 /// section in the output files
734 /// Create relocation section, asking TargetLDBackend to
735 /// read the relocation information into RelocationEntry
736 /// and push_back into the relocation section
relocation()737 bool ObjectLinker::relocation()
738 {
739 // when producing relocatables, no need to apply relocation
740 if (LinkerConfig::Object == m_Config.codeGenType())
741 return true;
742
743 // apply all relocations of all inputs
744 Module::obj_iterator input, inEnd = m_pModule->obj_end();
745 for (input = m_pModule->obj_begin(); input != inEnd; ++input) {
746 m_LDBackend.getRelocator()->initializeApply(**input);
747 LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
748 for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
749 // bypass the reloc section if
750 // 1. its section kind is changed to Ignore. (The target section is a
751 // discarded group section.)
752 // 2. it has no reloc data. (All symbols in the input relocs are in the
753 // discarded group sections)
754 if (LDFileFormat::Ignore == (*rs)->kind() || !(*rs)->hasRelocData())
755 continue;
756 RelocData::iterator reloc, rEnd = (*rs)->getRelocData()->end();
757 for (reloc = (*rs)->getRelocData()->begin(); reloc != rEnd; ++reloc) {
758 Relocation* relocation = llvm::cast<Relocation>(reloc);
759
760 // bypass the reloc if the symbol is in the discarded input section
761 ResolveInfo* info = relocation->symInfo();
762 if (!info->outSymbol()->hasFragRef() &&
763 ResolveInfo::Section == info->type() &&
764 ResolveInfo::Undefined == info->desc())
765 continue;
766
767 relocation->apply(*m_LDBackend.getRelocator());
768 } // for all relocations
769 } // for all relocation section
770 m_LDBackend.getRelocator()->finalizeApply(**input);
771 } // for all inputs
772
773 // apply relocations created by relaxation
774 BranchIslandFactory* br_factory = m_LDBackend.getBRIslandFactory();
775 BranchIslandFactory::iterator facIter, facEnd = br_factory->end();
776 for (facIter = br_factory->begin(); facIter != facEnd; ++facIter) {
777 BranchIsland& island = *facIter;
778 BranchIsland::reloc_iterator iter, iterEnd = island.reloc_end();
779 for (iter = island.reloc_begin(); iter != iterEnd; ++iter)
780 (*iter)->apply(*m_LDBackend.getRelocator());
781 }
782 return true;
783 }
784
785 /// emitOutput - emit the output file.
emitOutput(FileOutputBuffer & pOutput)786 bool ObjectLinker::emitOutput(FileOutputBuffer& pOutput)
787 {
788 return std::error_code() == getWriter()->writeObject(*m_pModule, pOutput);
789 }
790
791
792 /// postProcessing - do modification after all processes
postProcessing(FileOutputBuffer & pOutput)793 bool ObjectLinker::postProcessing(FileOutputBuffer& pOutput)
794 {
795 if (LinkerConfig::Object != m_Config.codeGenType())
796 normalSyncRelocationResult(pOutput);
797 else
798 partialSyncRelocationResult(pOutput);
799
800 // emit .eh_frame_hdr
801 // eh_frame_hdr should be emitted after syncRelocation, because eh_frame_hdr
802 // needs FDE PC value, which will be corrected at syncRelocation
803 m_LDBackend.postProcessing(pOutput);
804 return true;
805 }
806
normalSyncRelocationResult(FileOutputBuffer & pOutput)807 void ObjectLinker::normalSyncRelocationResult(FileOutputBuffer& pOutput)
808 {
809 uint8_t* data = pOutput.getBufferStart();
810
811 // sync all relocations of all inputs
812 Module::obj_iterator input, inEnd = m_pModule->obj_end();
813 for (input = m_pModule->obj_begin(); input != inEnd; ++input) {
814 LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
815 for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
816 // bypass the reloc section if
817 // 1. its section kind is changed to Ignore. (The target section is a
818 // discarded group section.)
819 // 2. it has no reloc data. (All symbols in the input relocs are in the
820 // discarded group sections)
821 if (LDFileFormat::Ignore == (*rs)->kind() || !(*rs)->hasRelocData())
822 continue;
823 RelocData::iterator reloc, rEnd = (*rs)->getRelocData()->end();
824 for (reloc = (*rs)->getRelocData()->begin(); reloc != rEnd; ++reloc) {
825 Relocation* relocation = llvm::cast<Relocation>(reloc);
826
827 // bypass the reloc if the symbol is in the discarded input section
828 ResolveInfo* info = relocation->symInfo();
829 if (!info->outSymbol()->hasFragRef() &&
830 ResolveInfo::Section == info->type() &&
831 ResolveInfo::Undefined == info->desc())
832 continue;
833
834 // bypass the relocation with NONE type. This is to avoid overwrite the
835 // target result by NONE type relocation if there is a place which has
836 // two relocations to apply to, and one of it is NONE type. The result
837 // we want is the value of the other relocation result. For example,
838 // in .exidx, there are usually an R_ARM_NONE and R_ARM_PREL31 apply to
839 // the same place
840 if (0x0 == relocation->type())
841 continue;
842 writeRelocationResult(*relocation, data);
843 } // for all relocations
844 } // for all relocation section
845 } // for all inputs
846
847 // sync relocations created by relaxation
848 BranchIslandFactory* br_factory = m_LDBackend.getBRIslandFactory();
849 BranchIslandFactory::iterator facIter, facEnd = br_factory->end();
850 for (facIter = br_factory->begin(); facIter != facEnd; ++facIter) {
851 BranchIsland& island = *facIter;
852 BranchIsland::reloc_iterator iter, iterEnd = island.reloc_end();
853 for (iter = island.reloc_begin(); iter != iterEnd; ++iter) {
854 Relocation* reloc = *iter;
855 writeRelocationResult(*reloc, data);
856 }
857 }
858 }
859
partialSyncRelocationResult(FileOutputBuffer & pOutput)860 void ObjectLinker::partialSyncRelocationResult(FileOutputBuffer& pOutput)
861 {
862 uint8_t* data = pOutput.getBufferStart();
863
864 // traverse outputs' LDSection to get RelocData
865 Module::iterator sectIter, sectEnd = m_pModule->end();
866 for (sectIter = m_pModule->begin(); sectIter != sectEnd; ++sectIter) {
867 if (LDFileFormat::Relocation != (*sectIter)->kind())
868 continue;
869
870 RelocData* reloc_data = (*sectIter)->getRelocData();
871 RelocData::iterator relocIter, relocEnd = reloc_data->end();
872 for (relocIter = reloc_data->begin(); relocIter != relocEnd; ++relocIter) {
873 Relocation* reloc = llvm::cast<Relocation>(relocIter);
874
875 // bypass the relocation with NONE type. This is to avoid overwrite the
876 // target result by NONE type relocation if there is a place which has
877 // two relocations to apply to, and one of it is NONE type. The result
878 // we want is the value of the other relocation result. For example,
879 // in .exidx, there are usually an R_ARM_NONE and R_ARM_PREL31 apply to
880 // the same place
881 if (0x0 == reloc->type())
882 continue;
883 writeRelocationResult(*reloc, data);
884 }
885 }
886 }
887
writeRelocationResult(Relocation & pReloc,uint8_t * pOutput)888 void ObjectLinker::writeRelocationResult(Relocation& pReloc, uint8_t* pOutput)
889 {
890 // get output file offset
891 size_t out_offset =
892 pReloc.targetRef().frag()->getParent()->getSection().offset() +
893 pReloc.targetRef().getOutputOffset();
894
895 uint8_t* target_addr = pOutput + out_offset;
896 // byte swapping if target and host has different endian, and then write back
897 if(llvm::sys::IsLittleEndianHost != m_Config.targets().isLittleEndian()) {
898 uint64_t tmp_data = 0;
899
900 switch(pReloc.size(*m_LDBackend.getRelocator())) {
901 case 8u:
902 std::memcpy(target_addr, &pReloc.target(), 1);
903 break;
904
905 case 16u:
906 tmp_data = mcld::bswap16(pReloc.target());
907 std::memcpy(target_addr, &tmp_data, 2);
908 break;
909
910 case 32u:
911 tmp_data = mcld::bswap32(pReloc.target());
912 std::memcpy(target_addr, &tmp_data, 4);
913 break;
914
915 case 64u:
916 tmp_data = mcld::bswap64(pReloc.target());
917 std::memcpy(target_addr, &tmp_data, 8);
918 break;
919
920 default:
921 break;
922 }
923 }
924 else
925 std::memcpy(target_addr, &pReloc.target(),
926 pReloc.size(*m_LDBackend.getRelocator())/8);
927 }
928
929