1 //===- MipsLDBackend.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 "Mips.h"
10 #include "MipsGNUInfo.h"
11 #include "MipsELFDynamic.h"
12 #include "MipsLA25Stub.h"
13 #include "MipsLDBackend.h"
14 #include "MipsRelocator.h"
15
16 #include "mcld/IRBuilder.h"
17 #include "mcld/LinkerConfig.h"
18 #include "mcld/Module.h"
19 #include "mcld/Fragment/AlignFragment.h"
20 #include "mcld/Fragment/FillFragment.h"
21 #include "mcld/LD/BranchIslandFactory.h"
22 #include "mcld/LD/LDContext.h"
23 #include "mcld/LD/StubFactory.h"
24 #include "mcld/LD/ELFFileFormat.h"
25 #include "mcld/LD/ELFSegment.h"
26 #include "mcld/LD/ELFSegmentFactory.h"
27 #include "mcld/MC/Attribute.h"
28 #include "mcld/Object/ObjectBuilder.h"
29 #include "mcld/Support/MemoryRegion.h"
30 #include "mcld/Support/MemoryArea.h"
31 #include "mcld/Support/MsgHandling.h"
32 #include "mcld/Support/TargetRegistry.h"
33 #include "mcld/Target/OutputRelocSection.h"
34
35 #include <llvm/ADT/Triple.h>
36 #include <llvm/Object/ELFTypes.h>
37 #include <llvm/Support/Casting.h>
38 #include <llvm/Support/ELF.h>
39 #include <llvm/Support/Host.h>
40 #include <llvm/Support/MipsABIFlags.h>
41
42 #include <vector>
43
44 namespace mcld {
45
46 //===----------------------------------------------------------------------===//
47 // MipsGNULDBackend
48 //===----------------------------------------------------------------------===//
MipsGNULDBackend(const LinkerConfig & pConfig,MipsGNUInfo * pInfo)49 MipsGNULDBackend::MipsGNULDBackend(const LinkerConfig& pConfig,
50 MipsGNUInfo* pInfo)
51 : GNULDBackend(pConfig, pInfo),
52 m_pRelocator(NULL),
53 m_pGOT(NULL),
54 m_pPLT(NULL),
55 m_pGOTPLT(NULL),
56 m_pInfo(*pInfo),
57 m_pRelPlt(NULL),
58 m_pRelDyn(NULL),
59 m_pDynamic(NULL),
60 m_pAbiFlags(NULL),
61 m_pGOTSymbol(NULL),
62 m_pPLTSymbol(NULL),
63 m_pGpDispSymbol(NULL) {
64 }
65
~MipsGNULDBackend()66 MipsGNULDBackend::~MipsGNULDBackend() {
67 delete m_pRelocator;
68 delete m_pPLT;
69 delete m_pRelPlt;
70 delete m_pRelDyn;
71 delete m_pDynamic;
72 }
73
needsLA25Stub(Relocation::Type pType,const mcld::ResolveInfo * pSym)74 bool MipsGNULDBackend::needsLA25Stub(Relocation::Type pType,
75 const mcld::ResolveInfo* pSym) {
76 if (config().isCodeIndep())
77 return false;
78
79 if (llvm::ELF::R_MIPS_26 != pType)
80 return false;
81
82 if (pSym->isLocal())
83 return false;
84
85 return true;
86 }
87
addNonPICBranchSym(ResolveInfo * rsym)88 void MipsGNULDBackend::addNonPICBranchSym(ResolveInfo* rsym) {
89 m_HasNonPICBranchSyms.insert(rsym);
90 }
91
hasNonPICBranch(const ResolveInfo * rsym) const92 bool MipsGNULDBackend::hasNonPICBranch(const ResolveInfo* rsym) const {
93 return m_HasNonPICBranchSyms.count(rsym);
94 }
95
initTargetSections(Module & pModule,ObjectBuilder & pBuilder)96 void MipsGNULDBackend::initTargetSections(Module& pModule,
97 ObjectBuilder& pBuilder) {
98 if (LinkerConfig::Object == config().codeGenType())
99 return;
100
101 ELFFileFormat* file_format = getOutputFormat();
102
103 // initialize .rel.plt
104 LDSection& relplt = file_format->getRelPlt();
105 m_pRelPlt = new OutputRelocSection(pModule, relplt);
106
107 // initialize .rel.dyn
108 LDSection& reldyn = file_format->getRelDyn();
109 m_pRelDyn = new OutputRelocSection(pModule, reldyn);
110
111 // initialize .sdata
112 m_psdata = pBuilder.CreateSection(
113 ".sdata", LDFileFormat::Target, llvm::ELF::SHT_PROGBITS,
114 llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE | llvm::ELF::SHF_MIPS_GPREL,
115 4);
116
117 // initialize .MIPS.abiflags
118 m_pAbiFlags = pBuilder.CreateSection(".MIPS.abiflags", LDFileFormat::Target,
119 llvm::ELF::SHT_MIPS_ABIFLAGS,
120 llvm::ELF::SHF_ALLOC, 4);
121 }
122
initTargetSymbols(IRBuilder & pBuilder,Module & pModule)123 void MipsGNULDBackend::initTargetSymbols(IRBuilder& pBuilder, Module& pModule) {
124 // Define the symbol _GLOBAL_OFFSET_TABLE_ if there is a symbol with the
125 // same name in input
126 m_pGOTSymbol = pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
127 "_GLOBAL_OFFSET_TABLE_",
128 ResolveInfo::Object,
129 ResolveInfo::Define,
130 ResolveInfo::Local,
131 0x0, // size
132 0x0, // value
133 FragmentRef::Null(), // FragRef
134 ResolveInfo::Hidden);
135
136 // Define the symbol _PROCEDURE_LINKAGE_TABLE_ if there is a symbol with the
137 // same name in input
138 m_pPLTSymbol = pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
139 "_PROCEDURE_LINKAGE_TABLE_",
140 ResolveInfo::Object,
141 ResolveInfo::Define,
142 ResolveInfo::Local,
143 0x0, // size
144 0x0, // value
145 FragmentRef::Null(), // FragRef
146 ResolveInfo::Hidden);
147
148 m_pGpDispSymbol =
149 pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Resolve>(
150 "_gp_disp",
151 ResolveInfo::Section,
152 ResolveInfo::Define,
153 ResolveInfo::Absolute,
154 0x0, // size
155 0x0, // value
156 FragmentRef::Null(), // FragRef
157 ResolveInfo::Default);
158
159 pBuilder.AddSymbol<IRBuilder::AsReferred, IRBuilder::Unresolve>(
160 "_gp",
161 ResolveInfo::NoType,
162 ResolveInfo::Define,
163 ResolveInfo::Absolute,
164 0x0, // size
165 0x0, // value
166 FragmentRef::Null(), // FragRef
167 ResolveInfo::Default);
168 }
169
getRelocator() const170 const Relocator* MipsGNULDBackend::getRelocator() const {
171 assert(m_pRelocator != NULL);
172 return m_pRelocator;
173 }
174
getRelocator()175 Relocator* MipsGNULDBackend::getRelocator() {
176 assert(m_pRelocator != NULL);
177 return m_pRelocator;
178 }
179
doPreLayout(IRBuilder & pBuilder)180 void MipsGNULDBackend::doPreLayout(IRBuilder& pBuilder) {
181 // initialize .dynamic data
182 if (!config().isCodeStatic() && m_pDynamic == NULL)
183 m_pDynamic = new MipsELFDynamic(*this, config());
184
185 if (m_pAbiInfo.hasValue())
186 m_pAbiFlags->setSize(m_pAbiInfo->size());
187
188 // set .got size
189 // when building shared object, the .got section is must.
190 if (LinkerConfig::Object != config().codeGenType()) {
191 if (LinkerConfig::DynObj == config().codeGenType() || m_pGOT->hasGOT1() ||
192 m_pGOTSymbol != NULL) {
193 m_pGOT->finalizeScanning(*m_pRelDyn);
194 m_pGOT->finalizeSectionSize();
195
196 defineGOTSymbol(pBuilder);
197 }
198
199 if (m_pGOTPLT->hasGOT1()) {
200 m_pGOTPLT->finalizeSectionSize();
201
202 defineGOTPLTSymbol(pBuilder);
203 }
204
205 if (m_pPLT->hasPLT1())
206 m_pPLT->finalizeSectionSize();
207
208 ELFFileFormat* file_format = getOutputFormat();
209
210 // set .rel.plt size
211 if (!m_pRelPlt->empty()) {
212 assert(
213 !config().isCodeStatic() &&
214 "static linkage should not result in a dynamic relocation section");
215 file_format->getRelPlt().setSize(m_pRelPlt->numOfRelocs() *
216 getRelEntrySize());
217 }
218
219 // set .rel.dyn size
220 if (!m_pRelDyn->empty()) {
221 assert(
222 !config().isCodeStatic() &&
223 "static linkage should not result in a dynamic relocation section");
224 file_format->getRelDyn().setSize(m_pRelDyn->numOfRelocs() *
225 getRelEntrySize());
226 }
227 }
228 }
229
doPostLayout(Module & pModule,IRBuilder & pBuilder)230 void MipsGNULDBackend::doPostLayout(Module& pModule, IRBuilder& pBuilder) {
231 const ELFFileFormat* format = getOutputFormat();
232
233 if (format->hasGOTPLT()) {
234 assert(m_pGOTPLT != NULL && "doPostLayout failed, m_pGOTPLT is NULL!");
235 m_pGOTPLT->applyAllGOTPLT(m_pPLT->addr());
236 }
237
238 if (format->hasPLT()) {
239 assert(m_pPLT != NULL && "doPostLayout failed, m_pPLT is NULL!");
240 m_pPLT->applyAllPLT(*m_pGOTPLT);
241 }
242
243 m_pInfo.setABIVersion(m_pPLT && m_pPLT->hasPLT1() ? 1 : 0);
244 }
245
246 /// dynamic - the dynamic section of the target machine.
247 /// Use co-variant return type to return its own dynamic section.
dynamic()248 MipsELFDynamic& MipsGNULDBackend::dynamic() {
249 assert(m_pDynamic != NULL);
250 return *m_pDynamic;
251 }
252
253 /// dynamic - the dynamic section of the target machine.
254 /// Use co-variant return type to return its own dynamic section.
dynamic() const255 const MipsELFDynamic& MipsGNULDBackend::dynamic() const {
256 assert(m_pDynamic != NULL);
257 return *m_pDynamic;
258 }
259
emitSectionData(const LDSection & pSection,MemoryRegion & pRegion) const260 uint64_t MipsGNULDBackend::emitSectionData(const LDSection& pSection,
261 MemoryRegion& pRegion) const {
262 assert(pRegion.size() && "Size of MemoryRegion is zero!");
263
264 const ELFFileFormat* file_format = getOutputFormat();
265
266 if (file_format->hasGOT() && (&pSection == &(file_format->getGOT()))) {
267 return m_pGOT->emit(pRegion);
268 }
269
270 if (file_format->hasPLT() && (&pSection == &(file_format->getPLT()))) {
271 return m_pPLT->emit(pRegion);
272 }
273
274 if (file_format->hasGOTPLT() && (&pSection == &(file_format->getGOTPLT()))) {
275 return m_pGOTPLT->emit(pRegion);
276 }
277
278 if (&pSection == m_pAbiFlags && m_pAbiInfo.hasValue())
279 return MipsAbiFlags::emit(*m_pAbiInfo, pRegion);
280
281 if (&pSection == m_psdata && m_psdata->hasSectionData()) {
282 const SectionData* sect_data = pSection.getSectionData();
283 SectionData::const_iterator frag_iter, frag_end = sect_data->end();
284 uint8_t* out_offset = pRegion.begin();
285 for (frag_iter = sect_data->begin(); frag_iter != frag_end; ++frag_iter) {
286 size_t size = frag_iter->size();
287 switch (frag_iter->getKind()) {
288 case Fragment::Fillment: {
289 const FillFragment& fill_frag = llvm::cast<FillFragment>(*frag_iter);
290 if (fill_frag.getValueSize() == 0) {
291 // virtual fillment, ignore it.
292 break;
293 }
294 memset(out_offset, fill_frag.getValue(), fill_frag.size());
295 break;
296 }
297 case Fragment::Region: {
298 const RegionFragment& region_frag =
299 llvm::cast<RegionFragment>(*frag_iter);
300 const char* start = region_frag.getRegion().begin();
301 memcpy(out_offset, start, size);
302 break;
303 }
304 case Fragment::Alignment: {
305 const AlignFragment& align_frag =
306 llvm::cast<AlignFragment>(*frag_iter);
307 uint64_t count = size / align_frag.getValueSize();
308 switch (align_frag.getValueSize()) {
309 case 1u:
310 std::memset(out_offset, align_frag.getValue(), count);
311 break;
312 default:
313 llvm::report_fatal_error(
314 "unsupported value size for align fragment emission yet.\n");
315 break;
316 } // end switch
317 break;
318 }
319 case Fragment::Null: {
320 assert(0x0 == size);
321 break;
322 }
323 default:
324 llvm::report_fatal_error("unsupported fragment type.\n");
325 break;
326 } // end switch
327 out_offset += size;
328 }
329 return pRegion.size();
330 }
331
332 fatal(diag::unrecognized_output_sectoin) << pSection.name()
333 << "mclinker@googlegroups.com";
334 return 0;
335 }
336
hasEntryInStrTab(const LDSymbol & pSym) const337 bool MipsGNULDBackend::hasEntryInStrTab(const LDSymbol& pSym) const {
338 return ResolveInfo::Section != pSym.type() || m_pGpDispSymbol == &pSym;
339 }
340
341 namespace {
342 struct DynsymGOTCompare {
343 const MipsGOT& m_pGOT;
344
DynsymGOTComparemcld::__anon44e4591a0111::DynsymGOTCompare345 explicit DynsymGOTCompare(const MipsGOT& pGOT) : m_pGOT(pGOT) {}
346
operator ()mcld::__anon44e4591a0111::DynsymGOTCompare347 bool operator()(const LDSymbol* X, const LDSymbol* Y) const {
348 return m_pGOT.dynSymOrderCompare(X, Y);
349 }
350 };
351 } // anonymous namespace
352
orderSymbolTable(Module & pModule)353 void MipsGNULDBackend::orderSymbolTable(Module& pModule) {
354 if (config().options().hasGNUHash()) {
355 // The MIPS ABI and .gnu.hash require .dynsym to be sorted
356 // in different ways. The MIPS ABI requires a mapping between
357 // the GOT and the symbol table. At the same time .gnu.hash
358 // needs symbols to be grouped by hash code.
359 llvm::errs() << ".gnu.hash is incompatible with the MIPS ABI\n";
360 }
361
362 Module::SymbolTable& symbols = pModule.getSymbolTable();
363
364 std::stable_sort(
365 symbols.dynamicBegin(), symbols.dynamicEnd(), DynsymGOTCompare(*m_pGOT));
366 }
367
368 } // namespace mcld
369
370 namespace llvm {
371 namespace ELF {
372 // SHT_MIPS_OPTIONS section's block descriptor.
373 struct Elf_Options {
374 unsigned char kind; // Determines interpretation of variable
375 // part of descriptor. See ODK_xxx enumeration.
376 unsigned char size; // Byte size of descriptor, including this header.
377 Elf64_Half section; // Section header index of section affected,
378 // or 0 for global options.
379 Elf64_Word info; // Kind-specific information.
380 };
381
382 // Content of ODK_REGINFO block in SHT_MIPS_OPTIONS section on 32 bit ABI.
383 struct Elf32_RegInfo {
384 Elf32_Word ri_gprmask; // Mask of general purpose registers used.
385 Elf32_Word ri_cprmask[4]; // Mask of co-processor registers used.
386 Elf32_Addr ri_gp_value; // GP register value for this object file.
387 };
388
389 // Content of ODK_REGINFO block in SHT_MIPS_OPTIONS section on 64 bit ABI.
390 struct Elf64_RegInfo {
391 Elf32_Word ri_gprmask; // Mask of general purpose registers used.
392 Elf32_Word ri_pad; // Padding.
393 Elf32_Word ri_cprmask[4]; // Mask of co-processor registers used.
394 Elf64_Addr ri_gp_value; // GP register value for this object file.
395 };
396
397 } // namespace ELF
398 } // namespace llvm
399
400 namespace mcld {
401
ArchName(uint64_t flagBits)402 static const char* ArchName(uint64_t flagBits) {
403 switch (flagBits) {
404 case llvm::ELF::EF_MIPS_ARCH_1:
405 return "mips1";
406 case llvm::ELF::EF_MIPS_ARCH_2:
407 return "mips2";
408 case llvm::ELF::EF_MIPS_ARCH_3:
409 return "mips3";
410 case llvm::ELF::EF_MIPS_ARCH_4:
411 return "mips4";
412 case llvm::ELF::EF_MIPS_ARCH_5:
413 return "mips5";
414 case llvm::ELF::EF_MIPS_ARCH_32:
415 return "mips32";
416 case llvm::ELF::EF_MIPS_ARCH_64:
417 return "mips64";
418 case llvm::ELF::EF_MIPS_ARCH_32R2:
419 return "mips32r2";
420 case llvm::ELF::EF_MIPS_ARCH_64R2:
421 return "mips64r2";
422 case llvm::ELF::EF_MIPS_ARCH_32R6:
423 return "mips32r6";
424 case llvm::ELF::EF_MIPS_ARCH_64R6:
425 return "mips64r6";
426 default:
427 return "Unknown Arch";
428 }
429 }
430
mergeFlags(Input & pInput,const char * ELF_hdr)431 void MipsGNULDBackend::mergeFlags(Input& pInput, const char* ELF_hdr) {
432 bool isTarget64Bit = config().targets().triple().isArch64Bit();
433 bool isInput64Bit = ELF_hdr[llvm::ELF::EI_CLASS] == llvm::ELF::ELFCLASS64;
434
435 if (isTarget64Bit != isInput64Bit) {
436 fatal(diag::error_Mips_incompatible_class)
437 << (isTarget64Bit ? "ELFCLASS64" : "ELFCLASS32")
438 << (isInput64Bit ? "ELFCLASS64" : "ELFCLASS32") << pInput.name();
439 return;
440 }
441
442 m_ElfFlagsMap[&pInput] =
443 isInput64Bit ?
444 reinterpret_cast<const llvm::ELF::Elf64_Ehdr*>(ELF_hdr)->e_flags :
445 reinterpret_cast<const llvm::ELF::Elf32_Ehdr*>(ELF_hdr)->e_flags;
446 }
447
readSection(Input & pInput,SectionData & pSD)448 bool MipsGNULDBackend::readSection(Input& pInput, SectionData& pSD) {
449 if ((pSD.getSection().flag() & llvm::ELF::SHF_MIPS_GPREL) ||
450 (pSD.getSection().type() == llvm::ELF::SHT_MIPS_ABIFLAGS)) {
451 uint64_t offset = pInput.fileOffset() + pSD.getSection().offset();
452 uint64_t size = pSD.getSection().size();
453
454 Fragment* frag = IRBuilder::CreateRegion(pInput, offset, size);
455 ObjectBuilder::AppendFragment(*frag, pSD);
456 return true;
457 }
458
459 if (pSD.getSection().type() == llvm::ELF::SHT_MIPS_OPTIONS) {
460 uint32_t offset = pInput.fileOffset() + pSD.getSection().offset();
461 uint32_t size = pSD.getSection().size();
462
463 llvm::StringRef region = pInput.memArea()->request(offset, size);
464 if (region.size() > 0) {
465 const llvm::ELF::Elf_Options* optb =
466 reinterpret_cast<const llvm::ELF::Elf_Options*>(region.begin());
467 const llvm::ELF::Elf_Options* opte =
468 reinterpret_cast<const llvm::ELF::Elf_Options*>(region.begin() +
469 size);
470
471 for (const llvm::ELF::Elf_Options* opt = optb; opt < opte;
472 opt += opt->size) {
473 switch (opt->kind) {
474 default:
475 // Nothing to do.
476 break;
477 case llvm::ELF::ODK_REGINFO:
478 if (config().targets().triple().isArch32Bit()) {
479 const llvm::ELF::Elf32_RegInfo* reg =
480 reinterpret_cast<const llvm::ELF::Elf32_RegInfo*>(opt + 1);
481 m_GP0Map[&pInput] = reg->ri_gp_value;
482 } else {
483 const llvm::ELF::Elf64_RegInfo* reg =
484 reinterpret_cast<const llvm::ELF::Elf64_RegInfo*>(opt + 1);
485 m_GP0Map[&pInput] = reg->ri_gp_value;
486 }
487 break;
488 }
489 }
490 }
491
492 return true;
493 }
494
495 return GNULDBackend::readSection(pInput, pSD);
496 }
497
getGOT()498 MipsGOT& MipsGNULDBackend::getGOT() {
499 assert(m_pGOT != NULL);
500 return *m_pGOT;
501 }
502
getGOT() const503 const MipsGOT& MipsGNULDBackend::getGOT() const {
504 assert(m_pGOT != NULL);
505 return *m_pGOT;
506 }
507
getPLT()508 MipsPLT& MipsGNULDBackend::getPLT() {
509 assert(m_pPLT != NULL);
510 return *m_pPLT;
511 }
512
getPLT() const513 const MipsPLT& MipsGNULDBackend::getPLT() const {
514 assert(m_pPLT != NULL);
515 return *m_pPLT;
516 }
517
getGOTPLT()518 MipsGOTPLT& MipsGNULDBackend::getGOTPLT() {
519 assert(m_pGOTPLT != NULL);
520 return *m_pGOTPLT;
521 }
522
getGOTPLT() const523 const MipsGOTPLT& MipsGNULDBackend::getGOTPLT() const {
524 assert(m_pGOTPLT != NULL);
525 return *m_pGOTPLT;
526 }
527
getRelPLT()528 OutputRelocSection& MipsGNULDBackend::getRelPLT() {
529 assert(m_pRelPlt != NULL);
530 return *m_pRelPlt;
531 }
532
getRelPLT() const533 const OutputRelocSection& MipsGNULDBackend::getRelPLT() const {
534 assert(m_pRelPlt != NULL);
535 return *m_pRelPlt;
536 }
537
getRelDyn()538 OutputRelocSection& MipsGNULDBackend::getRelDyn() {
539 assert(m_pRelDyn != NULL);
540 return *m_pRelDyn;
541 }
542
getRelDyn() const543 const OutputRelocSection& MipsGNULDBackend::getRelDyn() const {
544 assert(m_pRelDyn != NULL);
545 return *m_pRelDyn;
546 }
547
getTargetSectionOrder(const LDSection & pSectHdr) const548 unsigned int MipsGNULDBackend::getTargetSectionOrder(
549 const LDSection& pSectHdr) const {
550 const ELFFileFormat* file_format = getOutputFormat();
551
552 if (file_format->hasGOT() && (&pSectHdr == &file_format->getGOT()))
553 return SHO_DATA;
554
555 if (file_format->hasGOTPLT() && (&pSectHdr == &file_format->getGOTPLT()))
556 return SHO_DATA;
557
558 if (file_format->hasPLT() && (&pSectHdr == &file_format->getPLT()))
559 return SHO_PLT;
560
561 if (&pSectHdr == m_psdata)
562 return SHO_SMALL_DATA;
563
564 if (&pSectHdr == m_pAbiFlags)
565 return SHO_RO_NOTE;
566
567 return SHO_UNDEFINED;
568 }
569
570 /// finalizeSymbol - finalize the symbol value
finalizeTargetSymbols()571 bool MipsGNULDBackend::finalizeTargetSymbols() {
572 if (m_pGpDispSymbol != NULL)
573 m_pGpDispSymbol->setValue(m_pGOT->getGPDispAddress());
574
575 return true;
576 }
577
578 /// allocateCommonSymbols - allocate common symbols in the corresponding
579 /// sections. This is called at pre-layout stage.
580 /// FIXME: Mips needs to allocate small common symbol
allocateCommonSymbols(Module & pModule)581 bool MipsGNULDBackend::allocateCommonSymbols(Module& pModule) {
582 SymbolCategory& symbol_list = pModule.getSymbolTable();
583
584 if (symbol_list.emptyCommons() && symbol_list.emptyFiles() &&
585 symbol_list.emptyLocals() && symbol_list.emptyLocalDyns())
586 return true;
587
588 SymbolCategory::iterator com_sym, com_end;
589
590 // FIXME: If the order of common symbols is defined, then sort common symbols
591 // std::sort(com_sym, com_end, some kind of order);
592
593 // get corresponding BSS LDSection
594 ELFFileFormat* file_format = getOutputFormat();
595 LDSection& bss_sect = file_format->getBSS();
596 LDSection& tbss_sect = file_format->getTBSS();
597
598 // get or create corresponding BSS SectionData
599 SectionData* bss_sect_data = NULL;
600 if (bss_sect.hasSectionData())
601 bss_sect_data = bss_sect.getSectionData();
602 else
603 bss_sect_data = IRBuilder::CreateSectionData(bss_sect);
604
605 SectionData* tbss_sect_data = NULL;
606 if (tbss_sect.hasSectionData())
607 tbss_sect_data = tbss_sect.getSectionData();
608 else
609 tbss_sect_data = IRBuilder::CreateSectionData(tbss_sect);
610
611 // remember original BSS size
612 uint64_t bss_offset = bss_sect.size();
613 uint64_t tbss_offset = tbss_sect.size();
614
615 // allocate all local common symbols
616 com_end = symbol_list.localEnd();
617
618 for (com_sym = symbol_list.localBegin(); com_sym != com_end; ++com_sym) {
619 if (ResolveInfo::Common == (*com_sym)->desc()) {
620 // We have to reset the description of the symbol here. When doing
621 // incremental linking, the output relocatable object may have common
622 // symbols. Therefore, we can not treat common symbols as normal symbols
623 // when emitting the regular name pools. We must change the symbols'
624 // description here.
625 (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
626 Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
627
628 if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
629 // allocate TLS common symbol in tbss section
630 tbss_offset += ObjectBuilder::AppendFragment(
631 *frag, *tbss_sect_data, (*com_sym)->value());
632 ObjectBuilder::UpdateSectionAlign(tbss_sect, (*com_sym)->value());
633 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
634 } else {
635 // FIXME: how to identify small and large common symbols?
636 bss_offset += ObjectBuilder::AppendFragment(
637 *frag, *bss_sect_data, (*com_sym)->value());
638 ObjectBuilder::UpdateSectionAlign(bss_sect, (*com_sym)->value());
639 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
640 }
641 }
642 }
643
644 // allocate all global common symbols
645 com_end = symbol_list.commonEnd();
646 for (com_sym = symbol_list.commonBegin(); com_sym != com_end; ++com_sym) {
647 // We have to reset the description of the symbol here. When doing
648 // incremental linking, the output relocatable object may have common
649 // symbols. Therefore, we can not treat common symbols as normal symbols
650 // when emitting the regular name pools. We must change the symbols'
651 // description here.
652 (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
653 Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
654
655 if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
656 // allocate TLS common symbol in tbss section
657 tbss_offset += ObjectBuilder::AppendFragment(
658 *frag, *tbss_sect_data, (*com_sym)->value());
659 ObjectBuilder::UpdateSectionAlign(tbss_sect, (*com_sym)->value());
660 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
661 } else {
662 // FIXME: how to identify small and large common symbols?
663 bss_offset += ObjectBuilder::AppendFragment(
664 *frag, *bss_sect_data, (*com_sym)->value());
665 ObjectBuilder::UpdateSectionAlign(bss_sect, (*com_sym)->value());
666 (*com_sym)->setFragmentRef(FragmentRef::Create(*frag, 0));
667 }
668 }
669
670 bss_sect.setSize(bss_offset);
671 tbss_sect.setSize(tbss_offset);
672 symbol_list.changeCommonsToGlobal();
673 return true;
674 }
675
getTPOffset(const Input & pInput) const676 uint64_t MipsGNULDBackend::getTPOffset(const Input& pInput) const {
677 return m_TpOffsetMap.lookup(&pInput);
678 }
679
getDTPOffset(const Input & pInput) const680 uint64_t MipsGNULDBackend::getDTPOffset(const Input& pInput) const {
681 return m_DtpOffsetMap.lookup(&pInput);
682 }
683
getGP0(const Input & pInput) const684 uint64_t MipsGNULDBackend::getGP0(const Input& pInput) const {
685 return m_GP0Map.lookup(&pInput);
686 }
687
defineGOTSymbol(IRBuilder & pBuilder)688 void MipsGNULDBackend::defineGOTSymbol(IRBuilder& pBuilder) {
689 // If we do not reserve any GOT entries, we do not need to re-define GOT
690 // symbol.
691 if (!m_pGOT->hasGOT1())
692 return;
693
694 // define symbol _GLOBAL_OFFSET_TABLE_
695 if (m_pGOTSymbol != NULL) {
696 pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
697 "_GLOBAL_OFFSET_TABLE_",
698 ResolveInfo::Object,
699 ResolveInfo::Define,
700 ResolveInfo::Local,
701 0x0, // size
702 0x0, // value
703 FragmentRef::Create(*(m_pGOT->begin()), 0x0),
704 ResolveInfo::Hidden);
705 } else {
706 m_pGOTSymbol = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
707 "_GLOBAL_OFFSET_TABLE_",
708 ResolveInfo::Object,
709 ResolveInfo::Define,
710 ResolveInfo::Local,
711 0x0, // size
712 0x0, // value
713 FragmentRef::Create(*(m_pGOT->begin()), 0x0),
714 ResolveInfo::Hidden);
715 }
716 }
717
defineGOTPLTSymbol(IRBuilder & pBuilder)718 void MipsGNULDBackend::defineGOTPLTSymbol(IRBuilder& pBuilder) {
719 // define symbol _PROCEDURE_LINKAGE_TABLE_
720 if (m_pPLTSymbol != NULL) {
721 pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Unresolve>(
722 "_PROCEDURE_LINKAGE_TABLE_",
723 ResolveInfo::Object,
724 ResolveInfo::Define,
725 ResolveInfo::Local,
726 0x0, // size
727 0x0, // value
728 FragmentRef::Create(*(m_pPLT->begin()), 0x0),
729 ResolveInfo::Hidden);
730 } else {
731 m_pPLTSymbol = pBuilder.AddSymbol<IRBuilder::Force, IRBuilder::Resolve>(
732 "_PROCEDURE_LINKAGE_TABLE_",
733 ResolveInfo::Object,
734 ResolveInfo::Define,
735 ResolveInfo::Local,
736 0x0, // size
737 0x0, // value
738 FragmentRef::Create(*(m_pPLT->begin()), 0x0),
739 ResolveInfo::Hidden);
740 }
741 }
742
743 /// doCreateProgramHdrs - backend can implement this function to create the
744 /// target-dependent segments
doCreateProgramHdrs(Module & pModule)745 void MipsGNULDBackend::doCreateProgramHdrs(Module& pModule) {
746 if (!m_pAbiFlags || m_pAbiFlags->size() == 0)
747 return;
748
749 // create PT_MIPS_ABIFLAGS segment
750 ELFSegmentFactory::iterator sit =
751 elfSegmentTable().find(llvm::ELF::PT_INTERP, 0x0, 0x0);
752 if (sit == elfSegmentTable().end())
753 sit = elfSegmentTable().find(llvm::ELF::PT_PHDR, 0x0, 0x0);
754 if (sit == elfSegmentTable().end())
755 sit = elfSegmentTable().begin();
756 else
757 ++sit;
758
759 ELFSegment* abiSeg = elfSegmentTable().insert(sit,
760 llvm::ELF::PT_MIPS_ABIFLAGS,
761 llvm::ELF::PF_R);
762 abiSeg->setAlign(8);
763 abiSeg->append(m_pAbiFlags);
764 }
765
relaxRelocation(IRBuilder & pBuilder,Relocation & pRel)766 bool MipsGNULDBackend::relaxRelocation(IRBuilder& pBuilder, Relocation& pRel) {
767 uint64_t sym_value = 0x0;
768
769 LDSymbol* symbol = pRel.symInfo()->outSymbol();
770 if (symbol->hasFragRef()) {
771 uint64_t value = symbol->fragRef()->getOutputOffset();
772 uint64_t addr = symbol->fragRef()->frag()->getParent()->getSection().addr();
773 sym_value = addr + value;
774 }
775
776 Stub* stub = getStubFactory()->create(
777 pRel, sym_value, pBuilder, *getBRIslandFactory());
778
779 if (stub == NULL)
780 return false;
781
782 assert(stub->symInfo() != NULL);
783 // reset the branch target of the reloc to this stub instead
784 pRel.setSymInfo(stub->symInfo());
785
786 // increase the size of .symtab and .strtab
787 LDSection& symtab = getOutputFormat()->getSymTab();
788 LDSection& strtab = getOutputFormat()->getStrTab();
789 symtab.setSize(symtab.size() + sizeof(llvm::ELF::Elf32_Sym));
790 strtab.setSize(strtab.size() + stub->symInfo()->nameSize() + 1);
791
792 return true;
793 }
794
doRelax(Module & pModule,IRBuilder & pBuilder,bool & pFinished)795 bool MipsGNULDBackend::doRelax(Module& pModule,
796 IRBuilder& pBuilder,
797 bool& pFinished) {
798 assert(getStubFactory() != NULL && getBRIslandFactory() != NULL);
799
800 bool isRelaxed = false;
801
802 for (Module::obj_iterator input = pModule.obj_begin();
803 input != pModule.obj_end();
804 ++input) {
805 LDContext* context = (*input)->context();
806
807 for (LDContext::sect_iterator rs = context->relocSectBegin();
808 rs != context->relocSectEnd();
809 ++rs) {
810 LDSection* sec = *rs;
811
812 if (LDFileFormat::Ignore == sec->kind() || !sec->hasRelocData())
813 continue;
814
815 for (RelocData::iterator reloc = sec->getRelocData()->begin();
816 reloc != sec->getRelocData()->end();
817 ++reloc) {
818 if (llvm::ELF::R_MIPS_26 != reloc->type())
819 continue;
820
821 if (relaxRelocation(pBuilder, *llvm::cast<Relocation>(reloc)))
822 isRelaxed = true;
823 }
824 }
825 }
826
827 // find the first fragment w/ invalid offset due to stub insertion
828 std::vector<Fragment*> invalid_frags;
829 pFinished = true;
830 for (BranchIslandFactory::iterator ii = getBRIslandFactory()->begin(),
831 ie = getBRIslandFactory()->end();
832 ii != ie;
833 ++ii) {
834 BranchIsland& island = *ii;
835 if (island.size() > stubGroupSize()) {
836 error(diag::err_no_space_to_place_stubs) << stubGroupSize();
837 return false;
838 }
839
840 if (island.numOfStubs() == 0) {
841 continue;
842 }
843
844 Fragment* exit = &*island.end();
845 if (exit == &*island.begin()->getParent()->end()) {
846 continue;
847 }
848
849 if ((island.offset() + island.size()) > exit->getOffset()) {
850 if (invalid_frags.empty() ||
851 (invalid_frags.back()->getParent() != island.getParent())) {
852 invalid_frags.push_back(exit);
853 pFinished = false;
854 }
855 continue;
856 }
857 }
858
859 // reset the offset of invalid fragments
860 for (auto it = invalid_frags.begin(), ie = invalid_frags.end(); it != ie;
861 ++it) {
862 Fragment* invalid = *it;
863 while (invalid != NULL) {
864 invalid->setOffset(invalid->getPrevNode()->getOffset() +
865 invalid->getPrevNode()->size());
866 invalid = invalid->getNextNode();
867 }
868 }
869
870 // reset the size of section that has stubs inserted.
871 if (isRelaxed) {
872 SectionData* prev = NULL;
873 for (BranchIslandFactory::iterator island = getBRIslandFactory()->begin(),
874 island_end = getBRIslandFactory()->end();
875 island != island_end;
876 ++island) {
877 SectionData* sd = (*island).begin()->getParent();
878 if ((*island).numOfStubs() != 0) {
879 if (sd != prev) {
880 sd->getSection().setSize(sd->back().getOffset() + sd->back().size());
881 }
882 }
883 prev = sd;
884 }
885 }
886
887 return isRelaxed;
888 }
889
initTargetStubs()890 bool MipsGNULDBackend::initTargetStubs() {
891 if (getStubFactory() == NULL)
892 return false;
893
894 getStubFactory()->addPrototype(new MipsLA25Stub(*this));
895 return true;
896 }
897
readRelocation(const llvm::ELF::Elf32_Rel & pRel,Relocation::Type & pType,uint32_t & pSymIdx,uint32_t & pOffset) const898 bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf32_Rel& pRel,
899 Relocation::Type& pType,
900 uint32_t& pSymIdx,
901 uint32_t& pOffset) const {
902 return GNULDBackend::readRelocation(pRel, pType, pSymIdx, pOffset);
903 }
904
readRelocation(const llvm::ELF::Elf32_Rela & pRel,Relocation::Type & pType,uint32_t & pSymIdx,uint32_t & pOffset,int32_t & pAddend) const905 bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf32_Rela& pRel,
906 Relocation::Type& pType,
907 uint32_t& pSymIdx,
908 uint32_t& pOffset,
909 int32_t& pAddend) const {
910 return GNULDBackend::readRelocation(pRel, pType, pSymIdx, pOffset, pAddend);
911 }
912
readRelocation(const llvm::ELF::Elf64_Rel & pRel,Relocation::Type & pType,uint32_t & pSymIdx,uint64_t & pOffset) const913 bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf64_Rel& pRel,
914 Relocation::Type& pType,
915 uint32_t& pSymIdx,
916 uint64_t& pOffset) const {
917 uint64_t r_info = 0x0;
918 if (llvm::sys::IsLittleEndianHost) {
919 pOffset = pRel.r_offset;
920 r_info = pRel.r_info;
921 } else {
922 pOffset = mcld::bswap64(pRel.r_offset);
923 r_info = mcld::bswap64(pRel.r_info);
924 }
925
926 // MIPS 64 little endian (we do not support big endian now)
927 // has a "special" encoding of r_info relocation
928 // field. Instead of one 64 bit little endian number, it is a little
929 // endian 32 bit number followed by a 32 bit big endian number.
930 pType = mcld::bswap32(r_info >> 32);
931 pSymIdx = r_info & 0xffffffff;
932 return true;
933 }
934
readRelocation(const llvm::ELF::Elf64_Rela & pRel,Relocation::Type & pType,uint32_t & pSymIdx,uint64_t & pOffset,int64_t & pAddend) const935 bool MipsGNULDBackend::readRelocation(const llvm::ELF::Elf64_Rela& pRel,
936 Relocation::Type& pType,
937 uint32_t& pSymIdx,
938 uint64_t& pOffset,
939 int64_t& pAddend) const {
940 uint64_t r_info = 0x0;
941 if (llvm::sys::IsLittleEndianHost) {
942 pOffset = pRel.r_offset;
943 r_info = pRel.r_info;
944 pAddend = pRel.r_addend;
945 } else {
946 pOffset = mcld::bswap64(pRel.r_offset);
947 r_info = mcld::bswap64(pRel.r_info);
948 pAddend = mcld::bswap64(pRel.r_addend);
949 }
950
951 pType = mcld::bswap32(r_info >> 32);
952 pSymIdx = r_info & 0xffffffff;
953 return true;
954 }
955
emitRelocation(llvm::ELF::Elf32_Rel & pRel,Relocation::Type pType,uint32_t pSymIdx,uint32_t pOffset) const956 void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf32_Rel& pRel,
957 Relocation::Type pType,
958 uint32_t pSymIdx,
959 uint32_t pOffset) const {
960 GNULDBackend::emitRelocation(pRel, pType, pSymIdx, pOffset);
961 }
962
emitRelocation(llvm::ELF::Elf32_Rela & pRel,Relocation::Type pType,uint32_t pSymIdx,uint32_t pOffset,int32_t pAddend) const963 void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf32_Rela& pRel,
964 Relocation::Type pType,
965 uint32_t pSymIdx,
966 uint32_t pOffset,
967 int32_t pAddend) const {
968 GNULDBackend::emitRelocation(pRel, pType, pSymIdx, pOffset, pAddend);
969 }
970
emitRelocation(llvm::ELF::Elf64_Rel & pRel,Relocation::Type pType,uint32_t pSymIdx,uint64_t pOffset) const971 void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf64_Rel& pRel,
972 Relocation::Type pType,
973 uint32_t pSymIdx,
974 uint64_t pOffset) const {
975 uint64_t r_info = mcld::bswap32(pType);
976 r_info <<= 32;
977 r_info |= pSymIdx;
978
979 pRel.r_info = r_info;
980 pRel.r_offset = pOffset;
981 }
982
emitRelocation(llvm::ELF::Elf64_Rela & pRel,Relocation::Type pType,uint32_t pSymIdx,uint64_t pOffset,int64_t pAddend) const983 void MipsGNULDBackend::emitRelocation(llvm::ELF::Elf64_Rela& pRel,
984 Relocation::Type pType,
985 uint32_t pSymIdx,
986 uint64_t pOffset,
987 int64_t pAddend) const {
988 uint64_t r_info = mcld::bswap32(pType);
989 r_info <<= 32;
990 r_info |= pSymIdx;
991
992 pRel.r_info = r_info;
993 pRel.r_offset = pOffset;
994 pRel.r_addend = pAddend;
995 }
996
997 namespace {
998 struct ISATreeEdge {
999 unsigned child;
1000 unsigned parent;
1001 };
1002 }
1003
1004 static ISATreeEdge isaTree[] = {
1005 // MIPS32R6 and MIPS64R6 are not compatible with other extensions
1006
1007 // MIPS64 extensions.
1008 {llvm::ELF::EF_MIPS_ARCH_64R2, llvm::ELF::EF_MIPS_ARCH_64},
1009 // MIPS V extensions.
1010 {llvm::ELF::EF_MIPS_ARCH_64, llvm::ELF::EF_MIPS_ARCH_5},
1011 // MIPS IV extensions.
1012 {llvm::ELF::EF_MIPS_ARCH_5, llvm::ELF::EF_MIPS_ARCH_4},
1013 // MIPS III extensions.
1014 {llvm::ELF::EF_MIPS_ARCH_4, llvm::ELF::EF_MIPS_ARCH_3},
1015 // MIPS32 extensions.
1016 {llvm::ELF::EF_MIPS_ARCH_32R2, llvm::ELF::EF_MIPS_ARCH_32},
1017 // MIPS II extensions.
1018 {llvm::ELF::EF_MIPS_ARCH_3, llvm::ELF::EF_MIPS_ARCH_2},
1019 {llvm::ELF::EF_MIPS_ARCH_32, llvm::ELF::EF_MIPS_ARCH_2},
1020 // MIPS I extensions.
1021 {llvm::ELF::EF_MIPS_ARCH_2, llvm::ELF::EF_MIPS_ARCH_1},
1022 };
1023
isIsaMatched(uint32_t base,uint32_t ext)1024 static bool isIsaMatched(uint32_t base, uint32_t ext) {
1025 if (base == ext)
1026 return true;
1027 if (base == llvm::ELF::EF_MIPS_ARCH_32 &&
1028 isIsaMatched(llvm::ELF::EF_MIPS_ARCH_64, ext))
1029 return true;
1030 if (base == llvm::ELF::EF_MIPS_ARCH_32R2 &&
1031 isIsaMatched(llvm::ELF::EF_MIPS_ARCH_64R2, ext))
1032 return true;
1033 for (const auto &edge : isaTree) {
1034 if (ext == edge.child) {
1035 ext = edge.parent;
1036 if (ext == base)
1037 return true;
1038 }
1039 }
1040 return false;
1041 }
1042
getAbiFlags(const Input & pInput,uint64_t elfFlags,bool & hasFlags,MipsAbiFlags & pFlags)1043 static bool getAbiFlags(const Input& pInput, uint64_t elfFlags, bool& hasFlags,
1044 MipsAbiFlags& pFlags) {
1045 MipsAbiFlags pElfFlags = {};
1046 if (!MipsAbiFlags::fillByElfFlags(pInput, elfFlags, pElfFlags))
1047 return false;
1048
1049 const LDContext* ctx = pInput.context();
1050 for (auto it = ctx->sectBegin(), ie = ctx->sectEnd(); it != ie; ++it)
1051 if ((*it)->type() == llvm::ELF::SHT_MIPS_ABIFLAGS) {
1052 if (!MipsAbiFlags::fillBySection(pInput, **it, pFlags))
1053 return false;
1054 if (!MipsAbiFlags::isCompatible(pInput, pElfFlags, pFlags))
1055 return false;
1056 hasFlags = true;
1057 return true;
1058 }
1059
1060 pFlags = pElfFlags;
1061 return true;
1062 }
1063
getNanName(uint64_t flags)1064 static const char* getNanName(uint64_t flags) {
1065 return flags & llvm::ELF::EF_MIPS_NAN2008 ? "2008" : "legacy";
1066 }
1067
mergeElfFlags(const Input & pInput,uint64_t & oldElfFlags,uint64_t newElfFlags)1068 static bool mergeElfFlags(const Input& pInput, uint64_t& oldElfFlags,
1069 uint64_t newElfFlags) {
1070 // PIC code is inherently CPIC and may not set CPIC flag explicitly.
1071 // Ensure that this flag will exist in the linked file.
1072 if (newElfFlags & llvm::ELF::EF_MIPS_PIC)
1073 newElfFlags |= llvm::ELF::EF_MIPS_CPIC;
1074
1075 if (newElfFlags & llvm::ELF::EF_MIPS_ARCH_ASE_M16) {
1076 error(diag::error_Mips_m16_unsupported) << pInput.name();
1077 return false;
1078 }
1079
1080 if (!oldElfFlags) {
1081 oldElfFlags = newElfFlags;
1082 return true;
1083 }
1084
1085 uint64_t newPic =
1086 newElfFlags & (llvm::ELF::EF_MIPS_PIC | llvm::ELF::EF_MIPS_CPIC);
1087 uint64_t oldPic =
1088 oldElfFlags & (llvm::ELF::EF_MIPS_PIC | llvm::ELF::EF_MIPS_CPIC);
1089
1090 // Check PIC / CPIC flags compatibility.
1091 if ((newPic != 0) != (oldPic != 0))
1092 warning(diag::warn_Mips_abicalls_linking) << pInput.name();
1093
1094 if (!(newPic & llvm::ELF::EF_MIPS_PIC))
1095 oldElfFlags &= ~llvm::ELF::EF_MIPS_PIC;
1096 if (newPic)
1097 oldElfFlags |= llvm::ELF::EF_MIPS_CPIC;
1098
1099 // Check ISA compatibility.
1100 uint64_t newArch = newElfFlags & llvm::ELF::EF_MIPS_ARCH;
1101 uint64_t oldArch = oldElfFlags & llvm::ELF::EF_MIPS_ARCH;
1102 if (!isIsaMatched(newArch, oldArch)) {
1103 if (!isIsaMatched(oldArch, newArch)) {
1104 error(diag::error_Mips_inconsistent_arch)
1105 << ArchName(oldArch) << ArchName(newArch) << pInput.name();
1106 return false;
1107 }
1108 oldElfFlags &= ~llvm::ELF::EF_MIPS_ARCH;
1109 oldElfFlags |= newArch;
1110 }
1111
1112 // Check ABI compatibility.
1113 uint32_t newAbi = newElfFlags & llvm::ELF::EF_MIPS_ABI;
1114 uint32_t oldAbi = oldElfFlags & llvm::ELF::EF_MIPS_ABI;
1115 if (newAbi != oldAbi && newAbi && oldAbi) {
1116 error(diag::error_Mips_inconsistent_abi) << pInput.name();
1117 return false;
1118 }
1119
1120 // Check -mnan flags compatibility.
1121 if ((newElfFlags & llvm::ELF::EF_MIPS_NAN2008) !=
1122 (oldElfFlags & llvm::ELF::EF_MIPS_NAN2008)) {
1123 // Linking -mnan=2008 and -mnan=legacy modules
1124 error(diag::error_Mips_inconsistent_mnan)
1125 << getNanName(oldElfFlags) << getNanName(newElfFlags) << pInput.name();
1126 return false;
1127 }
1128
1129 // Check ASE compatibility.
1130 uint64_t newAse = newElfFlags & llvm::ELF::EF_MIPS_ARCH_ASE;
1131 uint64_t oldAse = oldElfFlags & llvm::ELF::EF_MIPS_ARCH_ASE;
1132 if (newAse != oldAse)
1133 oldElfFlags |= newAse;
1134
1135 // Check FP64 compatibility.
1136 if ((newElfFlags & llvm::ELF::EF_MIPS_FP64) !=
1137 (oldElfFlags & llvm::ELF::EF_MIPS_FP64)) {
1138 // Linking -mnan=2008 and -mnan=legacy modules
1139 error(diag::error_Mips_inconsistent_fp64) << pInput.name();
1140 return false;
1141 }
1142
1143 oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_NOREORDER;
1144 oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_MICROMIPS;
1145 oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_NAN2008;
1146 oldElfFlags |= newElfFlags & llvm::ELF::EF_MIPS_32BITMODE;
1147
1148 return true;
1149 }
1150
saveTPOffset(const Input & pInput)1151 void MipsGNULDBackend::saveTPOffset(const Input& pInput) {
1152 const LDContext* ctx = pInput.context();
1153 for (auto it = ctx->sectBegin(), ie = ctx->sectEnd(); it != ie; ++it) {
1154 LDSection* sect = *it;
1155 if (sect->flag() & llvm::ELF::SHF_TLS) {
1156 m_TpOffsetMap[&pInput] = sect->addr() + 0x7000;
1157 m_DtpOffsetMap[&pInput] = sect->addr() + 0x8000;
1158 break;
1159 }
1160 }
1161 }
1162
preMergeSections(Module & pModule)1163 void MipsGNULDBackend::preMergeSections(Module& pModule) {
1164 uint64_t elfFlags = 0;
1165 bool hasAbiFlags = false;
1166 MipsAbiFlags abiFlags = {};
1167 for (const Input *input : pModule.getObjectList()) {
1168 if (input->type() != Input::Object)
1169 continue;
1170
1171 uint64_t newElfFlags = m_ElfFlagsMap[input];
1172
1173 MipsAbiFlags newAbiFlags = {};
1174 if (!getAbiFlags(*input, newElfFlags, hasAbiFlags, newAbiFlags))
1175 continue;
1176
1177 if (!mergeElfFlags(*input, elfFlags, newElfFlags))
1178 continue;
1179
1180 if (!MipsAbiFlags::merge(*input, abiFlags, newAbiFlags))
1181 continue;
1182
1183 saveTPOffset(*input);
1184 }
1185
1186 m_pInfo.setElfFlags(elfFlags);
1187 if (hasAbiFlags)
1188 m_pAbiInfo = abiFlags;
1189 }
1190
mergeSection(Module & pModule,const Input & pInput,LDSection & pSection)1191 bool MipsGNULDBackend::mergeSection(Module& pModule, const Input& pInput,
1192 LDSection& pSection) {
1193 if (pSection.flag() & llvm::ELF::SHF_MIPS_GPREL) {
1194 SectionData* sd = NULL;
1195 if (!m_psdata->hasSectionData()) {
1196 sd = IRBuilder::CreateSectionData(*m_psdata);
1197 m_psdata->setSectionData(sd);
1198 }
1199 sd = m_psdata->getSectionData();
1200 moveSectionData(*pSection.getSectionData(), *sd);
1201 } else if (pSection.type() == llvm::ELF::SHT_MIPS_ABIFLAGS) {
1202 // Nothing to do because we handle all .MIPS.abiflags sections
1203 // in the preMergeSections method.
1204 } else {
1205 ObjectBuilder builder(pModule);
1206 builder.MergeSection(pInput, pSection);
1207 }
1208 return true;
1209 }
1210
moveSectionData(SectionData & pFrom,SectionData & pTo)1211 void MipsGNULDBackend::moveSectionData(SectionData& pFrom, SectionData& pTo) {
1212 assert(&pFrom != &pTo && "Cannot move section data to itself!");
1213
1214 uint64_t offset = pTo.getSection().size();
1215 AlignFragment* align = NULL;
1216 if (pFrom.getSection().align() > 1) {
1217 // if the align constraint is larger than 1, append an alignment
1218 unsigned int alignment = pFrom.getSection().align();
1219 align = new AlignFragment(/*alignment*/ alignment,
1220 /*the filled value*/ 0x0,
1221 /*the size of filled value*/ 1u,
1222 /*max bytes to emit*/ alignment - 1);
1223 align->setOffset(offset);
1224 align->setParent(&pTo);
1225 pTo.getFragmentList().push_back(align);
1226 offset += align->size();
1227 }
1228
1229 // move fragments from pFrom to pTO
1230 SectionData::FragmentListType& from_list = pFrom.getFragmentList();
1231 SectionData::FragmentListType& to_list = pTo.getFragmentList();
1232 SectionData::FragmentListType::iterator frag, fragEnd = from_list.end();
1233 for (frag = from_list.begin(); frag != fragEnd; ++frag) {
1234 frag->setParent(&pTo);
1235 frag->setOffset(offset);
1236 offset += frag->size();
1237 }
1238 to_list.splice(to_list.end(), from_list);
1239
1240 // set up pTo's header
1241 pTo.getSection().setSize(offset);
1242 }
1243
1244 //===----------------------------------------------------------------------===//
1245 // Mips32GNULDBackend
1246 //===----------------------------------------------------------------------===//
Mips32GNULDBackend(const LinkerConfig & pConfig,MipsGNUInfo * pInfo)1247 Mips32GNULDBackend::Mips32GNULDBackend(const LinkerConfig& pConfig,
1248 MipsGNUInfo* pInfo)
1249 : MipsGNULDBackend(pConfig, pInfo) {
1250 }
1251
initRelocator()1252 bool Mips32GNULDBackend::initRelocator() {
1253 if (m_pRelocator == NULL)
1254 m_pRelocator = new Mips32Relocator(*this, config());
1255
1256 return true;
1257 }
1258
initTargetSections(Module & pModule,ObjectBuilder & pBuilder)1259 void Mips32GNULDBackend::initTargetSections(Module& pModule,
1260 ObjectBuilder& pBuilder) {
1261 MipsGNULDBackend::initTargetSections(pModule, pBuilder);
1262
1263 if (LinkerConfig::Object == config().codeGenType())
1264 return;
1265
1266 ELFFileFormat* fileFormat = getOutputFormat();
1267
1268 // initialize .got
1269 LDSection& got = fileFormat->getGOT();
1270 m_pGOT = new Mips32GOT(got);
1271
1272 // initialize .got.plt
1273 LDSection& gotplt = fileFormat->getGOTPLT();
1274 m_pGOTPLT = new MipsGOTPLT(gotplt);
1275
1276 // initialize .plt
1277 LDSection& plt = fileFormat->getPLT();
1278 m_pPLT = new MipsPLT(plt);
1279 }
1280
getRelEntrySize()1281 size_t Mips32GNULDBackend::getRelEntrySize() {
1282 return 8;
1283 }
1284
getRelaEntrySize()1285 size_t Mips32GNULDBackend::getRelaEntrySize() {
1286 return 12;
1287 }
1288
1289 //===----------------------------------------------------------------------===//
1290 // Mips64GNULDBackend
1291 //===----------------------------------------------------------------------===//
Mips64GNULDBackend(const LinkerConfig & pConfig,MipsGNUInfo * pInfo)1292 Mips64GNULDBackend::Mips64GNULDBackend(const LinkerConfig& pConfig,
1293 MipsGNUInfo* pInfo)
1294 : MipsGNULDBackend(pConfig, pInfo) {
1295 }
1296
initRelocator()1297 bool Mips64GNULDBackend::initRelocator() {
1298 if (m_pRelocator == NULL)
1299 m_pRelocator = new Mips64Relocator(*this, config());
1300
1301 return true;
1302 }
1303
initTargetSections(Module & pModule,ObjectBuilder & pBuilder)1304 void Mips64GNULDBackend::initTargetSections(Module& pModule,
1305 ObjectBuilder& pBuilder) {
1306 MipsGNULDBackend::initTargetSections(pModule, pBuilder);
1307
1308 if (LinkerConfig::Object == config().codeGenType())
1309 return;
1310
1311 ELFFileFormat* fileFormat = getOutputFormat();
1312
1313 // initialize .got
1314 LDSection& got = fileFormat->getGOT();
1315 m_pGOT = new Mips64GOT(got);
1316
1317 // initialize .got.plt
1318 LDSection& gotplt = fileFormat->getGOTPLT();
1319 m_pGOTPLT = new MipsGOTPLT(gotplt);
1320
1321 // initialize .plt
1322 LDSection& plt = fileFormat->getPLT();
1323 m_pPLT = new MipsPLT(plt);
1324 }
1325
getRelEntrySize()1326 size_t Mips64GNULDBackend::getRelEntrySize() {
1327 return 16;
1328 }
1329
getRelaEntrySize()1330 size_t Mips64GNULDBackend::getRelaEntrySize() {
1331 return 24;
1332 }
1333
1334 //===----------------------------------------------------------------------===//
1335 /// createMipsLDBackend - the help funtion to create corresponding MipsLDBackend
1336 ///
createMipsLDBackend(const LinkerConfig & pConfig)1337 static TargetLDBackend* createMipsLDBackend(const LinkerConfig& pConfig) {
1338 const llvm::Triple& triple = pConfig.targets().triple();
1339
1340 if (triple.isOSDarwin()) {
1341 assert(0 && "MachO linker is not supported yet");
1342 }
1343 if (triple.isOSWindows()) {
1344 assert(0 && "COFF linker is not supported yet");
1345 }
1346
1347 llvm::Triple::ArchType arch = triple.getArch();
1348
1349 if (llvm::Triple::mips64el == arch)
1350 return new Mips64GNULDBackend(pConfig, new MipsGNUInfo(triple));
1351
1352 assert(arch == llvm::Triple::mipsel);
1353 return new Mips32GNULDBackend(pConfig, new MipsGNUInfo(triple));
1354 }
1355
1356 } // namespace mcld
1357
1358 //===----------------------------------------------------------------------===//
1359 // Force static initialization.
1360 //===----------------------------------------------------------------------===//
MCLDInitializeMipsLDBackend()1361 extern "C" void MCLDInitializeMipsLDBackend() {
1362 mcld::TargetRegistry::RegisterTargetLDBackend(mcld::TheMipselTarget,
1363 mcld::createMipsLDBackend);
1364 mcld::TargetRegistry::RegisterTargetLDBackend(mcld::TheMips64elTarget,
1365 mcld::createMipsLDBackend);
1366 }
1367