1 //===- GNULDBackend.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 <llvm/Support/ELF.h>
10 #include <mcld/ADT/SizeTraits.h>
11 #include <mcld/Target/GNULDBackend.h>
12 #include <mcld/MC/MCLDInfo.h>
13 #include <mcld/MC/MCLDOutput.h>
14 #include <mcld/MC/MCLDInputTree.h>
15 #include <mcld/MC/SymbolCategory.h>
16 #include <mcld/LD/LDSymbol.h>
17 #include <mcld/LD/Layout.h>
18 #include <mcld/Support/MemoryArea.h>
19 #include <mcld/Support/MemoryRegion.h>
20 #include <string>
21 #include <cstring>
22 #include <cassert>
23
24 using namespace mcld;
25
26 //===----------------------------------------------------------------------===//
27 // GNULDBackend
GNULDBackend()28 GNULDBackend::GNULDBackend()
29 : m_pArchiveReader(0),
30 m_pObjectReader(0),
31 m_pDynObjReader(0),
32 m_pObjectWriter(0),
33 m_pDynObjWriter(0),
34 m_pDynObjFileFormat(0),
35 m_pExecFileFormat(0),
36 m_ELFSegmentTable(9)// magic number
37 {
38 m_pSymIndexMap = new HashTableType(1024);
39 }
40
~GNULDBackend()41 GNULDBackend::~GNULDBackend()
42 {
43 if (m_pArchiveReader)
44 delete m_pArchiveReader;
45 if (m_pObjectReader)
46 delete m_pObjectReader;
47 if (m_pDynObjReader)
48 delete m_pDynObjReader;
49 if (m_pObjectWriter)
50 delete m_pObjectWriter;
51 if (m_pDynObjWriter)
52 delete m_pDynObjWriter;
53 if (m_pDynObjFileFormat)
54 delete m_pDynObjFileFormat;
55 if (m_pExecFileFormat)
56 delete m_pExecFileFormat;
57 if(m_pSymIndexMap)
58 delete m_pSymIndexMap;
59 }
60
sectionStartOffset() const61 size_t GNULDBackend::sectionStartOffset() const
62 {
63 // FIXME: use fixed offset, we need 10 segments by default
64 return sizeof(llvm::ELF::Elf64_Ehdr)+10*sizeof(llvm::ELF::Elf64_Phdr);
65 }
66
initArchiveReader(MCLinker &,MCLDInfo & pInfo)67 bool GNULDBackend::initArchiveReader(MCLinker&, MCLDInfo &pInfo)
68 {
69 if (0 == m_pArchiveReader)
70 {
71 LDReader::Endian isLittleEndian = LDReader::LittleEndian;
72 m_pArchiveReader = new GNUArchiveReader(pInfo, isLittleEndian);
73 }
74 return true;
75 }
76
initObjectReader(MCLinker & pLinker)77 bool GNULDBackend::initObjectReader(MCLinker& pLinker)
78 {
79 if (0 == m_pObjectReader)
80 m_pObjectReader = new ELFObjectReader(*this, pLinker);
81 return true;
82 }
83
initDynObjReader(MCLinker & pLinker)84 bool GNULDBackend::initDynObjReader(MCLinker& pLinker)
85 {
86 if (0 == m_pDynObjReader)
87 m_pDynObjReader = new ELFDynObjReader(*this, pLinker);
88 return true;
89 }
90
initObjectWriter(MCLinker &)91 bool GNULDBackend::initObjectWriter(MCLinker&)
92 {
93 // TODO
94 return true;
95 }
96
initDynObjWriter(MCLinker & pLinker)97 bool GNULDBackend::initDynObjWriter(MCLinker& pLinker)
98 {
99 if (0 == m_pDynObjWriter)
100 m_pDynObjWriter = new ELFDynObjWriter(*this, pLinker);
101 return true;
102 }
103
initExecSections(MCLinker & pMCLinker)104 bool GNULDBackend::initExecSections(MCLinker& pMCLinker)
105 {
106 if (0 == m_pExecFileFormat)
107 m_pExecFileFormat = new ELFExecFileFormat(*this);
108
109 // initialize standard sections
110 m_pExecFileFormat->initStdSections(pMCLinker);
111 return true;
112 }
113
initDynObjSections(MCLinker & pMCLinker)114 bool GNULDBackend::initDynObjSections(MCLinker& pMCLinker)
115 {
116 if (0 == m_pDynObjFileFormat)
117 m_pDynObjFileFormat = new ELFDynObjFileFormat(*this);
118
119 // initialize standard sections
120 m_pDynObjFileFormat->initStdSections(pMCLinker);
121 return true;
122 }
123
initStandardSymbols(MCLinker & pLinker)124 bool GNULDBackend::initStandardSymbols(MCLinker& pLinker)
125 {
126 return true;
127 }
128
getArchiveReader()129 GNUArchiveReader *GNULDBackend::getArchiveReader()
130 {
131 assert(0 != m_pArchiveReader);
132 return m_pArchiveReader;
133 }
134
getArchiveReader() const135 GNUArchiveReader *GNULDBackend::getArchiveReader() const
136 {
137 assert(0 != m_pArchiveReader);
138 return m_pArchiveReader;
139 }
140
getObjectReader()141 ELFObjectReader *GNULDBackend::getObjectReader()
142 {
143 assert(0 != m_pObjectReader);
144 return m_pObjectReader;
145 }
146
getObjectReader() const147 ELFObjectReader *GNULDBackend::getObjectReader() const
148 {
149 assert(0 != m_pObjectReader);
150 return m_pObjectReader;
151 }
152
getDynObjReader()153 ELFDynObjReader *GNULDBackend::getDynObjReader()
154 {
155 assert(0 != m_pDynObjReader);
156 return m_pDynObjReader;
157 }
158
getDynObjReader() const159 ELFDynObjReader *GNULDBackend::getDynObjReader() const
160 {
161 assert(0 != m_pDynObjReader);
162 return m_pDynObjReader;
163 }
164
getObjectWriter()165 ELFObjectWriter *GNULDBackend::getObjectWriter()
166 {
167 // TODO
168 return NULL;
169 }
170
getObjectWriter() const171 ELFObjectWriter *GNULDBackend::getObjectWriter() const
172 {
173 // TODO
174 return NULL;
175 }
176
getDynObjWriter()177 ELFDynObjWriter *GNULDBackend::getDynObjWriter()
178 {
179 assert(0 != m_pDynObjWriter);
180 return m_pDynObjWriter;
181 }
182
getDynObjWriter() const183 ELFDynObjWriter *GNULDBackend::getDynObjWriter() const
184 {
185 assert(0 != m_pDynObjWriter);
186 return m_pDynObjWriter;
187 }
188
getDynObjFileFormat()189 ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat()
190 {
191 assert(0 != m_pDynObjFileFormat);
192 return m_pDynObjFileFormat;
193 }
194
getDynObjFileFormat() const195 ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat() const
196 {
197 assert(0 != m_pDynObjFileFormat);
198 return m_pDynObjFileFormat;
199 }
200
getExecFileFormat()201 ELFExecFileFormat* GNULDBackend::getExecFileFormat()
202 {
203 assert(0 != m_pExecFileFormat);
204 return m_pExecFileFormat;
205 }
206
getExecFileFormat() const207 ELFExecFileFormat* GNULDBackend::getExecFileFormat() const
208 {
209 assert(0 != m_pExecFileFormat);
210 return m_pExecFileFormat;
211 }
212
213 /// sizeNamePools - compute the size of regular name pools
214 /// In ELF executable files, regular name pools are .symtab, .strtab,
215 /// .dynsym, .dynstr, and .hash
216 void
sizeNamePools(const Output & pOutput,const SymbolCategory & pSymbols,const MCLDInfo & pLDInfo)217 GNULDBackend::sizeNamePools(const Output& pOutput,
218 const SymbolCategory& pSymbols,
219 const MCLDInfo& pLDInfo)
220 {
221 // size of string tables starts from 1 to hold the null character in their
222 // first byte
223 size_t symtab = 1;
224 size_t dynsym = 1;
225 // number of entries in symbol tables starts from 1 to hold the special entry
226 // at index 0 (STN_UNDEF). See ELF Spec Book I, p1-21.
227 size_t strtab = 1;
228 size_t dynstr = 1;
229 size_t hash = 0;
230
231 // compute size of .symtab, .dynsym and .strtab
232 SymbolCategory::const_iterator symbol;
233 SymbolCategory::const_iterator symEnd = pSymbols.end();
234 for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) {
235 size_t str_size = (*symbol)->nameSize() + 1;
236 if (isDynamicSymbol(**symbol, pOutput)) {
237 ++dynsym;
238 dynstr += str_size;
239 }
240 ++symtab;
241 strtab += str_size;
242 }
243
244 ELFFileFormat* file_format = NULL;
245 switch(pOutput.type()) {
246 // compute size of .dynstr and .hash
247 case Output::DynObj:
248 file_format = getDynObjFileFormat();
249 break;
250 case Output::Exec:
251 file_format = getExecFileFormat();
252 break;
253 case Output::Object:
254 default:
255 // TODO: not support yet
256 return;
257 }
258
259 switch(pOutput.type()) {
260 // compute size of .dynstr and .hash
261 case Output::DynObj:
262 case Output::Exec: {
263 // add DT_NEED strings into .dynstr and .dynamic
264 // Rules:
265 // 1. ignore --no-add-needed
266 // 2. force count in --no-as-needed
267 // 3. judge --as-needed
268 InputTree::const_bfs_iterator input, inputEnd = pLDInfo.inputs().bfs_end();
269 for (input = pLDInfo.inputs().bfs_begin(); input != inputEnd; ++input) {
270 if (Input::DynObj == (*input)->type()) {
271 // --add-needed
272 if ((*input)->attribute()->isAddNeeded()) {
273 // --no-as-needed
274 if (!(*input)->attribute()->isAsNeeded()) {
275 dynstr += (*input)->name().size() + 1;
276 dynamic().reserveNeedEntry();
277 }
278 // --as-needed
279 else if ((*input)->isNeeded()) {
280 dynstr += (*input)->name().size() + 1;
281 dynamic().reserveNeedEntry();
282 }
283 }
284 }
285 } // for
286
287 // compute .hash
288 // Both Elf32_Word and Elf64_Word are 4 bytes
289 hash = (2 + getHashBucketCount(dynsym, false) + dynsym) *
290 sizeof(llvm::ELF::Elf32_Word);
291
292 // set size
293 dynstr += pOutput.name().size() + 1;
294 if (32 == bitclass())
295 file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf32_Sym));
296 else
297 file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf64_Sym));
298 file_format->getDynStrTab().setSize(dynstr);
299 file_format->getHashTab().setSize(hash);
300
301 }
302 /* fall through */
303 case Output::Object: {
304 if (32 == bitclass())
305 file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf32_Sym));
306 else
307 file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf64_Sym));
308 file_format->getStrTab().setSize(strtab);
309 break;
310 }
311 } // end of switch
312
313 // reserve fixed entries in the .dynamic section.
314 if (Output::DynObj == pOutput.type() || Output::Exec == pOutput.type()) {
315 // Because some entries in .dynamic section need information of .dynsym,
316 // .dynstr, .symtab, .strtab and .hash, we can not reserve non-DT_NEEDED
317 // entries until we get the size of the sections mentioned above
318 dynamic().reserveEntries(pLDInfo, *file_format);
319 file_format->getDynamic().setSize(dynamic().numOfBytes());
320 }
321 }
322
323 /// emitRegNamePools - emit regular name pools - .symtab, .strtab
324 ///
325 /// the size of these tables should be computed before layout
326 /// layout should computes the start offset of these tables
emitRegNamePools(Output & pOutput,SymbolCategory & pSymbols,const Layout & pLayout,const MCLDInfo & pLDInfo)327 void GNULDBackend::emitRegNamePools(Output& pOutput,
328 SymbolCategory& pSymbols,
329 const Layout& pLayout,
330 const MCLDInfo& pLDInfo)
331 {
332
333 assert(pOutput.hasMemArea());
334
335 bool sym_exist = false;
336 HashTableType::entry_type* entry = 0;
337
338 ELFFileFormat* file_format = NULL;
339 switch(pOutput.type()) {
340 // compute size of .dynstr and .hash
341 case Output::DynObj:
342 file_format = getDynObjFileFormat();
343 break;
344 case Output::Exec:
345 file_format = getExecFileFormat();
346 break;
347 case Output::Object:
348 default:
349 // add first symbol into m_pSymIndexMap
350 entry = m_pSymIndexMap->insert(NULL, sym_exist);
351 entry->setValue(0);
352
353 // TODO: not support yet
354 return;
355 }
356
357 LDSection& symtab_sect = file_format->getSymTab();
358 LDSection& strtab_sect = file_format->getStrTab();
359
360 MemoryRegion* symtab_region = pOutput.memArea()->request(symtab_sect.offset(),
361 symtab_sect.size());
362 MemoryRegion* strtab_region = pOutput.memArea()->request(strtab_sect.offset(),
363 strtab_sect.size());
364
365 // set up symtab_region
366 llvm::ELF::Elf32_Sym* symtab32 = NULL;
367 llvm::ELF::Elf64_Sym* symtab64 = NULL;
368 if (32 == bitclass())
369 symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
370 else if (64 == bitclass())
371 symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
372 else
373 llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") +
374 llvm::Twine(bitclass()) +
375 llvm::Twine(".\n"));
376 // set up strtab_region
377 char* strtab = (char*)strtab_region->start();
378 strtab[0] = '\0';
379
380 // initialize the first ELF symbol
381 if (32 == bitclass()) {
382 symtab32[0].st_name = 0;
383 symtab32[0].st_value = 0;
384 symtab32[0].st_size = 0;
385 symtab32[0].st_info = 0;
386 symtab32[0].st_other = 0;
387 symtab32[0].st_shndx = 0;
388 }
389 else { // must 64
390 symtab64[0].st_name = 0;
391 symtab64[0].st_value = 0;
392 symtab64[0].st_size = 0;
393 symtab64[0].st_info = 0;
394 symtab64[0].st_other = 0;
395 symtab64[0].st_shndx = 0;
396 }
397
398 size_t symtabIdx = 1;
399 size_t strtabsize = 1;
400 // compute size of .symtab, .dynsym and .strtab
401 SymbolCategory::iterator symbol;
402 SymbolCategory::iterator symEnd = pSymbols.end();
403 for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) {
404
405 // maintain output's symbol and index map if building .o file
406 if (Output::Object == pOutput.type()) {
407 entry = m_pSymIndexMap->insert(NULL, sym_exist);
408 entry->setValue(symtabIdx);
409 }
410
411 // FIXME: check the endian between host and target
412 // write out symbol
413 if (32 == bitclass()) {
414 symtab32[symtabIdx].st_name = strtabsize;
415 symtab32[symtabIdx].st_value = getSymbolValue(**symbol);
416 symtab32[symtabIdx].st_size = getSymbolSize(**symbol);
417 symtab32[symtabIdx].st_info = getSymbolInfo(**symbol);
418 symtab32[symtabIdx].st_other = (*symbol)->visibility();
419 symtab32[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
420 }
421 else { // must 64
422 symtab64[symtabIdx].st_name = strtabsize;
423 symtab64[symtabIdx].st_value = getSymbolValue(**symbol);
424 symtab64[symtabIdx].st_size = getSymbolSize(**symbol);
425 symtab64[symtabIdx].st_info = getSymbolInfo(**symbol);
426 symtab64[symtabIdx].st_other = (*symbol)->visibility();
427 symtab64[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
428 }
429 // write out string
430 strcpy((strtab + strtabsize), (*symbol)->name());
431
432 // write out
433 // sum up counters
434 ++symtabIdx;
435 strtabsize += (*symbol)->nameSize() + 1;
436 }
437 }
438
439 /// emitNamePools - emit dynamic name pools - .dyntab, .dynstr, .hash
440 ///
441 /// the size of these tables should be computed before layout
442 /// layout should computes the start offset of these tables
emitDynNamePools(Output & pOutput,SymbolCategory & pSymbols,const Layout & pLayout,const MCLDInfo & pLDInfo)443 void GNULDBackend::emitDynNamePools(Output& pOutput,
444 SymbolCategory& pSymbols,
445 const Layout& pLayout,
446 const MCLDInfo& pLDInfo)
447 {
448 assert(pOutput.hasMemArea());
449 ELFFileFormat* file_format = NULL;
450
451 bool sym_exist = false;
452 HashTableType::entry_type* entry = 0;
453
454 switch(pOutput.type()) {
455 // compute size of .dynstr and .hash
456 case Output::DynObj:
457 file_format = getDynObjFileFormat();
458 break;
459 case Output::Exec:
460 file_format = getExecFileFormat();
461 break;
462 case Output::Object:
463 default:
464 // TODO: not support yet
465 return;
466 }
467
468 LDSection& symtab_sect = file_format->getDynSymTab();
469 LDSection& strtab_sect = file_format->getDynStrTab();
470 LDSection& hash_sect = file_format->getHashTab();
471 LDSection& dyn_sect = file_format->getDynamic();
472
473 MemoryRegion* symtab_region = pOutput.memArea()->request(symtab_sect.offset(),
474 symtab_sect.size());
475 MemoryRegion* strtab_region = pOutput.memArea()->request(strtab_sect.offset(),
476 strtab_sect.size());
477 MemoryRegion* hash_region = pOutput.memArea()->request(hash_sect.offset(),
478 hash_sect.size());
479 MemoryRegion* dyn_region = pOutput.memArea()->request(dyn_sect.offset(),
480 dyn_sect.size());
481 // set up symtab_region
482 llvm::ELF::Elf32_Sym* symtab32 = NULL;
483 llvm::ELF::Elf64_Sym* symtab64 = NULL;
484 if (32 == bitclass())
485 symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
486 else if (64 == bitclass())
487 symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
488 else
489 llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") +
490 llvm::Twine(bitclass()) +
491 llvm::Twine(".\n"));
492
493 // initialize the first ELF symbol
494 if (32 == bitclass()) {
495 symtab32[0].st_name = 0;
496 symtab32[0].st_value = 0;
497 symtab32[0].st_size = 0;
498 symtab32[0].st_info = 0;
499 symtab32[0].st_other = 0;
500 symtab32[0].st_shndx = 0;
501 }
502 else { // must 64
503 symtab64[0].st_name = 0;
504 symtab64[0].st_value = 0;
505 symtab64[0].st_size = 0;
506 symtab64[0].st_info = 0;
507 symtab64[0].st_other = 0;
508 symtab64[0].st_shndx = 0;
509 }
510 // set up strtab_region
511 char* strtab = (char*)strtab_region->start();
512 strtab[0] = '\0';
513
514 // add the first symbol into m_pSymIndexMap
515 entry = m_pSymIndexMap->insert(NULL, sym_exist);
516 entry->setValue(0);
517
518 size_t symtabIdx = 1;
519 size_t strtabsize = 1;
520
521 // emit of .dynsym, and .dynstr
522 SymbolCategory::iterator symbol;
523 SymbolCategory::iterator symEnd = pSymbols.end();
524 for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) {
525 if (!isDynamicSymbol(**symbol, pOutput))
526 continue;
527
528 // maintain output's symbol and index map
529 entry = m_pSymIndexMap->insert(*symbol, sym_exist);
530 entry->setValue(symtabIdx);
531
532 // FIXME: check the endian between host and target
533 // write out symbol
534 if (32 == bitclass()) {
535 symtab32[symtabIdx].st_name = strtabsize;
536 symtab32[symtabIdx].st_value = (*symbol)->value();
537 symtab32[symtabIdx].st_size = getSymbolSize(**symbol);
538 symtab32[symtabIdx].st_info = getSymbolInfo(**symbol);
539 symtab32[symtabIdx].st_other = (*symbol)->visibility();
540 symtab32[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
541 }
542 else { // must 64
543 symtab64[symtabIdx].st_name = strtabsize;
544 symtab64[symtabIdx].st_value = (*symbol)->value();
545 symtab64[symtabIdx].st_size = getSymbolSize(**symbol);
546 symtab64[symtabIdx].st_info = getSymbolInfo(**symbol);
547 symtab64[symtabIdx].st_other = (*symbol)->visibility();
548 symtab64[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
549 }
550 // write out string
551 strcpy((strtab + strtabsize), (*symbol)->name());
552
553 // sum up counters
554 ++symtabIdx;
555 strtabsize += (*symbol)->nameSize() + 1;
556 }
557
558 // emit DT_NEED
559 // add DT_NEED strings into .dynstr
560 // Rules:
561 // 1. ignore --no-add-needed
562 // 2. force count in --no-as-needed
563 // 3. judge --as-needed
564 ELFDynamic::iterator dt_need = dynamic().needBegin();
565 InputTree::const_bfs_iterator input, inputEnd = pLDInfo.inputs().bfs_end();
566 for (input = pLDInfo.inputs().bfs_begin(); input != inputEnd; ++input) {
567 if (Input::DynObj == (*input)->type()) {
568 // --add-needed
569 if ((*input)->attribute()->isAddNeeded()) {
570 // --no-as-needed
571 if (!(*input)->attribute()->isAsNeeded()) {
572 strcpy((strtab + strtabsize), (*input)->name().c_str());
573 (*dt_need)->setValue(llvm::ELF::DT_NEEDED, strtabsize);
574 strtabsize += (*input)->name().size() + 1;
575 ++dt_need;
576 }
577 // --as-needed
578 else if ((*input)->isNeeded()) {
579 strcpy((strtab + strtabsize), (*input)->name().c_str());
580 (*dt_need)->setValue(llvm::ELF::DT_NEEDED, strtabsize);
581 strtabsize += (*input)->name().size() + 1;
582 ++dt_need;
583 }
584 }
585 }
586 } // for
587
588 // emit soname
589 // initialize value of ELF .dynamic section
590 dynamic().applySoname(strtabsize);
591 dynamic().applyEntries(pLDInfo, *file_format);
592 dynamic().emit(dyn_sect, *dyn_region);
593
594 strcpy((strtab + strtabsize), pOutput.name().c_str());
595 strtabsize += pOutput.name().size() + 1;
596
597 // emit hash table
598 // FIXME: this verion only emit SVR4 hash section.
599 // Please add GNU new hash section
600
601 // both 32 and 64 bits hash table use 32-bit entry
602 // set up hash_region
603 uint32_t* word_array = (uint32_t*)hash_region->start();
604 uint32_t& nbucket = word_array[0];
605 uint32_t& nchain = word_array[1];
606
607 nbucket = getHashBucketCount(symtabIdx, false);
608 nchain = symtabIdx;
609
610 uint32_t* bucket = (word_array + 2);
611 uint32_t* chain = (bucket + nbucket);
612
613 // initialize bucket
614 bzero((void*)bucket, nbucket);
615
616 StringHash<ELF> hash_func;
617
618 if (32 == bitclass()) {
619 for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) {
620 llvm::StringRef name(strtab + symtab32[sym_idx].st_name);
621 size_t bucket_pos = hash_func(name) % nbucket;
622 chain[sym_idx] = bucket[bucket_pos];
623 bucket[bucket_pos] = sym_idx;
624 }
625 }
626 else if (64 == bitclass()) {
627 for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) {
628 llvm::StringRef name(strtab + symtab64[sym_idx].st_name);
629 size_t bucket_pos = hash_func(name) % nbucket;
630 chain[sym_idx] = bucket[bucket_pos];
631 bucket[bucket_pos] = sym_idx;
632 }
633 }
634 }
635
636 /// getSectionOrder
getSectionOrder(const Output & pOutput,const LDSection & pSectHdr) const637 unsigned int GNULDBackend::getSectionOrder(const Output& pOutput,
638 const LDSection& pSectHdr) const
639 {
640 // NULL section should be the "1st" section
641 if (LDFileFormat::Null == pSectHdr.kind())
642 return 0;
643
644 // if the section is not ALLOC, lay it out until the last possible moment
645 if (0 == (pSectHdr.flag() & llvm::ELF::SHF_ALLOC))
646 return SHO_UNDEFINED;
647
648 bool is_write = (pSectHdr.flag() & llvm::ELF::SHF_WRITE) != 0;
649 bool is_exec = (pSectHdr.flag() & llvm::ELF::SHF_EXECINSTR) != 0;
650 ELFFileFormat* file_format = NULL;
651 switch (pOutput.type()) {
652 case Output::DynObj:
653 file_format = getDynObjFileFormat();
654 break;
655 case Output::Exec:
656 file_format = getExecFileFormat();
657 break;
658 case Output::Object:
659 default:
660 assert(0 && "Not support yet.\n");
661 break;
662 }
663
664 // TODO: need to take care other possible output sections
665 switch (pSectHdr.kind()) {
666 case LDFileFormat::Regular:
667 if (is_exec) {
668 if (&pSectHdr == &file_format->getInit())
669 return SHO_INIT;
670 if (&pSectHdr == &file_format->getFini())
671 return SHO_FINI;
672 return SHO_TEXT;
673 } else if (!is_write) {
674 return SHO_RO;
675 } else {
676 if (pSectHdr.type() == llvm::ELF::SHT_PREINIT_ARRAY ||
677 pSectHdr.type() == llvm::ELF::SHT_INIT_ARRAY ||
678 pSectHdr.type() == llvm::ELF::SHT_FINI_ARRAY ||
679 &pSectHdr == &file_format->getCtors() ||
680 &pSectHdr == &file_format->getDtors())
681 return SHO_RELRO;
682
683 return SHO_DATA;
684 }
685
686 case LDFileFormat::BSS:
687 return SHO_BSS;
688
689 case LDFileFormat::NamePool:
690 if (&pSectHdr == &file_format->getDynamic())
691 return SHO_RELRO;
692 return SHO_NAMEPOOL;
693
694 case LDFileFormat::Relocation:
695 if (&pSectHdr == &file_format->getRelPlt() ||
696 &pSectHdr == &file_format->getRelaPlt())
697 return SHO_REL_PLT;
698 return SHO_RELOCATION;
699
700 // get the order from target for target specific sections
701 case LDFileFormat::Target:
702 return getTargetSectionOrder(pOutput, pSectHdr);
703
704 // handle .interp
705 case LDFileFormat::Note:
706 return SHO_INTERP;
707
708 case LDFileFormat::Exception:
709 return SHO_EHFRAME;
710
711 case LDFileFormat::MetaData:
712 case LDFileFormat::Debug:
713 default:
714 return SHO_UNDEFINED;
715 }
716 }
717
718 /// getSymbolSize
getSymbolSize(const LDSymbol & pSymbol) const719 uint64_t GNULDBackend::getSymbolSize(const LDSymbol& pSymbol) const
720 {
721 // @ref Google gold linker: symtab.cc: 2780
722 // undefined and dynamic symbols should have zero size.
723 if (pSymbol.isDyn() || pSymbol.desc() == ResolveInfo::Undefined)
724 return 0x0;
725 return pSymbol.resolveInfo()->size();
726 }
727
728 /// getSymbolInfo
getSymbolInfo(const LDSymbol & pSymbol) const729 uint64_t GNULDBackend::getSymbolInfo(const LDSymbol& pSymbol) const
730 {
731 // set binding
732 uint8_t bind = 0x0;
733 if (pSymbol.resolveInfo()->isLocal())
734 bind = llvm::ELF::STB_LOCAL;
735 else if (pSymbol.resolveInfo()->isGlobal())
736 bind = llvm::ELF::STB_GLOBAL;
737 else if (pSymbol.resolveInfo()->isWeak())
738 bind = llvm::ELF::STB_WEAK;
739 else if (pSymbol.resolveInfo()->isAbsolute()) {
740 // (Luba) Is a absolute but not global (weak or local) symbol meaningful?
741 bind = llvm::ELF::STB_GLOBAL;
742 }
743
744 if (pSymbol.visibility() == llvm::ELF::STV_INTERNAL ||
745 pSymbol.visibility() == llvm::ELF::STV_HIDDEN)
746 bind = llvm::ELF::STB_LOCAL;
747
748 return (pSymbol.resolveInfo()->type() | (bind << 4));
749 }
750
751 /// getSymbolValue - this function is called after layout()
getSymbolValue(const LDSymbol & pSymbol) const752 uint64_t GNULDBackend::getSymbolValue(const LDSymbol& pSymbol) const
753 {
754 if (pSymbol.isDyn())
755 return 0x0;
756
757 return pSymbol.value();
758 }
759
760 /// getSymbolShndx - this function is called after layout()
761 uint64_t
getSymbolShndx(const LDSymbol & pSymbol,const Layout & pLayout) const762 GNULDBackend::getSymbolShndx(const LDSymbol& pSymbol, const Layout& pLayout) const
763 {
764 if (pSymbol.resolveInfo()->isAbsolute())
765 return llvm::ELF::SHN_ABS;
766 if (pSymbol.resolveInfo()->isCommon())
767 return llvm::ELF::SHN_COMMON;
768 if (pSymbol.resolveInfo()->isUndef() || pSymbol.isDyn())
769 return llvm::ELF::SHN_UNDEF;
770
771 if (pSymbol.resolveInfo()->isLocal()) {
772 switch (pSymbol.type()) {
773 case ResolveInfo::NoType:
774 case ResolveInfo::File:
775 return llvm::ELF::SHN_ABS;
776 }
777 }
778
779 assert(pSymbol.hasFragRef());
780 return pLayout.getOutputLDSection(*pSymbol.fragRef()->frag())->index();
781 }
782
783 /// getSymbolIdx - called by emitRelocation to get the ouput symbol table index
getSymbolIdx(LDSymbol * pSymbol) const784 size_t GNULDBackend::getSymbolIdx(LDSymbol* pSymbol) const
785 {
786 HashTableType::iterator entry = m_pSymIndexMap->find(pSymbol);
787 return entry.getEntry()->value();
788 }
789
790 /// emitProgramHdrs - emit ELF program headers
emitProgramHdrs(Output & pOutput)791 void GNULDBackend::emitProgramHdrs(Output& pOutput)
792 {
793 assert(NULL != pOutput.context());
794 createProgramHdrs(*pOutput.context());
795
796 if (32 == bitclass())
797 writeELF32ProgramHdrs(pOutput);
798 else
799 writeELF64ProgramHdrs(pOutput);
800 }
801
802 /// createProgramHdrs - base on output sections to create the program headers
createProgramHdrs(LDContext & pContext)803 void GNULDBackend::createProgramHdrs(LDContext& pContext)
804 {
805 // make PT_PHDR
806 m_ELFSegmentTable.produce(llvm::ELF::PT_PHDR);
807
808 // make PT_INTERP
809 LDSection* interp = pContext.getSection(".interp");
810 if (NULL != interp) {
811 ELFSegment* interp_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_INTERP);
812 interp_seg->addSection(interp);
813 interp_seg->setAlign(bitclass() / 8);
814 }
815
816 uint32_t cur_seg_flag, prev_seg_flag = getSegmentFlag(0);
817 uint64_t padding = 0;
818 ELFSegment* load_seg = NULL;
819 // make possible PT_LOAD segments
820 LDContext::sect_iterator sect, sect_end = pContext.sectEnd();
821 for (sect = pContext.sectBegin(); sect != sect_end; ++sect) {
822 if (0 == ((*sect)->flag() & llvm::ELF::SHF_ALLOC) &&
823 LDFileFormat::Null != (*sect)->kind())
824 continue;
825
826 // FIXME: Now only separate writable and non-writable PT_LOAD
827 cur_seg_flag = getSegmentFlag((*sect)->flag());
828 if ((prev_seg_flag & llvm::ELF::PF_W) ^ (cur_seg_flag & llvm::ELF::PF_W) ||
829 LDFileFormat::Null == (*sect)->kind()) {
830 // create new PT_LOAD segment
831 load_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_LOAD);
832 load_seg->setAlign(pagesize());
833
834 // check if this segment needs padding
835 padding = 0;
836 if (((*sect)->offset() & (load_seg->align() - 1)) != 0)
837 padding = load_seg->align();
838 }
839
840 assert(NULL != load_seg);
841 load_seg->addSection(*sect);
842 load_seg->updateFlag(cur_seg_flag);
843
844 // FIXME: set section's vma
845 // need to handle start vma for user-defined one or for executable.
846 (*sect)->setAddr((*sect)->offset() + padding);
847
848 prev_seg_flag = cur_seg_flag;
849 }
850
851 // make PT_DYNAMIC
852 LDSection* dynamic = pContext.getSection(".dynamic");
853 if (NULL != dynamic) {
854 ELFSegment* dyn_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_DYNAMIC);
855 dyn_seg->setFlag(llvm::ELF::PF_R | llvm::ELF::PF_W);
856 dyn_seg->addSection(dynamic);
857 dyn_seg->setAlign(bitclass() / 8);
858 }
859
860 // update segment info
861 uint64_t file_size = 0;
862 ELFSegmentFactory::iterator seg, seg_end = m_ELFSegmentTable.end();
863 for (seg = m_ELFSegmentTable.begin(); seg != seg_end; ++seg) {
864 ELFSegment& segment = *seg;
865
866 // update PT_PHDR
867 if (llvm::ELF::PT_PHDR == segment.type()) {
868 uint64_t offset, phdr_size;
869 if (32 == bitclass()) {
870 offset = sizeof(llvm::ELF::Elf32_Ehdr);
871 phdr_size = sizeof(llvm::ELF::Elf32_Phdr);
872 }
873 else {
874 offset = sizeof(llvm::ELF::Elf64_Ehdr);
875 phdr_size = sizeof(llvm::ELF::Elf64_Phdr);
876 }
877 segment.setOffset(offset);
878 segment.setVaddr(offset);
879 segment.setPaddr(segment.vaddr());
880 segment.setFilesz(numOfSegments() * phdr_size);
881 segment.setMemsz(numOfSegments() * phdr_size);
882 segment.setAlign(bitclass() / 8);
883 continue;
884 }
885
886 assert(NULL != segment.getFirstSection());
887 segment.setOffset(segment.getFirstSection()->offset());
888 segment.setVaddr(segment.getFirstSection()->addr());
889 segment.setPaddr(segment.vaddr());
890
891 const LDSection* last_sect = segment.getLastSection();
892 assert(NULL != last_sect);
893 file_size = last_sect->offset() - segment.offset();
894 if (LDFileFormat::BSS != last_sect->kind())
895 file_size += last_sect->size();
896 segment.setFilesz(file_size);
897
898 segment.setMemsz(last_sect->addr() - segment.vaddr() + last_sect->size());
899 }
900 }
901
902 /// writeELF32ProgramHdrs - write out the ELF32 program headers
writeELF32ProgramHdrs(Output & pOutput)903 void GNULDBackend::writeELF32ProgramHdrs(Output& pOutput)
904 {
905 assert(pOutput.hasMemArea());
906
907 uint64_t start_offset, phdr_size;
908
909 start_offset = sizeof(llvm::ELF::Elf32_Ehdr);
910 phdr_size = sizeof(llvm::ELF::Elf32_Phdr);
911 // Program header must start directly after ELF header
912 MemoryRegion *region = pOutput.memArea()->request(start_offset,
913 numOfSegments()*phdr_size);
914
915 llvm::ELF::Elf32_Phdr* phdr = (llvm::ELF::Elf32_Phdr*)region->start();
916
917 size_t index = 0;
918 ELFSegmentFactory::iterator seg, segEnd = m_ELFSegmentTable.end();
919 for (seg = m_ELFSegmentTable.begin(); seg != segEnd; ++seg, ++index) {
920 phdr[index].p_type = (*seg).type();
921 phdr[index].p_flags = (*seg).flag();
922 phdr[index].p_offset = (*seg).offset();
923 phdr[index].p_vaddr = (*seg).vaddr();
924 phdr[index].p_paddr = (*seg).paddr();
925 phdr[index].p_filesz = (*seg).filesz();
926 phdr[index].p_memsz = (*seg).memsz();
927 phdr[index].p_align = (*seg).align();
928 }
929 }
930
931 /// writeELF64ProgramHdrs - write out the ELF64 program headers
writeELF64ProgramHdrs(Output & pOutput)932 void GNULDBackend::writeELF64ProgramHdrs(Output& pOutput)
933 {
934 assert(pOutput.hasMemArea());
935
936 uint64_t start_offset, phdr_size;
937
938 start_offset = sizeof(llvm::ELF::Elf64_Ehdr);
939 phdr_size = sizeof(llvm::ELF::Elf64_Phdr);
940 // Program header must start directly after ELF header
941 MemoryRegion *region = pOutput.memArea()->request(start_offset,
942 numOfSegments() *phdr_size);
943 llvm::ELF::Elf64_Phdr* phdr = (llvm::ELF::Elf64_Phdr*)region->start();
944
945 size_t index = 0;
946 ELFSegmentFactory::iterator seg, segEnd = m_ELFSegmentTable.end();
947 for (seg = m_ELFSegmentTable.begin(); seg != segEnd; ++seg, ++index) {
948 phdr[index].p_type = (*seg).type();
949 phdr[index].p_flags = (*seg).flag();
950 phdr[index].p_offset = (*seg).offset();
951 phdr[index].p_vaddr = (*seg).vaddr();
952 phdr[index].p_paddr = (*seg).paddr();
953 phdr[index].p_filesz = (*seg).filesz();
954 phdr[index].p_memsz = (*seg).memsz();
955 phdr[index].p_align = (*seg).align();
956 }
957 }
958
959 /// preLayout - Backend can do any needed modification before layout
preLayout(const Output & pOutput,const MCLDInfo & pLDInfo,MCLinker & pLinker)960 void GNULDBackend::preLayout(const Output& pOutput,
961 const MCLDInfo& pLDInfo,
962 MCLinker& pLinker)
963 {
964 // prelayout target first
965 doPreLayout(pOutput, pLDInfo, pLinker);
966 }
967
968 /// postLayout -Backend can do any needed modification after layout
postLayout(const Output & pOutput,const MCLDInfo & pInfo,MCLinker & pLinker)969 void GNULDBackend::postLayout(const Output& pOutput,
970 const MCLDInfo& pInfo,
971 MCLinker& pLinker)
972 {
973 // post layout target first
974 doPostLayout(pOutput, pInfo, pLinker);
975 }
976
977 /// getHashBucketCount - calculate hash bucket count.
978 /// @ref Google gold linker, dynobj.cc:791
getHashBucketCount(unsigned pNumOfSymbols,bool pIsGNUStyle)979 unsigned GNULDBackend::getHashBucketCount(unsigned pNumOfSymbols,
980 bool pIsGNUStyle)
981 {
982 // @ref Google gold, dynobj.cc:loc 791
983 static const unsigned int buckets[] =
984 {
985 1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
986 16411, 32771, 65537, 131101, 262147
987 };
988 const unsigned buckets_count = sizeof buckets / sizeof buckets[0];
989
990 unsigned int result = 1;
991 for (unsigned i = 0; i < buckets_count; ++i) {
992 if (pNumOfSymbols < buckets[i])
993 break;
994 result = buckets[i];
995 }
996
997 if (pIsGNUStyle && result < 2)
998 result = 2;
999
1000 return result;
1001 }
1002
1003 /// isDynamicSymbol
1004 /// @ref Google gold linker: symtab.cc:311
isDynamicSymbol(const LDSymbol & pSymbol,const Output & pOutput)1005 bool GNULDBackend::isDynamicSymbol(const LDSymbol& pSymbol,
1006 const Output& pOutput)
1007 {
1008 // If a local symbol is in the LDContext's symbol table, it's a real local
1009 // symbol. We should not add it
1010 if (pSymbol.binding() == ResolveInfo::Local)
1011 return false;
1012
1013 // If we are building shared object, and the visibility is external, we
1014 // need to add it.
1015 if (Output::DynObj == pOutput.type())
1016 if (pSymbol.resolveInfo()->visibility() == ResolveInfo::Default ||
1017 pSymbol.resolveInfo()->visibility() == ResolveInfo::Protected)
1018 return true;
1019
1020 return false;
1021 }
1022