1 //===- HexagonLDBackend.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 "Hexagon.h"
10 #include "HexagonELFDynamic.h"
11 #include "HexagonLDBackend.h"
12 #include "HexagonRelocator.h"
13 #include "HexagonGNUInfo.h"
14 #include "HexagonAbsoluteStub.h"
15
16 #include "mcld/IRBuilder.h"
17 #include "mcld/LinkerConfig.h"
18 #include "mcld/Fragment/AlignFragment.h"
19 #include "mcld/Fragment/FillFragment.h"
20 #include "mcld/Fragment/RegionFragment.h"
21 #include "mcld/Fragment/Stub.h"
22 #include "mcld/LD/BranchIslandFactory.h"
23 #include "mcld/LD/ELFFileFormat.h"
24 #include "mcld/LD/ELFSegmentFactory.h"
25 #include "mcld/LD/ELFSegment.h"
26 #include "mcld/LD/LDContext.h"
27 #include "mcld/LD/StubFactory.h"
28 #include "mcld/Object/ObjectBuilder.h"
29 #include "mcld/Support/MemoryArea.h"
30 #include "mcld/Support/MsgHandling.h"
31 #include "mcld/Support/TargetRegistry.h"
32
33 #include <llvm/ADT/Triple.h>
34 #include <llvm/Support/Casting.h>
35
36 #include <cstring>
37 #include <vector>
38
39 namespace mcld {
40
41 //===----------------------------------------------------------------------===//
42 // HexagonLDBackend
43 //===----------------------------------------------------------------------===//
HexagonLDBackend(const LinkerConfig & pConfig,HexagonGNUInfo * pInfo)44 HexagonLDBackend::HexagonLDBackend(const LinkerConfig& pConfig,
45 HexagonGNUInfo* pInfo)
46 : GNULDBackend(pConfig, pInfo),
47 m_pRelocator(NULL),
48 m_pGOT(NULL),
49 m_pGOTPLT(NULL),
50 m_pPLT(NULL),
51 m_pRelaDyn(NULL),
52 m_pRelaPLT(NULL),
53 m_pDynamic(NULL),
54 m_pGOTSymbol(NULL),
55 m_CopyRel(llvm::ELF::R_HEX_COPY) {
56 }
57
~HexagonLDBackend()58 HexagonLDBackend::~HexagonLDBackend() {
59 delete m_pRelocator;
60 delete m_pGOT;
61 delete m_pPLT;
62 delete m_pRelaDyn;
63 delete m_pRelaPLT;
64 delete m_pDynamic;
65 }
66
initRelocator()67 bool HexagonLDBackend::initRelocator() {
68 if (m_pRelocator == NULL) {
69 m_pRelocator = new HexagonRelocator(*this, config());
70 }
71 return true;
72 }
73
getRelocator() const74 const Relocator* HexagonLDBackend::getRelocator() const {
75 assert(m_pRelocator != NULL);
76 return m_pRelocator;
77 }
78
getRelocator()79 Relocator* HexagonLDBackend::getRelocator() {
80 assert(m_pRelocator != NULL);
81 return m_pRelocator;
82 }
83
doPreLayout(IRBuilder & pBuilder)84 void HexagonLDBackend::doPreLayout(IRBuilder& pBuilder) {
85 // initialize .dynamic data
86 if (!config().isCodeStatic() && m_pDynamic == NULL)
87 m_pDynamic = new HexagonELFDynamic(*this, config());
88
89 // set .got.plt and .got sizes
90 // when building shared object, the .got section is must
91 if ((LinkerConfig::Object != config().codeGenType()) &&
92 (!config().isCodeStatic())) {
93 setGOTSectionSize(pBuilder);
94
95 // set .plt size
96 if (m_pPLT->hasPLT1())
97 m_pPLT->finalizeSectionSize();
98
99 // set .rela.dyn size
100 if (!m_pRelaDyn->empty()) {
101 assert(
102 !config().isCodeStatic() &&
103 "static linkage should not result in a dynamic relocation section");
104 setRelaDynSize();
105 }
106 // set .rela.plt size
107 if (!m_pRelaPLT->empty()) {
108 assert(
109 !config().isCodeStatic() &&
110 "static linkage should not result in a dynamic relocation section");
111 setRelaPLTSize();
112 }
113 }
114 // Shared libraries are compiled with -G0 so there is no need to set SData.
115 if (LinkerConfig::Object == config().codeGenType())
116 SetSDataSection();
117 }
118
doPostLayout(Module & pModule,IRBuilder & pBuilder)119 void HexagonLDBackend::doPostLayout(Module& pModule, IRBuilder& pBuilder) {
120 }
121
122 /// dynamic - the dynamic section of the target machine.
123 /// Use co-variant return type to return its own dynamic section.
dynamic()124 HexagonELFDynamic& HexagonLDBackend::dynamic() {
125 assert(m_pDynamic != NULL);
126 return *m_pDynamic;
127 }
128
129 /// dynamic - the dynamic section of the target machine.
130 /// Use co-variant return type to return its own dynamic section.
dynamic() const131 const HexagonELFDynamic& HexagonLDBackend::dynamic() const {
132 assert(m_pDynamic != NULL);
133 return *m_pDynamic;
134 }
135
emitSectionData(const LDSection & pSection,MemoryRegion & pRegion) const136 uint64_t HexagonLDBackend::emitSectionData(const LDSection& pSection,
137 MemoryRegion& pRegion) const {
138 if (!pRegion.size())
139 return 0;
140
141 const ELFFileFormat* FileFormat = getOutputFormat();
142 unsigned int EntrySize = 0;
143 uint64_t RegionSize = 0;
144
145 if ((LinkerConfig::Object != config().codeGenType()) &&
146 (!config().isCodeStatic())) {
147 if (FileFormat->hasPLT() && (&pSection == &(FileFormat->getPLT()))) {
148 unsigned char* buffer = pRegion.begin();
149
150 m_pPLT->applyPLT0();
151 m_pPLT->applyPLT1();
152 HexagonPLT::iterator it = m_pPLT->begin();
153 unsigned int plt0_size = llvm::cast<PLTEntryBase>((*it)).size();
154
155 memcpy(buffer, llvm::cast<PLTEntryBase>((*it)).getValue(), plt0_size);
156 RegionSize += plt0_size;
157 ++it;
158
159 PLTEntryBase* plt1 = 0;
160 HexagonPLT::iterator ie = m_pPLT->end();
161 while (it != ie) {
162 plt1 = &(llvm::cast<PLTEntryBase>(*it));
163 EntrySize = plt1->size();
164 memcpy(buffer + RegionSize, plt1->getValue(), EntrySize);
165 RegionSize += EntrySize;
166 ++it;
167 }
168 return RegionSize;
169 } else if (FileFormat->hasGOT() && (&pSection == &(FileFormat->getGOT()))) {
170 RegionSize += emitGOTSectionData(pRegion);
171 return RegionSize;
172 } else if (FileFormat->hasGOTPLT() &&
173 (&pSection == &(FileFormat->getGOTPLT()))) {
174 RegionSize += emitGOTPLTSectionData(pRegion, FileFormat);
175 return RegionSize;
176 }
177 }
178
179 const SectionData* sect_data = pSection.getSectionData();
180 SectionData::const_iterator frag_iter, frag_end = sect_data->end();
181 uint8_t* out_offset = pRegion.begin();
182 for (frag_iter = sect_data->begin(); frag_iter != frag_end; ++frag_iter) {
183 size_t size = frag_iter->size();
184 switch (frag_iter->getKind()) {
185 case Fragment::Fillment: {
186 const FillFragment& fill_frag = llvm::cast<FillFragment>(*frag_iter);
187 if (fill_frag.getValueSize() == 0) {
188 // virtual fillment, ignore it.
189 break;
190 }
191 memset(out_offset, fill_frag.getValue(), fill_frag.size());
192 break;
193 }
194 case Fragment::Region: {
195 const RegionFragment& region_frag =
196 llvm::cast<RegionFragment>(*frag_iter);
197 const char* start = region_frag.getRegion().begin();
198 memcpy(out_offset, start, size);
199 break;
200 }
201 case Fragment::Alignment: {
202 const AlignFragment& align_frag = llvm::cast<AlignFragment>(*frag_iter);
203 uint64_t count = size / align_frag.getValueSize();
204 switch (align_frag.getValueSize()) {
205 case 1u:
206 std::memset(out_offset, align_frag.getValue(), count);
207 break;
208 default:
209 llvm::report_fatal_error(
210 "unsupported value size for align fragment emission yet.\n");
211 break;
212 } // end switch
213 break;
214 }
215 case Fragment::Null: {
216 assert(0x0 == size);
217 break;
218 }
219 default:
220 llvm::report_fatal_error("unsupported fragment type.\n");
221 break;
222 } // end switch
223 out_offset += size;
224 } // end for
225
226 return pRegion.size();
227 }
228
getGOT()229 HexagonGOT& HexagonLDBackend::getGOT() {
230 assert(m_pGOT != NULL);
231 return *m_pGOT;
232 }
233
getGOT() const234 const HexagonGOT& HexagonLDBackend::getGOT() const {
235 assert(m_pGOT != NULL);
236 return *m_pGOT;
237 }
238
getPLT()239 HexagonPLT& HexagonLDBackend::getPLT() {
240 assert(m_pPLT != NULL && "PLT section not exist");
241 return *m_pPLT;
242 }
243
getPLT() const244 const HexagonPLT& HexagonLDBackend::getPLT() const {
245 assert(m_pPLT != NULL && "PLT section not exist");
246 return *m_pPLT;
247 }
248
getRelaDyn()249 OutputRelocSection& HexagonLDBackend::getRelaDyn() {
250 assert(m_pRelaDyn != NULL && ".rela.dyn section not exist");
251 return *m_pRelaDyn;
252 }
253
getRelaDyn() const254 const OutputRelocSection& HexagonLDBackend::getRelaDyn() const {
255 assert(m_pRelaDyn != NULL && ".rela.dyn section not exist");
256 return *m_pRelaDyn;
257 }
258
getRelaPLT()259 OutputRelocSection& HexagonLDBackend::getRelaPLT() {
260 assert(m_pRelaPLT != NULL && ".rela.plt section not exist");
261 return *m_pRelaPLT;
262 }
263
getRelaPLT() const264 const OutputRelocSection& HexagonLDBackend::getRelaPLT() const {
265 assert(m_pRelaPLT != NULL && ".rela.plt section not exist");
266 return *m_pRelaPLT;
267 }
268
getGOTPLT()269 HexagonGOTPLT& HexagonLDBackend::getGOTPLT() {
270 assert(m_pGOTPLT != NULL);
271 return *m_pGOTPLT;
272 }
273
getGOTPLT() const274 const HexagonGOTPLT& HexagonLDBackend::getGOTPLT() const {
275 assert(m_pGOTPLT != NULL);
276 return *m_pGOTPLT;
277 }
278
setRelaDynSize()279 void HexagonLDBackend::setRelaDynSize() {
280 ELFFileFormat* file_format = getOutputFormat();
281 file_format->getRelaDyn().setSize(m_pRelaDyn->numOfRelocs() *
282 getRelaEntrySize());
283 }
284
setRelaPLTSize()285 void HexagonLDBackend::setRelaPLTSize() {
286 ELFFileFormat* file_format = getOutputFormat();
287 file_format->getRelaPlt().setSize(m_pRelaPLT->numOfRelocs() *
288 getRelaEntrySize());
289 }
290
setGOTSectionSize(IRBuilder & pBuilder)291 void HexagonLDBackend::setGOTSectionSize(IRBuilder& pBuilder) {
292 // set .got.plt size
293 if (LinkerConfig::DynObj == config().codeGenType() || m_pGOTPLT->hasGOT1() ||
294 m_pGOTSymbol != NULL) {
295 m_pGOTPLT->finalizeSectionSize();
296 defineGOTSymbol(pBuilder, *(m_pGOTPLT->begin()));
297 }
298
299 // set .got size
300 if (!m_pGOT->empty())
301 m_pGOT->finalizeSectionSize();
302 }
303
emitGOTSectionData(MemoryRegion & pRegion) const304 uint64_t HexagonLDBackend::emitGOTSectionData(MemoryRegion& pRegion) const {
305 assert(m_pGOT && "emitGOTSectionData failed, m_pGOT is NULL!");
306
307 uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
308
309 HexagonGOTEntry* got = 0;
310 unsigned int EntrySize = HexagonGOTEntry::EntrySize;
311 uint64_t RegionSize = 0;
312
313 for (HexagonGOT::iterator it = m_pGOT->begin(), ie = m_pGOT->end(); it != ie;
314 ++it, ++buffer) {
315 got = &(llvm::cast<HexagonGOTEntry>((*it)));
316 *buffer = static_cast<uint32_t>(got->getValue());
317 RegionSize += EntrySize;
318 }
319
320 return RegionSize;
321 }
322
defineGOTSymbol(IRBuilder & pBuilder,Fragment & pFrag)323 void HexagonLDBackend::defineGOTSymbol(IRBuilder& pBuilder, Fragment& pFrag) {
324 // define symbol _GLOBAL_OFFSET_TABLE_
325 if (m_pGOTSymbol != NULL) {
326 pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
327 "_GLOBAL_OFFSET_TABLE_",
328 ResolveInfo::Object,
329 ResolveInfo::Define,
330 ResolveInfo::Local,
331 0x0, // size
332 0x0, // value
333 FragmentRef::Create(pFrag, 0x0),
334 ResolveInfo::Hidden);
335 } else {
336 m_pGOTSymbol = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
337 "_GLOBAL_OFFSET_TABLE_",
338 ResolveInfo::Object,
339 ResolveInfo::Define,
340 ResolveInfo::Local,
341 0x0, // size
342 0x0, // value
343 FragmentRef::Create(pFrag, 0x0),
344 ResolveInfo::Hidden);
345 }
346 }
347
emitGOTPLTSectionData(MemoryRegion & pRegion,const ELFFileFormat * FileFormat) const348 uint64_t HexagonLDBackend::emitGOTPLTSectionData(
349 MemoryRegion& pRegion,
350 const ELFFileFormat* FileFormat) const {
351 assert(m_pGOTPLT != NULL &&
352 "emitGOTPLTSectionData failed, m_pGOTPLT is NULL!");
353 m_pGOTPLT->applyGOT0(FileFormat->getDynamic().addr());
354 m_pGOTPLT->applyAllGOTPLT(*m_pPLT);
355
356 uint32_t* buffer = reinterpret_cast<uint32_t*>(pRegion.begin());
357
358 HexagonGOTEntry* got = 0;
359 unsigned int EntrySize = HexagonGOTEntry::EntrySize;
360 uint64_t RegionSize = 0;
361
362 for (HexagonGOTPLT::iterator it = m_pGOTPLT->begin(), ie = m_pGOTPLT->end();
363 it != ie;
364 ++it, ++buffer) {
365 got = &(llvm::cast<HexagonGOTEntry>((*it)));
366 *buffer = static_cast<uint32_t>(got->getValue());
367 RegionSize += EntrySize;
368 }
369
370 return RegionSize;
371 }
372
getTargetSectionOrder(const LDSection & pSectHdr) const373 unsigned int HexagonLDBackend::getTargetSectionOrder(
374 const LDSection& pSectHdr) const {
375 const ELFFileFormat* file_format = getOutputFormat();
376
377 if (LinkerConfig::Object != config().codeGenType()) {
378 if (file_format->hasGOT() && (&pSectHdr == &file_format->getGOT())) {
379 if (config().options().hasNow())
380 return SHO_RELRO;
381 return SHO_RELRO_LAST;
382 }
383
384 if (file_format->hasGOTPLT() && (&pSectHdr == &file_format->getGOTPLT())) {
385 if (config().options().hasNow())
386 return SHO_RELRO;
387 return SHO_NON_RELRO_FIRST;
388 }
389
390 if (file_format->hasPLT() && (&pSectHdr == &file_format->getPLT()))
391 return SHO_PLT;
392 }
393
394 if (&pSectHdr == m_pstart)
395 return SHO_INIT;
396
397 if (&pSectHdr == m_psdata)
398 return SHO_SMALL_DATA;
399
400 return SHO_UNDEFINED;
401 }
402
initTargetSections(Module & pModule,ObjectBuilder & pBuilder)403 void HexagonLDBackend::initTargetSections(Module& pModule,
404 ObjectBuilder& pBuilder) {
405 if ((LinkerConfig::Object != config().codeGenType()) &&
406 (!config().isCodeStatic())) {
407 ELFFileFormat* file_format = getOutputFormat();
408 // initialize .got
409 LDSection& got = file_format->getGOT();
410 m_pGOT = new HexagonGOT(got);
411
412 // initialize .got.plt
413 LDSection& gotplt = file_format->getGOTPLT();
414 m_pGOTPLT = new HexagonGOTPLT(gotplt);
415
416 // initialize .plt
417 LDSection& plt = file_format->getPLT();
418 m_pPLT = new HexagonPLT(plt, *m_pGOTPLT, config());
419
420 // initialize .rela.plt
421 LDSection& relaplt = file_format->getRelaPlt();
422 relaplt.setLink(&plt);
423 m_pRelaPLT = new OutputRelocSection(pModule, relaplt);
424
425 // initialize .rela.dyn
426 LDSection& reladyn = file_format->getRelaDyn();
427 m_pRelaDyn = new OutputRelocSection(pModule, reladyn);
428 }
429 m_psdata = pBuilder.CreateSection(".sdata",
430 LDFileFormat::Target,
431 llvm::ELF::SHT_PROGBITS,
432 llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
433 4 * 1024);
434 m_pscommon_1 =
435 pBuilder.CreateSection(".scommon.1",
436 LDFileFormat::Target,
437 llvm::ELF::SHT_PROGBITS,
438 llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
439 1);
440 IRBuilder::CreateSectionData(*m_pscommon_1);
441
442 m_pscommon_2 =
443 pBuilder.CreateSection(".scommon.2",
444 LDFileFormat::Target,
445 llvm::ELF::SHT_PROGBITS,
446 llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
447 2);
448 IRBuilder::CreateSectionData(*m_pscommon_2);
449
450 m_pscommon_4 =
451 pBuilder.CreateSection(".scommon.4",
452 LDFileFormat::Target,
453 llvm::ELF::SHT_PROGBITS,
454 llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
455 4);
456 IRBuilder::CreateSectionData(*m_pscommon_4);
457
458 m_pscommon_8 =
459 pBuilder.CreateSection(".scommon.8",
460 LDFileFormat::Target,
461 llvm::ELF::SHT_PROGBITS,
462 llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
463 8);
464 IRBuilder::CreateSectionData(*m_pscommon_8);
465
466 m_pstart = pBuilder.CreateSection(".start",
467 LDFileFormat::Target,
468 llvm::ELF::SHT_PROGBITS,
469 llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE,
470 8);
471 IRBuilder::CreateSectionData(*m_pstart);
472 }
473
initTargetSymbols(IRBuilder & pBuilder,Module & pModule)474 void HexagonLDBackend::initTargetSymbols(IRBuilder& pBuilder, Module& pModule) {
475 if (config().codeGenType() == LinkerConfig::Object)
476 return;
477
478 // Define the symbol _GLOBAL_OFFSET_TABLE_ if there is a symbol with the
479 // same name in input
480 m_pGOTSymbol = pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
481 "_GLOBAL_OFFSET_TABLE_",
482 ResolveInfo::Object,
483 ResolveInfo::Define,
484 ResolveInfo::Local,
485 0x0, // size
486 0x0, // value
487 FragmentRef::Null(),
488 ResolveInfo::Hidden);
489
490 m_psdabase = pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
491 "_SDA_BASE_",
492 ResolveInfo::Object,
493 ResolveInfo::Define,
494 ResolveInfo::Absolute,
495 0x0, // size
496 0x0, // value
497 FragmentRef::Null(),
498 ResolveInfo::Hidden);
499
500 pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
501 "__sbss_start",
502 ResolveInfo::Object,
503 ResolveInfo::Define,
504 ResolveInfo::Absolute,
505 0x0, // size
506 0x0, // value
507 FragmentRef::Null(),
508 ResolveInfo::Hidden);
509
510 pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
511 "__sbss_end",
512 ResolveInfo::Object,
513 ResolveInfo::Define,
514 ResolveInfo::Absolute,
515 0x0, // size
516 0x0, // value
517 FragmentRef::Null(),
518 ResolveInfo::Hidden);
519 }
520
initTargetStubs()521 bool HexagonLDBackend::initTargetStubs() {
522 if (getStubFactory() != NULL) {
523 getStubFactory()->addPrototype(
524 new HexagonAbsoluteStub(config().isCodeIndep()));
525 return true;
526 }
527 return false;
528 }
529
initBRIslandFactory()530 bool HexagonLDBackend::initBRIslandFactory() {
531 if (m_pBRIslandFactory == NULL) {
532 m_pBRIslandFactory =
533 new BranchIslandFactory(maxFwdBranchOffset(), maxBwdBranchOffset(), 0);
534 }
535 return true;
536 }
537
initStubFactory()538 bool HexagonLDBackend::initStubFactory() {
539 if (m_pStubFactory == NULL) {
540 m_pStubFactory = new StubFactory();
541 }
542 return true;
543 }
544
doRelax(Module & pModule,IRBuilder & pBuilder,bool & pFinished)545 bool HexagonLDBackend::doRelax(Module& pModule,
546 IRBuilder& pBuilder,
547 bool& pFinished) {
548 assert(getStubFactory() != NULL && getBRIslandFactory() != NULL);
549 bool isRelaxed = false;
550 ELFFileFormat* file_format = getOutputFormat();
551 // check branch relocs and create the related stubs if needed
552 Module::obj_iterator input, inEnd = pModule.obj_end();
553 for (input = pModule.obj_begin(); input != inEnd; ++input) {
554 LDContext::sect_iterator rs, rsEnd = (*input)->context()->relocSectEnd();
555 for (rs = (*input)->context()->relocSectBegin(); rs != rsEnd; ++rs) {
556 if (LDFileFormat::Ignore == (*rs)->kind() || !(*rs)->hasRelocData())
557 continue;
558 RelocData::iterator reloc, rEnd = (*rs)->getRelocData()->end();
559 for (reloc = (*rs)->getRelocData()->begin(); reloc != rEnd; ++reloc) {
560 switch (reloc->type()) {
561 case llvm::ELF::R_HEX_B22_PCREL:
562 case llvm::ELF::R_HEX_B15_PCREL:
563 case llvm::ELF::R_HEX_B7_PCREL:
564 case llvm::ELF::R_HEX_B13_PCREL:
565 case llvm::ELF::R_HEX_B9_PCREL: {
566 Relocation* relocation = llvm::cast<Relocation>(reloc);
567 uint64_t sym_value = 0x0;
568 LDSymbol* symbol = relocation->symInfo()->outSymbol();
569 if (symbol->hasFragRef()) {
570 uint64_t value = symbol->fragRef()->getOutputOffset();
571 uint64_t addr =
572 symbol->fragRef()->frag()->getParent()->getSection().addr();
573 sym_value = addr + value;
574 }
575 Stub* stub = getStubFactory()->create(*relocation, // relocation
576 sym_value, // symbol value
577 pBuilder,
578 *getBRIslandFactory());
579 if (stub != NULL) {
580 assert(stub->symInfo() != NULL);
581 // reset the branch target of the reloc to this stub instead
582 relocation->setSymInfo(stub->symInfo());
583
584 // increase the size of .symtab and .strtab
585 LDSection& symtab = file_format->getSymTab();
586 LDSection& strtab = file_format->getStrTab();
587 symtab.setSize(symtab.size() + sizeof(llvm::ELF::Elf32_Sym));
588 strtab.setSize(strtab.size() + stub->symInfo()->nameSize() + 1);
589 isRelaxed = true;
590 }
591 } break;
592
593 default:
594 break;
595 }
596 }
597 }
598 }
599
600 // find the first fragment w/ invalid offset due to stub insertion
601 std::vector<Fragment*> invalid_frags;
602 pFinished = true;
603 for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
604 island_end = getBRIslandFactory()->end();
605 island != island_end;
606 ++island) {
607 if ((*island).size() > stubGroupSize()) {
608 error(diag::err_no_space_to_place_stubs) << stubGroupSize();
609 return false;
610 }
611
612 if ((*island).numOfStubs() == 0) {
613 continue;
614 }
615
616 Fragment* exit = &*(*island).end();
617 if (exit == (*island).begin()->getParent()->end()) {
618 continue;
619 }
620
621 if (((*island).offset() + (*island).size()) > exit->getOffset()) {
622 if (invalid_frags.empty() ||
623 (invalid_frags.back()->getParent() != (*island).getParent())) {
624 invalid_frags.push_back(exit);
625 pFinished = false;
626 }
627 continue;
628 }
629 }
630
631 // reset the offset of invalid fragments
632 for (auto it = invalid_frags.begin(), ie = invalid_frags.end(); it != ie;
633 ++it) {
634 Fragment* invalid = *it;
635 while (invalid != NULL) {
636 invalid->setOffset(invalid->getPrevNode()->getOffset() +
637 invalid->getPrevNode()->size());
638 invalid = invalid->getNextNode();
639 }
640 }
641
642 // reset the size of section that has stubs inserted.
643 if (isRelaxed) {
644 SectionData* prev = NULL;
645 for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
646 island_end = getBRIslandFactory()->end();
647 island != island_end;
648 ++island) {
649 SectionData* sd = (*island).begin()->getParent();
650 if ((*island).numOfStubs() != 0) {
651 if (sd != prev) {
652 sd->getSection().setSize(sd->back().getOffset() + sd->back().size());
653 }
654 }
655 prev = sd;
656 }
657 }
658 return isRelaxed;
659 }
660
661 /// finalizeSymbol - finalize the symbol value
finalizeTargetSymbols()662 bool HexagonLDBackend::finalizeTargetSymbols() {
663 if (config().codeGenType() == LinkerConfig::Object)
664 return true;
665 if (m_psdabase)
666 m_psdabase->setValue(m_psdata->addr());
667
668 ELFSegmentFactory::const_iterator edata = elfSegmentTable().find(
669 llvm::ELF::PT_LOAD, llvm::ELF::PF_W, llvm::ELF::PF_X);
670 if (elfSegmentTable().end() != edata) {
671 if (f_pEData != NULL && ResolveInfo::ThreadLocal != f_pEData->type()) {
672 f_pEData->setValue((*edata)->vaddr() + (*edata)->filesz());
673 }
674 if (f_p_EData != NULL && ResolveInfo::ThreadLocal != f_p_EData->type()) {
675 f_p_EData->setValue((*edata)->vaddr() + (*edata)->filesz());
676 }
677 if (f_pBSSStart != NULL &&
678 ResolveInfo::ThreadLocal != f_pBSSStart->type()) {
679 f_pBSSStart->setValue((*edata)->vaddr() + (*edata)->filesz());
680 }
681 if (f_pEnd != NULL && ResolveInfo::ThreadLocal != f_pEnd->type()) {
682 f_pEnd->setValue((((*edata)->vaddr() + (*edata)->memsz()) + 7) & ~7);
683 }
684 if (f_p_End != NULL && ResolveInfo::ThreadLocal != f_p_End->type()) {
685 f_p_End->setValue((((*edata)->vaddr() + (*edata)->memsz()) + 7) & ~7);
686 }
687 }
688 return true;
689 }
690
691 /// merge Input Sections
mergeSection(Module & pModule,const Input & pInputFile,LDSection & pInputSection)692 bool HexagonLDBackend::mergeSection(Module& pModule,
693 const Input& pInputFile,
694 LDSection& pInputSection) {
695 if ((pInputSection.flag() & llvm::ELF::SHF_HEX_GPREL) ||
696 (pInputSection.kind() == LDFileFormat::LinkOnce) ||
697 (pInputSection.kind() == LDFileFormat::Target)) {
698 SectionData* sd = NULL;
699 if (!m_psdata->hasSectionData()) {
700 sd = IRBuilder::CreateSectionData(*m_psdata);
701 m_psdata->setSectionData(sd);
702 }
703 sd = m_psdata->getSectionData();
704 MoveSectionDataAndSort(*pInputSection.getSectionData(), *sd);
705 } else {
706 ObjectBuilder builder(pModule);
707 builder.MergeSection(pInputFile, pInputSection);
708 }
709 return true;
710 }
711
SetSDataSection()712 bool HexagonLDBackend::SetSDataSection() {
713 SectionData* pTo = (m_psdata->getSectionData());
714
715 if (pTo) {
716 MoveCommonData(*m_pscommon_1->getSectionData(), *pTo);
717 MoveCommonData(*m_pscommon_2->getSectionData(), *pTo);
718 MoveCommonData(*m_pscommon_4->getSectionData(), *pTo);
719 MoveCommonData(*m_pscommon_8->getSectionData(), *pTo);
720
721 SectionData::FragmentListType& to_list = pTo->getFragmentList();
722 SectionData::FragmentListType::iterator fragTo, fragToEnd = to_list.end();
723 uint32_t offset = 0;
724 for (fragTo = to_list.begin(); fragTo != fragToEnd; ++fragTo) {
725 fragTo->setOffset(offset);
726 offset += fragTo->size();
727 }
728
729 // set up pTo's header
730 pTo->getSection().setSize(offset);
731
732 SectionData::FragmentListType& newlist = pTo->getFragmentList();
733
734 for (fragTo = newlist.begin(), fragToEnd = newlist.end();
735 fragTo != fragToEnd;
736 ++fragTo) {
737 fragTo->setParent(pTo);
738 }
739 }
740
741 return true;
742 }
743
744 /// allocateCommonSymbols - allocate common symbols in the corresponding
745 /// sections. This is called at pre-layout stage.
allocateCommonSymbols(Module & pModule)746 bool HexagonLDBackend::allocateCommonSymbols(Module& pModule) {
747 SymbolCategory& symbol_list = pModule.getSymbolTable();
748
749 if (symbol_list.emptyCommons() && symbol_list.emptyLocals()) {
750 SetSDataSection();
751 return true;
752 }
753
754 int8_t maxGPSize = config().targets().getGPSize();
755
756 SymbolCategory::iterator com_sym, com_end;
757
758 // get corresponding BSS LDSection
759 ELFFileFormat* file_format = getOutputFormat();
760 LDSection& bss_sect = file_format->getBSS();
761 LDSection& tbss_sect = file_format->getTBSS();
762
763 // get or create corresponding BSS SectionData
764 SectionData* bss_sect_data = NULL;
765 if (bss_sect.hasSectionData())
766 bss_sect_data = bss_sect.getSectionData();
767 else
768 bss_sect_data = IRBuilder::CreateSectionData(bss_sect);
769
770 SectionData* tbss_sect_data = NULL;
771 if (tbss_sect.hasSectionData())
772 tbss_sect_data = tbss_sect.getSectionData();
773 else
774 tbss_sect_data = IRBuilder::CreateSectionData(tbss_sect);
775
776 // remember original BSS size
777 uint64_t bss_offset = bss_sect.size();
778 uint64_t tbss_offset = tbss_sect.size();
779
780 // allocate all local common symbols
781 com_end = symbol_list.localEnd();
782
783 for (com_sym = symbol_list.localBegin(); com_sym != com_end; ++com_sym) {
784 if (ResolveInfo::Common == (*com_sym)->desc()) {
785 // We have to reset the description of the symbol here. When doing
786 // incremental linking, the output relocatable object may have common
787 // symbols. Therefore, we can not treat common symbols as normal symbols
788 // when emitting the regular name pools. We must change the symbols'
789 // description here.
790 (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
791 Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
792
793 switch ((*com_sym)->size()) {
794 case 1:
795 if (maxGPSize <= 0)
796 break;
797 ObjectBuilder::AppendFragment(
798 *frag, *(m_pscommon_1->getSectionData()), (*com_sym)->value());
799 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
800 continue;
801 case 2:
802 if (maxGPSize <= 1)
803 break;
804 ObjectBuilder::AppendFragment(
805 *frag, *(m_pscommon_2->getSectionData()), (*com_sym)->value());
806 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
807 continue;
808 case 4:
809 if (maxGPSize <= 3)
810 break;
811 ObjectBuilder::AppendFragment(
812 *frag, *(m_pscommon_4->getSectionData()), (*com_sym)->value());
813 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
814 continue;
815 case 8:
816 if (maxGPSize <= 7)
817 break;
818 ObjectBuilder::AppendFragment(
819 *frag, *(m_pscommon_8->getSectionData()), (*com_sym)->value());
820 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
821 continue;
822 default:
823 break;
824 }
825
826 if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
827 // allocate TLS common symbol in tbss section
828 tbss_offset += ObjectBuilder::AppendFragment(
829 *frag, *tbss_sect_data, (*com_sym)->value());
830 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
831 } else {
832 // FIXME: how to identify small and large common symbols?
833 bss_offset += ObjectBuilder::AppendFragment(
834 *frag, *bss_sect_data, (*com_sym)->value());
835 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
836 }
837 }
838 }
839
840 // allocate all global common symbols
841 com_end = symbol_list.commonEnd();
842 for (com_sym = symbol_list.commonBegin(); com_sym != com_end; ++com_sym) {
843 // We have to reset the description of the symbol here. When doing
844 // incremental linking, the output relocatable object may have common
845 // symbols. Therefore, we can not treat common symbols as normal symbols
846 // when emitting the regular name pools. We must change the symbols'
847 // description here.
848 (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
849 Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
850
851 switch ((*com_sym)->size()) {
852 case 1:
853 if (maxGPSize <= 0)
854 break;
855 ObjectBuilder::AppendFragment(
856 *frag, *(m_pscommon_1->getSectionData()), (*com_sym)->value());
857 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
858 continue;
859 case 2:
860 if (maxGPSize <= 1)
861 break;
862 ObjectBuilder::AppendFragment(
863 *frag, *(m_pscommon_2->getSectionData()), (*com_sym)->value());
864 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
865 continue;
866 case 4:
867 if (maxGPSize <= 3)
868 break;
869 ObjectBuilder::AppendFragment(
870 *frag, *(m_pscommon_4->getSectionData()), (*com_sym)->value());
871 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
872 continue;
873 case 8:
874 if (maxGPSize <= 7)
875 break;
876 ObjectBuilder::AppendFragment(
877 *frag, *(m_pscommon_8->getSectionData()), (*com_sym)->value());
878 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
879 continue;
880 default:
881 break;
882 }
883
884 if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
885 // allocate TLS common symbol in tbss section
886 tbss_offset += ObjectBuilder::AppendFragment(
887 *frag, *tbss_sect_data, (*com_sym)->value());
888 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
889 } else {
890 // FIXME: how to identify small and large common symbols?
891 bss_offset += ObjectBuilder::AppendFragment(
892 *frag, *bss_sect_data, (*com_sym)->value());
893 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
894 }
895 }
896
897 bss_sect.setSize(bss_offset);
898 tbss_sect.setSize(tbss_offset);
899 symbol_list.changeCommonsToGlobal();
900 SetSDataSection();
901 return true;
902 }
903
MoveCommonData(SectionData & pFrom,SectionData & pTo)904 bool HexagonLDBackend::MoveCommonData(SectionData& pFrom, SectionData& pTo) {
905 SectionData::FragmentListType& to_list = pTo.getFragmentList();
906 SectionData::FragmentListType::iterator frag, fragEnd = to_list.end();
907
908 uint32_t pFromFlag = pFrom.getSection().align();
909 bool found = false;
910
911 SectionData::FragmentListType::iterator fragInsert;
912
913 for (frag = to_list.begin(); frag != fragEnd; ++frag) {
914 if (frag->getKind() == mcld::Fragment::Alignment) {
915 fragInsert = frag;
916 continue;
917 }
918 if ((frag->getKind() != mcld::Fragment::Region) &&
919 (frag->getKind() != mcld::Fragment::Fillment)) {
920 continue;
921 }
922 uint32_t flag = frag->getParent()->getSection().align();
923 if (pFromFlag < flag) {
924 found = true;
925 break;
926 }
927 }
928 AlignFragment* align = NULL;
929 if (pFrom.getSection().align() > 1) {
930 // if the align constraint is larger than 1, append an alignment
931 unsigned int alignment = pFrom.getSection().align();
932 align = new AlignFragment(/*alignment*/alignment,
933 /*the filled value*/0x0,
934 /*the size of filled value*/1u,
935 /*max bytes to emit*/alignment - 1);
936 pFrom.getFragmentList().push_front(align);
937 }
938 if (found)
939 to_list.splice(fragInsert, pFrom.getFragmentList());
940 else
941 to_list.splice(frag, pFrom.getFragmentList());
942
943 return true;
944 }
945
readSection(Input & pInput,SectionData & pSD)946 bool HexagonLDBackend::readSection(Input& pInput, SectionData& pSD) {
947 Fragment* frag = NULL;
948 uint32_t offset = pInput.fileOffset() + pSD.getSection().offset();
949 uint32_t size = pSD.getSection().size();
950
951 if (pSD.getSection().type() == llvm::ELF::SHT_NOBITS) {
952 frag = new FillFragment(0x0, 1, size);
953 } else {
954 llvm::StringRef region = pInput.memArea()->request(offset, size);
955 if (region.size() == 0) {
956 // If the input section's size is zero, we got a NULL region.
957 // use a virtual fill fragment
958 frag = new FillFragment(0x0, 0, 0);
959 } else {
960 frag = new RegionFragment(region);
961 }
962 }
963
964 ObjectBuilder::AppendFragment(*frag, pSD);
965 return true;
966 }
967
968 /// MoveSectionData - move the fragments of pTO section data to pTo
MoveSectionDataAndSort(SectionData & pFrom,SectionData & pTo)969 bool HexagonLDBackend::MoveSectionDataAndSort(SectionData& pFrom,
970 SectionData& pTo) {
971 assert(&pFrom != &pTo && "Cannot move section data to itself!");
972 SectionData::FragmentListType& to_list = pTo.getFragmentList();
973 SectionData::FragmentListType::iterator frag, fragEnd = to_list.end();
974
975 uint32_t pFromFlag = pFrom.getSection().align();
976 bool found = false;
977
978 SectionData::FragmentListType::iterator fragInsert;
979
980 for (frag = to_list.begin(); frag != fragEnd; ++frag) {
981 if (frag->getKind() == mcld::Fragment::Alignment) {
982 fragInsert = frag;
983 continue;
984 }
985 if ((frag->getKind() != mcld::Fragment::Region) &&
986 (frag->getKind() != mcld::Fragment::Fillment)) {
987 continue;
988 }
989 uint32_t flag = frag->getParent()->getSection().align();
990 if (pFromFlag < flag) {
991 found = true;
992 break;
993 }
994 }
995 AlignFragment* align = NULL;
996 if (pFrom.getSection().align() > 1) {
997 // if the align constraint is larger than 1, append an alignment
998 unsigned int alignment = pFrom.getSection().align();
999 align = new AlignFragment(/*alignment*/alignment,
1000 /*the filled value*/0x0,
1001 /*the size of filled value*/1u,
1002 /*max bytes to emit*/alignment - 1);
1003 pFrom.getFragmentList().push_front(align);
1004 }
1005 if (found)
1006 to_list.splice(fragInsert, pFrom.getFragmentList());
1007 else
1008 to_list.splice(frag, pFrom.getFragmentList());
1009
1010 uint32_t offset = 0;
1011 for (frag = to_list.begin(); frag != fragEnd; ++frag) {
1012 frag->setOffset(offset);
1013 offset += frag->size();
1014 }
1015
1016 // set up pTo's header
1017 pTo.getSection().setSize(offset);
1018
1019 if (pFrom.getSection().align() > pTo.getSection().align())
1020 pTo.getSection().setAlign(pFrom.getSection().align());
1021
1022 if (pFrom.getSection().flag() > pTo.getSection().flag())
1023 pTo.getSection().setFlag(pFrom.getSection().flag());
1024 return true;
1025 }
1026
1027 /// doCreateProgramHdrs - backend can implement this function to create the
1028 /// target-dependent segments
doCreateProgramHdrs(Module & pModule)1029 void HexagonLDBackend::doCreateProgramHdrs(Module& pModule) {
1030 // TODO
1031 }
1032
1033 //===----------------------------------------------------------------------===//
1034 /// createHexagonLDBackend - the help funtion to create corresponding
1035 /// HexagonLDBackend
createHexagonLDBackend(const LinkerConfig & pConfig)1036 TargetLDBackend* createHexagonLDBackend(const LinkerConfig& pConfig) {
1037 if (pConfig.targets().triple().isOSDarwin()) {
1038 assert(0 && "MachO linker is not supported yet");
1039 /**
1040 return new HexagonMachOLDBackend(createHexagonMachOArchiveReader,
1041 createHexagonMachOObjectReader,
1042 createHexagonMachOObjectWriter);
1043 **/
1044 }
1045 if (pConfig.targets().triple().isOSWindows()) {
1046 assert(0 && "COFF linker is not supported yet");
1047 /**
1048 return new HexagonCOFFLDBackend(createHexagonCOFFArchiveReader,
1049 createHexagonCOFFObjectReader,
1050 createHexagonCOFFObjectWriter);
1051 **/
1052 }
1053 return new HexagonLDBackend(pConfig, new HexagonGNUInfo(pConfig.targets()));
1054 }
1055
1056 } // namespace mcld
1057
1058 //===----------------------------------------------------------------------===//
1059 // Force static initialization.
1060 //===----------------------------------------------------------------------===//
MCLDInitializeHexagonLDBackend()1061 extern "C" void MCLDInitializeHexagonLDBackend() {
1062 // Register the linker backend
1063 mcld::TargetRegistry::RegisterTargetLDBackend(mcld::TheHexagonTarget,
1064 mcld::createHexagonLDBackend);
1065 }
1066