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
10#include <mcld/Target/GNULDBackend.h>
11
12#include <string>
13#include <cstring>
14#include <cassert>
15
16#include <llvm/Support/ELF.h>
17
18#include <mcld/ADT/SizeTraits.h>
19#include <mcld/LD/LDSymbol.h>
20#include <mcld/LD/Layout.h>
21#include <mcld/LD/FillFragment.h>
22#include <mcld/MC/MCLDInfo.h>
23#include <mcld/MC/MCLDOutput.h>
24#include <mcld/MC/InputTree.h>
25#include <mcld/MC/SymbolCategory.h>
26#include <mcld/MC/MCLinker.h>
27#include <mcld/Support/MemoryArea.h>
28#include <mcld/Support/MemoryRegion.h>
29#include <mcld/Support/MsgHandling.h>
30#include <mcld/Support/MemoryAreaFactory.h>
31
32using namespace mcld;
33
34//===----------------------------------------------------------------------===//
35// GNULDBackend
36//===----------------------------------------------------------------------===//
37GNULDBackend::GNULDBackend()
38  : m_pArchiveReader(NULL),
39    m_pObjectReader(NULL),
40    m_pDynObjReader(NULL),
41    m_pObjectWriter(NULL),
42    m_pDynObjWriter(NULL),
43    m_pExecWriter(NULL),
44    m_pDynObjFileFormat(NULL),
45    m_pExecFileFormat(NULL),
46    m_ELFSegmentTable(9), // magic number
47    m_pEhFrameHdr(NULL),
48    f_pPreInitArrayStart(NULL),
49    f_pPreInitArrayEnd(NULL),
50    f_pInitArrayStart(NULL),
51    f_pInitArrayEnd(NULL),
52    f_pFiniArrayStart(NULL),
53    f_pFiniArrayEnd(NULL),
54    f_pStack(NULL),
55    f_pExecutableStart(NULL),
56    f_pEText(NULL),
57    f_p_EText(NULL),
58    f_p__EText(NULL),
59    f_pEData(NULL),
60    f_p_EData(NULL),
61    f_pBSSStart(NULL),
62    f_pEnd(NULL),
63    f_p_End(NULL) {
64  m_pSymIndexMap = new HashTableType(1024);
65}
66
67GNULDBackend::~GNULDBackend()
68{
69  if (NULL != m_pArchiveReader)
70    delete m_pArchiveReader;
71  if (NULL != m_pObjectReader)
72    delete m_pObjectReader;
73  if (NULL != m_pDynObjReader)
74    delete m_pDynObjReader;
75  if (NULL != m_pObjectWriter)
76    delete m_pObjectWriter;
77  if (NULL != m_pDynObjWriter)
78    delete m_pDynObjWriter;
79  if (NULL != m_pExecWriter)
80    delete m_pExecWriter;
81  if (NULL != m_pDynObjFileFormat)
82    delete m_pDynObjFileFormat;
83  if (NULL != m_pExecFileFormat)
84    delete m_pExecFileFormat;
85  if (NULL != m_pSymIndexMap)
86    delete m_pSymIndexMap;
87  if (NULL != m_pEhFrameHdr)
88    delete m_pEhFrameHdr;
89}
90
91size_t GNULDBackend::sectionStartOffset() const
92{
93  // FIXME: use fixed offset, we need 10 segments by default
94  return sizeof(llvm::ELF::Elf64_Ehdr)+10*sizeof(llvm::ELF::Elf64_Phdr);
95}
96
97uint64_t GNULDBackend::segmentStartAddr(const Output& pOutput,
98                                        const MCLDInfo& pInfo) const
99{
100  // TODO: handle the user option: -TText=
101  if (isOutputPIC(pOutput, pInfo))
102    return 0x0;
103  else
104    return defaultTextSegmentAddr();
105}
106
107bool GNULDBackend::initArchiveReader(MCLinker& pLinker,
108                                     MCLDInfo& pInfo,
109                                     MemoryAreaFactory& pMemAreaFactory)
110{
111  if (NULL == m_pArchiveReader) {
112    assert(NULL != m_pObjectReader);
113    m_pArchiveReader = new GNUArchiveReader(pInfo,
114                                            pMemAreaFactory,
115                                            *m_pObjectReader);
116  }
117  return true;
118}
119
120bool GNULDBackend::initObjectReader(MCLinker& pLinker)
121{
122  if (NULL == m_pObjectReader)
123    m_pObjectReader = new ELFObjectReader(*this, pLinker);
124  return true;
125}
126
127bool GNULDBackend::initDynObjReader(MCLinker& pLinker)
128{
129  if (NULL == m_pDynObjReader)
130    m_pDynObjReader = new ELFDynObjReader(*this, pLinker);
131  return true;
132}
133
134bool GNULDBackend::initObjectWriter(MCLinker&)
135{
136  // TODO
137  return true;
138}
139
140bool GNULDBackend::initDynObjWriter(MCLinker& pLinker)
141{
142  if (NULL == m_pDynObjWriter)
143    m_pDynObjWriter = new ELFDynObjWriter(*this, pLinker);
144  return true;
145}
146
147bool GNULDBackend::initExecWriter(MCLinker& pLinker)
148{
149  if (NULL == m_pExecWriter)
150    m_pExecWriter = new ELFExecWriter(*this, pLinker);
151  return true;
152}
153
154bool GNULDBackend::initExecSections(MCLinker& pMCLinker)
155{
156  if (NULL == m_pExecFileFormat)
157    m_pExecFileFormat = new ELFExecFileFormat(*this);
158
159  // initialize standard sections
160  m_pExecFileFormat->initStdSections(pMCLinker);
161  return true;
162}
163
164bool GNULDBackend::initDynObjSections(MCLinker& pMCLinker)
165{
166  if (NULL == m_pDynObjFileFormat)
167    m_pDynObjFileFormat = new ELFDynObjFileFormat(*this);
168
169  // initialize standard sections
170  m_pDynObjFileFormat->initStdSections(pMCLinker);
171  return true;
172}
173
174bool GNULDBackend::initStandardSymbols(MCLinker& pLinker, const Output& pOutput)
175{
176  ELFFileFormat* file_format = getOutputFormat(pOutput);
177
178  // -----  section symbols  ----- //
179  // .preinit_array
180  FragmentRef* preinit_array = NULL;
181  if (file_format->hasPreInitArray()) {
182    preinit_array = pLinker.getLayout().getFragmentRef(
183                   *(file_format->getPreInitArray().getSectionData()->begin()),
184                   0x0);
185  }
186  f_pPreInitArrayStart =
187     pLinker.defineSymbol<MCLinker::AsRefered,
188                          MCLinker::Resolve>("__preinit_array_start",
189                                             false, // isDyn
190                                             ResolveInfo::NoType,
191                                             ResolveInfo::Define,
192                                             ResolveInfo::Global,
193                                             0x0, // size
194                                             0x0, // value
195                                             preinit_array, // FragRef
196                                             ResolveInfo::Hidden);
197  f_pPreInitArrayEnd =
198     pLinker.defineSymbol<MCLinker::AsRefered,
199                          MCLinker::Resolve>("__preinit_array_end",
200                                             false, // isDyn
201                                             ResolveInfo::NoType,
202                                             ResolveInfo::Define,
203                                             ResolveInfo::Global,
204                                             0x0, // size
205                                             0x0, // value
206                                             NULL, // FragRef
207                                             ResolveInfo::Hidden);
208
209  // .init_array
210  FragmentRef* init_array = NULL;
211  if (file_format->hasInitArray()) {
212    init_array = pLinker.getLayout().getFragmentRef(
213                      *(file_format->getInitArray().getSectionData()->begin()),
214                      0x0);
215  }
216
217  f_pInitArrayStart =
218     pLinker.defineSymbol<MCLinker::AsRefered,
219                          MCLinker::Resolve>("__init_array_start",
220                                             false, // isDyn
221                                             ResolveInfo::NoType,
222                                             ResolveInfo::Define,
223                                             ResolveInfo::Global,
224                                             0x0, // size
225                                             0x0, // value
226                                             init_array, // FragRef
227                                             ResolveInfo::Hidden);
228  f_pInitArrayEnd =
229     pLinker.defineSymbol<MCLinker::AsRefered,
230                          MCLinker::Resolve>("__init_array_end",
231                                             false, // isDyn
232                                             ResolveInfo::NoType,
233                                             ResolveInfo::Define,
234                                             ResolveInfo::Global,
235                                             0x0, // size
236                                             0x0, // value
237                                             init_array, // FragRef
238                                             ResolveInfo::Hidden);
239
240  // .fini_array
241  FragmentRef* fini_array = NULL;
242  if (file_format->hasFiniArray()) {
243    fini_array = pLinker.getLayout().getFragmentRef(
244                     *(file_format->getFiniArray().getSectionData()->begin()),
245                     0x0);
246  }
247
248  f_pFiniArrayStart =
249     pLinker.defineSymbol<MCLinker::AsRefered,
250                          MCLinker::Resolve>("__fini_array_start",
251                                             false, // isDyn
252                                             ResolveInfo::NoType,
253                                             ResolveInfo::Define,
254                                             ResolveInfo::Global,
255                                             0x0, // size
256                                             0x0, // value
257                                             fini_array, // FragRef
258                                             ResolveInfo::Hidden);
259  f_pFiniArrayEnd =
260     pLinker.defineSymbol<MCLinker::AsRefered,
261                          MCLinker::Resolve>("__fini_array_end",
262                                             false, // isDyn
263                                             ResolveInfo::NoType,
264                                             ResolveInfo::Define,
265                                             ResolveInfo::Global,
266                                             0x0, // size
267                                             0x0, // value
268                                             fini_array, // FragRef
269                                             ResolveInfo::Hidden);
270
271  // .stack
272  FragmentRef* stack = NULL;
273  if (file_format->hasStack()) {
274    stack = pLinker.getLayout().getFragmentRef(
275                          *(file_format->getStack().getSectionData()->begin()),
276                          0x0);
277  }
278  f_pStack =
279     pLinker.defineSymbol<MCLinker::AsRefered,
280                          MCLinker::Resolve>("__stack",
281                                             false, // isDyn
282                                             ResolveInfo::NoType,
283                                             ResolveInfo::Define,
284                                             ResolveInfo::Global,
285                                             0x0, // size
286                                             0x0, // value
287                                             stack, // FragRef
288                                             ResolveInfo::Hidden);
289
290  // -----  segment symbols  ----- //
291  f_pExecutableStart =
292     pLinker.defineSymbol<MCLinker::AsRefered,
293                          MCLinker::Resolve>("__executable_start",
294                                             false, // isDyn
295                                             ResolveInfo::NoType,
296                                             ResolveInfo::Define,
297                                             ResolveInfo::Absolute,
298                                             0x0, // size
299                                             0x0, // value
300                                             NULL, // FragRef
301                                             ResolveInfo::Default);
302  f_pEText =
303     pLinker.defineSymbol<MCLinker::AsRefered,
304                          MCLinker::Resolve>("etext",
305                                             false, // isDyn
306                                             ResolveInfo::NoType,
307                                             ResolveInfo::Define,
308                                             ResolveInfo::Absolute,
309                                             0x0, // size
310                                             0x0, // value
311                                             NULL, // FragRef
312                                             ResolveInfo::Default);
313  f_p_EText =
314     pLinker.defineSymbol<MCLinker::AsRefered,
315                          MCLinker::Resolve>("_etext",
316                                             false, // isDyn
317                                             ResolveInfo::NoType,
318                                             ResolveInfo::Define,
319                                             ResolveInfo::Absolute,
320                                             0x0, // size
321                                             0x0, // value
322                                             NULL, // FragRef
323                                             ResolveInfo::Default);
324  f_p__EText =
325     pLinker.defineSymbol<MCLinker::AsRefered,
326                          MCLinker::Resolve>("__etext",
327                                             false, // isDyn
328                                             ResolveInfo::NoType,
329                                             ResolveInfo::Define,
330                                             ResolveInfo::Absolute,
331                                             0x0, // size
332                                             0x0, // value
333                                             NULL, // FragRef
334                                             ResolveInfo::Default);
335  f_pEData =
336     pLinker.defineSymbol<MCLinker::AsRefered,
337                          MCLinker::Resolve>("edata",
338                                             false, // isDyn
339                                             ResolveInfo::NoType,
340                                             ResolveInfo::Define,
341                                             ResolveInfo::Absolute,
342                                             0x0, // size
343                                             0x0, // value
344                                             NULL, // FragRef
345                                             ResolveInfo::Default);
346
347  f_pEnd =
348     pLinker.defineSymbol<MCLinker::AsRefered,
349                          MCLinker::Resolve>("end",
350                                             false, // isDyn
351                                             ResolveInfo::NoType,
352                                             ResolveInfo::Define,
353                                             ResolveInfo::Absolute,
354                                             0x0, // size
355                                             0x0, // value
356                                             NULL, // FragRef
357                                             ResolveInfo::Default);
358
359  // _edata is defined forcefully.
360  // @ref Google gold linker: defstd.cc: 186
361  f_p_EData =
362     pLinker.defineSymbol<MCLinker::Force,
363                          MCLinker::Resolve>("_edata",
364                                             false, // isDyn
365                                             ResolveInfo::NoType,
366                                             ResolveInfo::Define,
367                                             ResolveInfo::Absolute,
368                                             0x0, // size
369                                             0x0, // value
370                                             NULL, // FragRef
371                                             ResolveInfo::Default);
372
373  // __bss_start is defined forcefully.
374  // @ref Google gold linker: defstd.cc: 214
375  f_pBSSStart =
376     pLinker.defineSymbol<MCLinker::Force,
377                          MCLinker::Resolve>("__bss_start",
378                                             false, // isDyn
379                                             ResolveInfo::NoType,
380                                             ResolveInfo::Define,
381                                             ResolveInfo::Absolute,
382                                             0x0, // size
383                                             0x0, // value
384                                             NULL, // FragRef
385                                             ResolveInfo::Default);
386
387  // _end is defined forcefully.
388  // @ref Google gold linker: defstd.cc: 228
389  f_p_End =
390     pLinker.defineSymbol<MCLinker::Force,
391                          MCLinker::Resolve>("_end",
392                                             false, // isDyn
393                                             ResolveInfo::NoType,
394                                             ResolveInfo::Define,
395                                             ResolveInfo::Absolute,
396                                             0x0, // size
397                                             0x0, // value
398                                             NULL, // FragRef
399                                             ResolveInfo::Default);
400
401  return true;
402}
403
404bool
405GNULDBackend::finalizeStandardSymbols(MCLinker& pLinker, const Output& pOutput)
406{
407  ELFFileFormat* file_format = getOutputFormat(pOutput);
408
409  // -----  section symbols  ----- //
410  if (NULL != f_pPreInitArrayStart) {
411    if (!f_pPreInitArrayStart->hasFragRef()) {
412      f_pPreInitArrayStart->resolveInfo()->setBinding(ResolveInfo::Absolute);
413      f_pPreInitArrayStart->setValue(0x0);
414    }
415  }
416
417  if (NULL != f_pPreInitArrayEnd) {
418    if (f_pPreInitArrayEnd->hasFragRef()) {
419      f_pPreInitArrayEnd->setValue(f_pPreInitArrayEnd->value() +
420                                   file_format->getPreInitArray().size());
421    }
422    else {
423      f_pPreInitArrayEnd->resolveInfo()->setBinding(ResolveInfo::Absolute);
424      f_pPreInitArrayEnd->setValue(0x0);
425    }
426  }
427
428  if (NULL != f_pInitArrayStart) {
429    if (!f_pInitArrayStart->hasFragRef()) {
430      f_pInitArrayStart->resolveInfo()->setBinding(ResolveInfo::Absolute);
431      f_pInitArrayStart->setValue(0x0);
432    }
433  }
434
435  if (NULL != f_pInitArrayEnd) {
436    if (f_pInitArrayEnd->hasFragRef()) {
437      f_pInitArrayEnd->setValue(f_pInitArrayEnd->value() +
438                                file_format->getInitArray().size());
439    }
440    else {
441      f_pInitArrayEnd->resolveInfo()->setBinding(ResolveInfo::Absolute);
442      f_pInitArrayEnd->setValue(0x0);
443    }
444  }
445
446  if (NULL != f_pFiniArrayStart) {
447    if (!f_pFiniArrayStart->hasFragRef()) {
448      f_pFiniArrayStart->resolveInfo()->setBinding(ResolveInfo::Absolute);
449      f_pFiniArrayStart->setValue(0x0);
450    }
451  }
452
453  if (NULL != f_pFiniArrayEnd) {
454    if (f_pFiniArrayEnd->hasFragRef()) {
455      f_pFiniArrayEnd->setValue(f_pFiniArrayEnd->value() +
456                                file_format->getFiniArray().size());
457    }
458    else {
459      f_pFiniArrayEnd->resolveInfo()->setBinding(ResolveInfo::Absolute);
460      f_pFiniArrayEnd->setValue(0x0);
461    }
462  }
463
464  if (NULL != f_pStack) {
465    if (!f_pStack->hasFragRef()) {
466      f_pStack->resolveInfo()->setBinding(ResolveInfo::Absolute);
467      f_pStack->setValue(0x0);
468    }
469  }
470
471  // -----  segment symbols  ----- //
472  if (NULL != f_pExecutableStart) {
473    ELFSegment* exec_start = m_ELFSegmentTable.find(llvm::ELF::PT_LOAD, 0x0, 0x0);
474    if (NULL != exec_start) {
475      if (ResolveInfo::ThreadLocal != f_pExecutableStart->type()) {
476        f_pExecutableStart->setValue(f_pExecutableStart->value() +
477                                     exec_start->vaddr());
478      }
479    }
480    else
481      f_pExecutableStart->setValue(0x0);
482  }
483
484  if (NULL != f_pEText || NULL != f_p_EText || NULL !=f_p__EText) {
485    ELFSegment* etext = m_ELFSegmentTable.find(llvm::ELF::PT_LOAD,
486                                               llvm::ELF::PF_X,
487                                               llvm::ELF::PF_W);
488    if (NULL != etext) {
489      if (NULL != f_pEText && ResolveInfo::ThreadLocal != f_pEText->type()) {
490        f_pEText->setValue(f_pEText->value() +
491                           etext->vaddr() +
492                           etext->memsz());
493      }
494      if (NULL != f_p_EText && ResolveInfo::ThreadLocal != f_p_EText->type()) {
495        f_p_EText->setValue(f_p_EText->value() +
496                            etext->vaddr() +
497                            etext->memsz());
498      }
499      if (NULL != f_p__EText && ResolveInfo::ThreadLocal != f_p__EText->type()) {
500        f_p__EText->setValue(f_p__EText->value() +
501                            etext->vaddr() +
502                            etext->memsz());
503      }
504    }
505    else {
506      if (NULL != f_pEText)
507        f_pEText->setValue(0x0);
508      if (NULL != f_p_EText)
509        f_p_EText->setValue(0x0);
510      if (NULL != f_p__EText)
511        f_p__EText->setValue(0x0);
512    }
513  }
514
515  if (NULL != f_pEData || NULL != f_p_EData || NULL != f_pBSSStart ||
516      NULL != f_pEnd || NULL != f_p_End) {
517    ELFSegment* edata = m_ELFSegmentTable.find(llvm::ELF::PT_LOAD,
518                                               llvm::ELF::PF_W,
519                                               0x0);
520    if (NULL != edata) {
521      if (NULL != f_pEData && ResolveInfo::ThreadLocal != f_pEData->type()) {
522        f_pEData->setValue(f_pEData->value() +
523                            edata->vaddr() +
524                            edata->filesz());
525      }
526      if (NULL != f_p_EData && ResolveInfo::ThreadLocal != f_p_EData->type()) {
527        f_p_EData->setValue(f_p_EData->value() +
528                            edata->vaddr() +
529                            edata->filesz());
530      }
531      if (NULL != f_pBSSStart && ResolveInfo::ThreadLocal != f_pBSSStart->type()) {
532        f_pBSSStart->setValue(f_pBSSStart->value() +
533                              edata->vaddr() +
534                              edata->filesz());
535      }
536
537      if (NULL != f_pEnd && ResolveInfo::ThreadLocal != f_pEnd->type()) {
538        f_pEnd->setValue(f_pEnd->value() +
539                         edata->vaddr() +
540                         edata->memsz());
541      }
542      if (NULL != f_p_End && ResolveInfo::ThreadLocal != f_p_End->type()) {
543        f_p_End->setValue(f_p_End->value() +
544                          edata->vaddr() +
545                          edata->memsz());
546      }
547    }
548    else {
549      if (NULL != f_pEData)
550        f_pEData->setValue(0x0);
551      if (NULL != f_p_EData)
552        f_p_EData->setValue(0x0);
553      if (NULL != f_pBSSStart)
554        f_pBSSStart->setValue(0x0);
555
556      if (NULL != f_pEnd)
557        f_pEnd->setValue(0x0);
558      if (NULL != f_p_End)
559        f_p_End->setValue(0x0);
560    }
561  }
562
563  return true;
564}
565
566GNUArchiveReader *GNULDBackend::getArchiveReader()
567{
568  assert(NULL != m_pArchiveReader);
569  return m_pArchiveReader;
570}
571
572const GNUArchiveReader *GNULDBackend::getArchiveReader() const
573{
574  assert(NULL != m_pArchiveReader);
575  return m_pArchiveReader;
576}
577
578ELFObjectReader *GNULDBackend::getObjectReader()
579{
580  assert(NULL != m_pObjectReader);
581  return m_pObjectReader;
582}
583
584const ELFObjectReader *GNULDBackend::getObjectReader() const
585{
586  assert(NULL != m_pObjectReader);
587  return m_pObjectReader;
588}
589
590ELFDynObjReader *GNULDBackend::getDynObjReader()
591{
592  assert(NULL != m_pDynObjReader);
593  return m_pDynObjReader;
594}
595
596const ELFDynObjReader *GNULDBackend::getDynObjReader() const
597{
598  assert(NULL != m_pDynObjReader);
599  return m_pDynObjReader;
600}
601
602ELFObjectWriter *GNULDBackend::getObjectWriter()
603{
604  // TODO
605  return NULL;
606}
607
608const ELFObjectWriter *GNULDBackend::getObjectWriter() const
609{
610  // TODO
611  return NULL;
612}
613
614ELFDynObjWriter *GNULDBackend::getDynObjWriter()
615{
616  assert(NULL != m_pDynObjWriter);
617  return m_pDynObjWriter;
618}
619
620const ELFDynObjWriter *GNULDBackend::getDynObjWriter() const
621{
622  assert(NULL != m_pDynObjWriter);
623  return m_pDynObjWriter;
624}
625
626ELFExecWriter *GNULDBackend::getExecWriter()
627{
628  assert(NULL != m_pExecWriter);
629  return m_pExecWriter;
630}
631
632const ELFExecWriter *GNULDBackend::getExecWriter() const
633{
634  assert(NULL != m_pExecWriter);
635  return m_pExecWriter;
636}
637
638ELFFileFormat* GNULDBackend::getOutputFormat(const Output& pOutput)
639{
640  switch (pOutput.type()) {
641    case Output::DynObj:
642      return getDynObjFileFormat();
643    case Output::Exec:
644      return getExecFileFormat();
645    // FIXME: We do not support building .o now
646    case Output::Object:
647    default:
648      fatal(diag::unrecognized_output_file) << pOutput.type();
649      return NULL;
650  }
651}
652
653const ELFFileFormat* GNULDBackend::getOutputFormat(const Output& pOutput) const
654{
655  switch (pOutput.type()) {
656    case Output::DynObj:
657      return getDynObjFileFormat();
658    case Output::Exec:
659      return getExecFileFormat();
660    // FIXME: We do not support building .o now
661    case Output::Object:
662    default:
663      fatal(diag::unrecognized_output_file) << pOutput.type();
664      return NULL;
665  }
666}
667
668ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat()
669{
670  assert(NULL != m_pDynObjFileFormat);
671  return m_pDynObjFileFormat;
672}
673
674const ELFDynObjFileFormat* GNULDBackend::getDynObjFileFormat() const
675{
676  assert(NULL != m_pDynObjFileFormat);
677  return m_pDynObjFileFormat;
678}
679
680ELFExecFileFormat* GNULDBackend::getExecFileFormat()
681{
682  assert(NULL != m_pExecFileFormat);
683  return m_pExecFileFormat;
684}
685
686const ELFExecFileFormat* GNULDBackend::getExecFileFormat() const
687{
688  assert(NULL != m_pExecFileFormat);
689  return m_pExecFileFormat;
690}
691
692/// sizeNamePools - compute the size of regular name pools
693/// In ELF executable files, regular name pools are .symtab, .strtab,
694/// .dynsym, .dynstr, and .hash
695void
696GNULDBackend::sizeNamePools(const Output& pOutput,
697                            const SymbolCategory& pSymbols,
698                            const MCLDInfo& pLDInfo)
699{
700  // size of string tables starts from 1 to hold the null character in their
701  // first byte
702  size_t symtab = 1;
703  size_t dynsym = 1;
704  // number of entries in symbol tables starts from 1 to hold the special entry
705  // at index 0 (STN_UNDEF). See ELF Spec Book I, p1-21.
706  size_t strtab = 1;
707  size_t dynstr = 1;
708  size_t hash   = 0;
709
710  // compute size of .symtab, .dynsym and .strtab
711  SymbolCategory::const_iterator symbol;
712  SymbolCategory::const_iterator symEnd = pSymbols.end();
713  for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) {
714    size_t str_size = (*symbol)->nameSize() + 1;
715    if (isDynamicSymbol(**symbol, pOutput)) {
716      ++dynsym;
717      dynstr += str_size;
718    }
719    ++symtab;
720    strtab += str_size;
721  }
722
723  ELFFileFormat* file_format = getOutputFormat(pOutput);
724
725  switch(pOutput.type()) {
726    // compute size of .dynstr and .hash
727    case Output::DynObj:
728    case Output::Exec: {
729      // add DT_NEED strings into .dynstr and .dynamic
730      // Rules:
731      //   1. ignore --no-add-needed
732      //   2. force count in --no-as-needed
733      //   3. judge --as-needed
734      InputTree::const_bfs_iterator input, inputEnd = pLDInfo.inputs().bfs_end();
735      for (input = pLDInfo.inputs().bfs_begin(); input != inputEnd; ++input) {
736        if (Input::DynObj == (*input)->type()) {
737          // --add-needed
738          if ((*input)->attribute()->isAddNeeded()) {
739            // --no-as-needed
740            if (!(*input)->attribute()->isAsNeeded()) {
741              dynstr += (*input)->name().size() + 1;
742              dynamic().reserveNeedEntry();
743            }
744            // --as-needed
745            else if ((*input)->isNeeded()) {
746              dynstr += (*input)->name().size() + 1;
747              dynamic().reserveNeedEntry();
748            }
749          }
750        }
751      } // for
752
753      // compute .hash
754      // Both Elf32_Word and Elf64_Word are 4 bytes
755      hash = (2 + getHashBucketCount(dynsym, false) + dynsym) *
756             sizeof(llvm::ELF::Elf32_Word);
757
758      // set size
759      dynstr += pOutput.name().size() + 1;
760      if (32 == bitclass())
761        file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf32_Sym));
762      else
763        file_format->getDynSymTab().setSize(dynsym*sizeof(llvm::ELF::Elf64_Sym));
764      file_format->getDynStrTab().setSize(dynstr);
765      file_format->getHashTab().setSize(hash);
766
767    }
768    /* fall through */
769    case Output::Object: {
770      if (32 == bitclass())
771        file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf32_Sym));
772      else
773        file_format->getSymTab().setSize(symtab*sizeof(llvm::ELF::Elf64_Sym));
774      file_format->getStrTab().setSize(strtab);
775      break;
776    }
777  } // end of switch
778
779  // reserve fixed entries in the .dynamic section.
780  if (Output::DynObj == pOutput.type() || Output::Exec == pOutput.type()) {
781    // Because some entries in .dynamic section need information of .dynsym,
782    // .dynstr, .symtab, .strtab and .hash, we can not reserve non-DT_NEEDED
783    // entries until we get the size of the sections mentioned above
784    dynamic().reserveEntries(pLDInfo, *file_format);
785    file_format->getDynamic().setSize(dynamic().numOfBytes());
786  }
787}
788
789/// emitRegNamePools - emit regular name pools - .symtab, .strtab
790///
791/// the size of these tables should be computed before layout
792/// layout should computes the start offset of these tables
793void GNULDBackend::emitRegNamePools(Output& pOutput,
794                                    SymbolCategory& pSymbols,
795                                    const Layout& pLayout,
796                                    const MCLDInfo& pLDInfo)
797{
798
799  assert(pOutput.hasMemArea());
800
801  bool sym_exist = false;
802  HashTableType::entry_type* entry = 0;
803
804  ELFFileFormat* file_format = getOutputFormat(pOutput);
805  if (pOutput.type() == Output::Object) {
806    // add first symbol into m_pSymIndexMap
807    entry = m_pSymIndexMap->insert(NULL, sym_exist);
808    entry->setValue(0);
809
810    // TODO: not support yet
811    return;
812  }
813
814  LDSection& symtab_sect = file_format->getSymTab();
815  LDSection& strtab_sect = file_format->getStrTab();
816
817  MemoryRegion* symtab_region = pOutput.memArea()->request(symtab_sect.offset(),
818                                                           symtab_sect.size());
819  MemoryRegion* strtab_region = pOutput.memArea()->request(strtab_sect.offset(),
820                                                           strtab_sect.size());
821
822  // set up symtab_region
823  llvm::ELF::Elf32_Sym* symtab32 = NULL;
824  llvm::ELF::Elf64_Sym* symtab64 = NULL;
825  if (32 == bitclass())
826    symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
827  else if (64 == bitclass())
828    symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
829  else
830    llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") +
831                             llvm::Twine(bitclass()) +
832                             llvm::Twine(".\n"));
833  // set up strtab_region
834  char* strtab = (char*)strtab_region->start();
835  strtab[0] = '\0';
836
837  // initialize the first ELF symbol
838  if (32 == bitclass()) {
839    symtab32[0].st_name  = 0;
840    symtab32[0].st_value = 0;
841    symtab32[0].st_size  = 0;
842    symtab32[0].st_info  = 0;
843    symtab32[0].st_other = 0;
844    symtab32[0].st_shndx = 0;
845  }
846  else { // must 64
847    symtab64[0].st_name  = 0;
848    symtab64[0].st_value = 0;
849    symtab64[0].st_size  = 0;
850    symtab64[0].st_info  = 0;
851    symtab64[0].st_other = 0;
852    symtab64[0].st_shndx = 0;
853  }
854
855  size_t symtabIdx = 1;
856  size_t strtabsize = 1;
857  // compute size of .symtab, .dynsym and .strtab
858  SymbolCategory::iterator symbol;
859  SymbolCategory::iterator symEnd = pSymbols.end();
860  for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) {
861
862     // maintain output's symbol and index map if building .o file
863    if (Output::Object == pOutput.type()) {
864      entry = m_pSymIndexMap->insert(NULL, sym_exist);
865      entry->setValue(symtabIdx);
866    }
867
868    // FIXME: check the endian between host and target
869    // write out symbol
870    if (32 == bitclass()) {
871      symtab32[symtabIdx].st_name  = strtabsize;
872      symtab32[symtabIdx].st_value = getSymbolValue(**symbol);
873      symtab32[symtabIdx].st_size  = getSymbolSize(**symbol);
874      symtab32[symtabIdx].st_info  = getSymbolInfo(**symbol);
875      symtab32[symtabIdx].st_other = (*symbol)->visibility();
876      symtab32[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
877    }
878    else { // must 64
879      symtab64[symtabIdx].st_name  = strtabsize;
880      symtab64[symtabIdx].st_value = getSymbolValue(**symbol);
881      symtab64[symtabIdx].st_size  = getSymbolSize(**symbol);
882      symtab64[symtabIdx].st_info  = getSymbolInfo(**symbol);
883      symtab64[symtabIdx].st_other = (*symbol)->visibility();
884      symtab64[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
885    }
886    // write out string
887    strcpy((strtab + strtabsize), (*symbol)->name());
888
889    // write out
890    // sum up counters
891    ++symtabIdx;
892    strtabsize += (*symbol)->nameSize() + 1;
893  }
894}
895
896/// emitNamePools - emit dynamic name pools - .dyntab, .dynstr, .hash
897///
898/// the size of these tables should be computed before layout
899/// layout should computes the start offset of these tables
900void GNULDBackend::emitDynNamePools(Output& pOutput,
901                                    SymbolCategory& pSymbols,
902                                    const Layout& pLayout,
903                                    const MCLDInfo& pLDInfo)
904{
905  assert(pOutput.hasMemArea());
906  ELFFileFormat* file_format = getOutputFormat(pOutput);
907
908  bool sym_exist = false;
909  HashTableType::entry_type* entry = 0;
910
911  LDSection& symtab_sect = file_format->getDynSymTab();
912  LDSection& strtab_sect = file_format->getDynStrTab();
913  LDSection& hash_sect   = file_format->getHashTab();
914  LDSection& dyn_sect    = file_format->getDynamic();
915
916  MemoryRegion* symtab_region = pOutput.memArea()->request(symtab_sect.offset(),
917                                                           symtab_sect.size());
918  MemoryRegion* strtab_region = pOutput.memArea()->request(strtab_sect.offset(),
919                                                           strtab_sect.size());
920  MemoryRegion* hash_region = pOutput.memArea()->request(hash_sect.offset(),
921                                                         hash_sect.size());
922  MemoryRegion* dyn_region = pOutput.memArea()->request(dyn_sect.offset(),
923                                                        dyn_sect.size());
924  // set up symtab_region
925  llvm::ELF::Elf32_Sym* symtab32 = NULL;
926  llvm::ELF::Elf64_Sym* symtab64 = NULL;
927  if (32 == bitclass())
928    symtab32 = (llvm::ELF::Elf32_Sym*)symtab_region->start();
929  else if (64 == bitclass())
930    symtab64 = (llvm::ELF::Elf64_Sym*)symtab_region->start();
931  else
932    llvm::report_fatal_error(llvm::Twine("unsupported bitclass ") +
933                             llvm::Twine(bitclass()) +
934                             llvm::Twine(".\n"));
935
936  // initialize the first ELF symbol
937  if (32 == bitclass()) {
938    symtab32[0].st_name  = 0;
939    symtab32[0].st_value = 0;
940    symtab32[0].st_size  = 0;
941    symtab32[0].st_info  = 0;
942    symtab32[0].st_other = 0;
943    symtab32[0].st_shndx = 0;
944  }
945  else { // must 64
946    symtab64[0].st_name  = 0;
947    symtab64[0].st_value = 0;
948    symtab64[0].st_size  = 0;
949    symtab64[0].st_info  = 0;
950    symtab64[0].st_other = 0;
951    symtab64[0].st_shndx = 0;
952  }
953  // set up strtab_region
954  char* strtab = (char*)strtab_region->start();
955  strtab[0] = '\0';
956
957  // add the first symbol into m_pSymIndexMap
958  entry = m_pSymIndexMap->insert(NULL, sym_exist);
959  entry->setValue(0);
960
961  size_t symtabIdx = 1;
962  size_t strtabsize = 1;
963
964  // emit of .dynsym, and .dynstr
965  SymbolCategory::iterator symbol;
966  SymbolCategory::iterator symEnd = pSymbols.end();
967  for (symbol = pSymbols.begin(); symbol != symEnd; ++symbol) {
968    if (!isDynamicSymbol(**symbol, pOutput))
969      continue;
970
971    // maintain output's symbol and index map
972    entry = m_pSymIndexMap->insert(*symbol, sym_exist);
973    entry->setValue(symtabIdx);
974
975    // FIXME: check the endian between host and target
976    // write out symbol
977    if (32 == bitclass()) {
978      symtab32[symtabIdx].st_name  = strtabsize;
979      symtab32[symtabIdx].st_value = (*symbol)->value();
980      symtab32[symtabIdx].st_size  = getSymbolSize(**symbol);
981      symtab32[symtabIdx].st_info  = getSymbolInfo(**symbol);
982      symtab32[symtabIdx].st_other = (*symbol)->visibility();
983      symtab32[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
984    }
985    else { // must 64
986      symtab64[symtabIdx].st_name  = strtabsize;
987      symtab64[symtabIdx].st_value = (*symbol)->value();
988      symtab64[symtabIdx].st_size  = getSymbolSize(**symbol);
989      symtab64[symtabIdx].st_info  = getSymbolInfo(**symbol);
990      symtab64[symtabIdx].st_other = (*symbol)->visibility();
991      symtab64[symtabIdx].st_shndx = getSymbolShndx(**symbol, pLayout);
992    }
993    // write out string
994    strcpy((strtab + strtabsize), (*symbol)->name());
995
996    // sum up counters
997    ++symtabIdx;
998    strtabsize += (*symbol)->nameSize() + 1;
999  }
1000
1001  // emit DT_NEED
1002  // add DT_NEED strings into .dynstr
1003  // Rules:
1004  //   1. ignore --no-add-needed
1005  //   2. force count in --no-as-needed
1006  //   3. judge --as-needed
1007  ELFDynamic::iterator dt_need = dynamic().needBegin();
1008  InputTree::const_bfs_iterator input, inputEnd = pLDInfo.inputs().bfs_end();
1009  for (input = pLDInfo.inputs().bfs_begin(); input != inputEnd; ++input) {
1010    if (Input::DynObj == (*input)->type()) {
1011      // --add-needed
1012      if ((*input)->attribute()->isAddNeeded()) {
1013        // --no-as-needed
1014        if (!(*input)->attribute()->isAsNeeded()) {
1015          strcpy((strtab + strtabsize), (*input)->name().c_str());
1016          (*dt_need)->setValue(llvm::ELF::DT_NEEDED, strtabsize);
1017          strtabsize += (*input)->name().size() + 1;
1018          ++dt_need;
1019        }
1020        // --as-needed
1021        else if ((*input)->isNeeded()) {
1022          strcpy((strtab + strtabsize), (*input)->name().c_str());
1023          (*dt_need)->setValue(llvm::ELF::DT_NEEDED, strtabsize);
1024          strtabsize += (*input)->name().size() + 1;
1025          ++dt_need;
1026        }
1027      }
1028    }
1029  } // for
1030
1031  // emit soname
1032  // initialize value of ELF .dynamic section
1033  if (Output::DynObj == pOutput.type())
1034    dynamic().applySoname(strtabsize);
1035  dynamic().applyEntries(pLDInfo, *file_format);
1036  dynamic().emit(dyn_sect, *dyn_region);
1037
1038  strcpy((strtab + strtabsize), pOutput.name().c_str());
1039  strtabsize += pOutput.name().size() + 1;
1040
1041  // emit hash table
1042  // FIXME: this verion only emit SVR4 hash section.
1043  //        Please add GNU new hash section
1044
1045  // both 32 and 64 bits hash table use 32-bit entry
1046  // set up hash_region
1047  uint32_t* word_array = (uint32_t*)hash_region->start();
1048  uint32_t& nbucket = word_array[0];
1049  uint32_t& nchain  = word_array[1];
1050
1051  nbucket = getHashBucketCount(symtabIdx, false);
1052  nchain  = symtabIdx;
1053
1054  uint32_t* bucket = (word_array + 2);
1055  uint32_t* chain  = (bucket + nbucket);
1056
1057  // initialize bucket
1058  bzero((void*)bucket, nbucket);
1059
1060  StringHash<ELF> hash_func;
1061
1062  if (32 == bitclass()) {
1063    for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) {
1064      llvm::StringRef name(strtab + symtab32[sym_idx].st_name);
1065      size_t bucket_pos = hash_func(name) % nbucket;
1066      chain[sym_idx] = bucket[bucket_pos];
1067      bucket[bucket_pos] = sym_idx;
1068    }
1069  }
1070  else if (64 == bitclass()) {
1071    for (size_t sym_idx=0; sym_idx < symtabIdx; ++sym_idx) {
1072      llvm::StringRef name(strtab + symtab64[sym_idx].st_name);
1073      size_t bucket_pos = hash_func(name) % nbucket;
1074      chain[sym_idx] = bucket[bucket_pos];
1075      bucket[bucket_pos] = sym_idx;
1076    }
1077  }
1078}
1079
1080/// sizeInterp - compute the size of the .interp section
1081void GNULDBackend::sizeInterp(const Output& pOutput, const MCLDInfo& pLDInfo)
1082{
1083  assert(pOutput.type() == Output::Exec);
1084
1085  const char* dyld_name;
1086  if (pLDInfo.options().hasDyld())
1087    dyld_name = pLDInfo.options().dyld().c_str();
1088  else
1089    dyld_name = dyld();
1090
1091  LDSection& interp = getExecFileFormat()->getInterp();
1092  interp.setSize(std::strlen(dyld_name) + 1);
1093}
1094
1095/// emitInterp - emit the .interp
1096void GNULDBackend::emitInterp(Output& pOutput, const MCLDInfo& pLDInfo)
1097{
1098  assert(pOutput.type() == Output::Exec &&
1099         getExecFileFormat()->hasInterp() &&
1100         pOutput.hasMemArea());
1101
1102  const LDSection& interp = getExecFileFormat()->getInterp();
1103  MemoryRegion *region = pOutput.memArea()->request(
1104                                              interp.offset(), interp.size());
1105  const char* dyld_name;
1106  if (pLDInfo.options().hasDyld())
1107    dyld_name = pLDInfo.options().dyld().c_str();
1108  else
1109    dyld_name = dyld();
1110
1111  std::memcpy(region->start(), dyld_name, interp.size());
1112}
1113
1114/// getSectionOrder
1115unsigned int GNULDBackend::getSectionOrder(const Output& pOutput,
1116                                           const LDSection& pSectHdr,
1117                                           const MCLDInfo& pInfo) const
1118{
1119  // NULL section should be the "1st" section
1120  if (LDFileFormat::Null == pSectHdr.kind())
1121    return 0;
1122
1123  // if the section is not ALLOC, lay it out until the last possible moment
1124  if (0 == (pSectHdr.flag() & llvm::ELF::SHF_ALLOC))
1125    return SHO_UNDEFINED;
1126
1127  bool is_write = (pSectHdr.flag() & llvm::ELF::SHF_WRITE) != 0;
1128  bool is_exec = (pSectHdr.flag() & llvm::ELF::SHF_EXECINSTR) != 0;
1129  const ELFFileFormat* file_format = getOutputFormat(pOutput);
1130
1131  // TODO: need to take care other possible output sections
1132  switch (pSectHdr.kind()) {
1133    case LDFileFormat::Regular:
1134      if (is_exec) {
1135        if (&pSectHdr == &file_format->getInit())
1136          return SHO_INIT;
1137        if (&pSectHdr == &file_format->getFini())
1138          return SHO_FINI;
1139        return SHO_TEXT;
1140      } else if (!is_write) {
1141        return SHO_RO;
1142      } else {
1143        if (pInfo.options().hasRelro()) {
1144          if (pSectHdr.type() == llvm::ELF::SHT_PREINIT_ARRAY ||
1145              pSectHdr.type() == llvm::ELF::SHT_INIT_ARRAY ||
1146              pSectHdr.type() == llvm::ELF::SHT_FINI_ARRAY ||
1147              &pSectHdr == &file_format->getCtors() ||
1148              &pSectHdr == &file_format->getDtors() ||
1149              &pSectHdr == &file_format->getJCR() ||
1150              0 == pSectHdr.name().compare(".data.rel.ro"))
1151            return SHO_RELRO;
1152          if (0 == pSectHdr.name().compare(".data.rel.ro.local"))
1153            return SHO_RELRO_LOCAL;
1154        }
1155        return SHO_DATA;
1156      }
1157
1158    case LDFileFormat::BSS:
1159      return SHO_BSS;
1160
1161    case LDFileFormat::NamePool:
1162      if (&pSectHdr == &file_format->getDynamic())
1163        return SHO_RELRO;
1164      return SHO_NAMEPOOL;
1165
1166    case LDFileFormat::Relocation:
1167      if (&pSectHdr == &file_format->getRelPlt() ||
1168          &pSectHdr == &file_format->getRelaPlt())
1169        return SHO_REL_PLT;
1170      return SHO_RELOCATION;
1171
1172    // get the order from target for target specific sections
1173    case LDFileFormat::Target:
1174      return getTargetSectionOrder(pOutput, pSectHdr, pInfo);
1175
1176    // handle .interp
1177    case LDFileFormat::Note:
1178      return SHO_INTERP;
1179
1180    case LDFileFormat::EhFrame:
1181    case LDFileFormat::EhFrameHdr:
1182    case LDFileFormat::GCCExceptTable:
1183      return SHO_EXCEPTION;
1184
1185    case LDFileFormat::MetaData:
1186    case LDFileFormat::Debug:
1187    default:
1188      return SHO_UNDEFINED;
1189  }
1190}
1191
1192/// getSymbolSize
1193uint64_t GNULDBackend::getSymbolSize(const LDSymbol& pSymbol) const
1194{
1195  // @ref Google gold linker: symtab.cc: 2780
1196  // undefined and dynamic symbols should have zero size.
1197  if (pSymbol.isDyn() || pSymbol.desc() == ResolveInfo::Undefined)
1198    return 0x0;
1199  return pSymbol.resolveInfo()->size();
1200}
1201
1202/// getSymbolInfo
1203uint64_t GNULDBackend::getSymbolInfo(const LDSymbol& pSymbol) const
1204{
1205  // set binding
1206  uint8_t bind = 0x0;
1207  if (pSymbol.resolveInfo()->isLocal())
1208    bind = llvm::ELF::STB_LOCAL;
1209  else if (pSymbol.resolveInfo()->isGlobal())
1210    bind = llvm::ELF::STB_GLOBAL;
1211  else if (pSymbol.resolveInfo()->isWeak())
1212    bind = llvm::ELF::STB_WEAK;
1213  else if (pSymbol.resolveInfo()->isAbsolute()) {
1214    // (Luba) Is a absolute but not global (weak or local) symbol meaningful?
1215    bind = llvm::ELF::STB_GLOBAL;
1216  }
1217
1218  if (pSymbol.visibility() == llvm::ELF::STV_INTERNAL ||
1219      pSymbol.visibility() == llvm::ELF::STV_HIDDEN)
1220    bind = llvm::ELF::STB_LOCAL;
1221
1222  uint32_t type = pSymbol.resolveInfo()->type();
1223  // if the IndirectFunc symbol (i.e., STT_GNU_IFUNC) is from dynobj, change
1224  // its type to Function
1225  if (type == ResolveInfo::IndirectFunc && pSymbol.isDyn())
1226    type = ResolveInfo::Function;
1227  return (type | (bind << 4));
1228}
1229
1230/// getSymbolValue - this function is called after layout()
1231uint64_t GNULDBackend::getSymbolValue(const LDSymbol& pSymbol) const
1232{
1233  if (pSymbol.isDyn())
1234    return 0x0;
1235
1236  return pSymbol.value();
1237}
1238
1239/// getSymbolShndx - this function is called after layout()
1240uint64_t
1241GNULDBackend::getSymbolShndx(const LDSymbol& pSymbol, const Layout& pLayout) const
1242{
1243  if (pSymbol.resolveInfo()->isAbsolute())
1244    return llvm::ELF::SHN_ABS;
1245  if (pSymbol.resolveInfo()->isCommon())
1246    return llvm::ELF::SHN_COMMON;
1247  if (pSymbol.resolveInfo()->isUndef() || pSymbol.isDyn())
1248    return llvm::ELF::SHN_UNDEF;
1249
1250  if (pSymbol.resolveInfo()->isLocal()) {
1251    switch (pSymbol.type()) {
1252      case ResolveInfo::NoType:
1253      case ResolveInfo::File:
1254        return llvm::ELF::SHN_ABS;
1255    }
1256  }
1257
1258  assert(pSymbol.hasFragRef() && "symbols must have fragment reference to get its index");
1259  return pLayout.getOutputLDSection(*pSymbol.fragRef()->frag())->index();
1260}
1261
1262/// getSymbolIdx - called by emitRelocation to get the ouput symbol table index
1263size_t GNULDBackend::getSymbolIdx(LDSymbol* pSymbol) const
1264{
1265   HashTableType::iterator entry = m_pSymIndexMap->find(pSymbol);
1266   return entry.getEntry()->value();
1267}
1268
1269/// allocateCommonSymbols - allocate common symbols in the corresponding
1270/// sections.
1271/// @refer Google gold linker: common.cc: 214
1272bool
1273GNULDBackend::allocateCommonSymbols(const MCLDInfo& pInfo, MCLinker& pLinker) const
1274{
1275  SymbolCategory& symbol_list = pLinker.getOutputSymbols();
1276
1277  if (symbol_list.emptyCommons() && symbol_list.emptyLocals())
1278    return true;
1279
1280  SymbolCategory::iterator com_sym, com_end;
1281
1282  // FIXME: If the order of common symbols is defined, then sort common symbols
1283  // std::sort(com_sym, com_end, some kind of order);
1284
1285  // get or create corresponding BSS LDSection
1286  LDSection* bss_sect = &pLinker.getOrCreateOutputSectHdr(".bss",
1287                                   LDFileFormat::BSS,
1288                                   llvm::ELF::SHT_NOBITS,
1289                                   llvm::ELF::SHF_WRITE | llvm::ELF::SHF_ALLOC);
1290
1291  LDSection* tbss_sect = &pLinker.getOrCreateOutputSectHdr(
1292                                   ".tbss",
1293                                   LDFileFormat::BSS,
1294                                   llvm::ELF::SHT_NOBITS,
1295                                   llvm::ELF::SHF_WRITE | llvm::ELF::SHF_ALLOC);
1296
1297  assert(NULL != bss_sect && NULL !=tbss_sect);
1298
1299  // get or create corresponding BSS SectionData
1300  SectionData& bss_sect_data = pLinker.getOrCreateSectData(*bss_sect);
1301  SectionData& tbss_sect_data = pLinker.getOrCreateSectData(*tbss_sect);
1302
1303  // remember original BSS size
1304  uint64_t bss_offset  = bss_sect->size();
1305  uint64_t tbss_offset = tbss_sect->size();
1306
1307  // allocate all local common symbols
1308  com_end = symbol_list.localEnd();
1309
1310  for (com_sym = symbol_list.localBegin(); com_sym != com_end; ++com_sym) {
1311    if (ResolveInfo::Common == (*com_sym)->desc()) {
1312      // We have to reset the description of the symbol here. When doing
1313      // incremental linking, the output relocatable object may have common
1314      // symbols. Therefore, we can not treat common symbols as normal symbols
1315      // when emitting the regular name pools. We must change the symbols'
1316      // description here.
1317      (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
1318      Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
1319      (*com_sym)->setFragmentRef(new FragmentRef(*frag, 0));
1320
1321      if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
1322        // allocate TLS common symbol in tbss section
1323        tbss_offset += pLinker.getLayout().appendFragment(*frag,
1324                                                          tbss_sect_data,
1325                                                          (*com_sym)->value());
1326      }
1327      else {
1328        bss_offset += pLinker.getLayout().appendFragment(*frag,
1329                                                         bss_sect_data,
1330                                                         (*com_sym)->value());
1331      }
1332    }
1333  }
1334
1335  // allocate all global common symbols
1336  com_end = symbol_list.commonEnd();
1337  for (com_sym = symbol_list.commonBegin(); com_sym != com_end; ++com_sym) {
1338    // We have to reset the description of the symbol here. When doing
1339    // incremental linking, the output relocatable object may have common
1340    // symbols. Therefore, we can not treat common symbols as normal symbols
1341    // when emitting the regular name pools. We must change the symbols'
1342    // description here.
1343    (*com_sym)->resolveInfo()->setDesc(ResolveInfo::Define);
1344    Fragment* frag = new FillFragment(0x0, 1, (*com_sym)->size());
1345    (*com_sym)->setFragmentRef(new FragmentRef(*frag, 0));
1346
1347    if (ResolveInfo::ThreadLocal == (*com_sym)->type()) {
1348      // allocate TLS common symbol in tbss section
1349      tbss_offset += pLinker.getLayout().appendFragment(*frag,
1350                                                        tbss_sect_data,
1351                                                        (*com_sym)->value());
1352    }
1353    else {
1354      bss_offset += pLinker.getLayout().appendFragment(*frag,
1355                                                       bss_sect_data,
1356                                                       (*com_sym)->value());
1357    }
1358  }
1359
1360  bss_sect->setSize(bss_offset);
1361  tbss_sect->setSize(tbss_offset);
1362  symbol_list.changeCommonsToGlobal();
1363  return true;
1364}
1365
1366
1367/// createProgramHdrs - base on output sections to create the program headers
1368void GNULDBackend::createProgramHdrs(Output& pOutput, const MCLDInfo& pInfo)
1369{
1370  assert(pOutput.hasContext());
1371  ELFFileFormat *file_format = getOutputFormat(pOutput);
1372
1373  // make PT_PHDR
1374  m_ELFSegmentTable.produce(llvm::ELF::PT_PHDR);
1375
1376  // make PT_INTERP
1377  if (file_format->hasInterp()) {
1378    ELFSegment* interp_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_INTERP);
1379    interp_seg->addSection(&file_format->getInterp());
1380  }
1381
1382  // FIXME: Should we consider -z relro here?
1383  if (pInfo.options().hasRelro()) {
1384    // if -z relro is given, we need to adjust sections' offset again, and let
1385    // PT_GNU_RELRO end on a common page boundary
1386    LDContext::SectionTable& sect_table = pOutput.context()->getSectionTable();
1387
1388    size_t idx;
1389    for (idx = 0; idx < pOutput.context()->numOfSections(); ++idx) {
1390      // find the first non-relro section
1391      if (getSectionOrder(pOutput, *sect_table[idx], pInfo) > SHO_RELRO_LAST) {
1392        break;
1393      }
1394    }
1395
1396    // align the first non-relro section to page boundary
1397    uint64_t offset = sect_table[idx]->offset();
1398    alignAddress(offset, commonPageSize(pInfo));
1399    sect_table[idx]->setOffset(offset);
1400
1401    // set up remaining section's offset
1402    for (++idx; idx < pOutput.context()->numOfSections(); ++idx) {
1403      uint64_t offset;
1404      size_t prev_idx = idx - 1;
1405      if (LDFileFormat::BSS == sect_table[prev_idx]->kind())
1406        offset = sect_table[prev_idx]->offset();
1407      else
1408        offset = sect_table[prev_idx]->offset() + sect_table[prev_idx]->size();
1409
1410      alignAddress(offset, sect_table[idx]->align());
1411      sect_table[idx]->setOffset(offset);
1412    }
1413  } // relro
1414
1415  uint32_t cur_seg_flag, prev_seg_flag = getSegmentFlag(0);
1416  uint64_t padding = 0;
1417  ELFSegment* load_seg = NULL;
1418  // make possible PT_LOAD segments
1419  LDContext::sect_iterator sect, sect_end = pOutput.context()->sectEnd();
1420  for (sect = pOutput.context()->sectBegin(); sect != sect_end; ++sect) {
1421
1422    if (0 == ((*sect)->flag() & llvm::ELF::SHF_ALLOC) &&
1423        LDFileFormat::Null != (*sect)->kind())
1424      continue;
1425
1426    // FIXME: Now only separate writable and non-writable PT_LOAD
1427    cur_seg_flag = getSegmentFlag((*sect)->flag());
1428    if ((prev_seg_flag & llvm::ELF::PF_W) ^ (cur_seg_flag & llvm::ELF::PF_W) ||
1429         LDFileFormat::Null == (*sect)->kind()) {
1430      // create new PT_LOAD segment
1431      load_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_LOAD);
1432      load_seg->setAlign(abiPageSize(pInfo));
1433
1434      // check if this segment needs padding
1435      padding = 0;
1436      if (((*sect)->offset() & (abiPageSize(pInfo) - 1)) != 0)
1437        padding = abiPageSize(pInfo);
1438    }
1439
1440    assert(NULL != load_seg);
1441    load_seg->addSection((*sect));
1442    if (cur_seg_flag != prev_seg_flag)
1443      load_seg->updateFlag(cur_seg_flag);
1444
1445    if (LDFileFormat::Null != (*sect)->kind())
1446      (*sect)->setAddr(segmentStartAddr(pOutput, pInfo) +
1447                       (*sect)->offset() +
1448                       padding);
1449
1450    prev_seg_flag = cur_seg_flag;
1451  }
1452
1453  // make PT_DYNAMIC
1454  if (file_format->hasDynamic()) {
1455    ELFSegment* dyn_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_DYNAMIC,
1456                                                    llvm::ELF::PF_R |
1457                                                    llvm::ELF::PF_W);
1458    dyn_seg->addSection(&file_format->getDynamic());
1459  }
1460
1461  if (pInfo.options().hasRelro()) {
1462    // make PT_GNU_RELRO
1463    ELFSegment* relro_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_GNU_RELRO);
1464    for (LDContext::sect_iterator sect = pOutput.context()->sectBegin();
1465         sect != pOutput.context()->sectEnd(); ++sect) {
1466      unsigned int order = getSectionOrder(pOutput, **sect, pInfo);
1467      if (SHO_RELRO_LOCAL == order ||
1468          SHO_RELRO == order ||
1469          SHO_RELRO_LAST == order) {
1470        relro_seg->addSection(*sect);
1471      }
1472    }
1473  }
1474
1475  // make PT_GNU_EH_FRAME
1476  if (file_format->hasEhFrameHdr()) {
1477    ELFSegment* eh_seg = m_ELFSegmentTable.produce(llvm::ELF::PT_GNU_EH_FRAME);
1478    eh_seg->addSection(&file_format->getEhFrameHdr());
1479  }
1480}
1481
1482/// setupProgramHdrs - set up the attributes of segments
1483void GNULDBackend:: setupProgramHdrs(const Output& pOutput, const MCLDInfo& pInfo)
1484{
1485  // update segment info
1486  ELFSegmentFactory::iterator seg, seg_end = m_ELFSegmentTable.end();
1487  for (seg = m_ELFSegmentTable.begin(); seg != seg_end; ++seg) {
1488    ELFSegment& segment = *seg;
1489
1490    // update PT_PHDR
1491    if (llvm::ELF::PT_PHDR == segment.type()) {
1492      uint64_t offset, phdr_size;
1493      if (32 == bitclass()) {
1494        offset = sizeof(llvm::ELF::Elf32_Ehdr);
1495        phdr_size = sizeof(llvm::ELF::Elf32_Phdr);
1496      }
1497      else {
1498        offset = sizeof(llvm::ELF::Elf64_Ehdr);
1499        phdr_size = sizeof(llvm::ELF::Elf64_Phdr);
1500      }
1501      segment.setOffset(offset);
1502      segment.setVaddr(segmentStartAddr(pOutput, pInfo) + offset);
1503      segment.setPaddr(segment.vaddr());
1504      segment.setFilesz(numOfSegments() * phdr_size);
1505      segment.setMemsz(numOfSegments() * phdr_size);
1506      segment.setAlign(bitclass() / 8);
1507      continue;
1508    }
1509
1510    // bypass if there is no section in this segment (e.g., PT_GNU_STACK)
1511    if (segment.numOfSections() == 0)
1512      continue;
1513
1514    segment.setOffset(segment.getFirstSection()->offset());
1515    if (llvm::ELF::PT_LOAD == segment.type() &&
1516        LDFileFormat::Null == segment.getFirstSection()->kind())
1517      segment.setVaddr(segmentStartAddr(pOutput, pInfo));
1518    else
1519      segment.setVaddr(segment.getFirstSection()->addr());
1520    segment.setPaddr(segment.vaddr());
1521
1522    const LDSection* last_sect = segment.getLastSection();
1523    assert(NULL != last_sect);
1524    uint64_t file_size = last_sect->offset() - segment.offset();
1525    if (LDFileFormat::BSS != last_sect->kind())
1526      file_size += last_sect->size();
1527    segment.setFilesz(file_size);
1528
1529    segment.setMemsz(last_sect->addr() - segment.vaddr() + last_sect->size());
1530  }
1531}
1532
1533/// createGNUStackInfo - create an output GNU stack section or segment if needed
1534/// @ref gold linker: layout.cc:2608
1535void GNULDBackend::createGNUStackInfo(const Output& pOutput,
1536                                      const MCLDInfo& pInfo,
1537                                      MCLinker& pLinker)
1538{
1539  uint32_t flag = 0x0;
1540  if (pInfo.options().hasStackSet()) {
1541    // 1. check the command line option (-z execstack or -z noexecstack)
1542    if (pInfo.options().hasExecStack())
1543      flag = llvm::ELF::SHF_EXECINSTR;
1544  } else {
1545    // 2. check the stack info from the input objects
1546    size_t object_count = 0, stack_note_count = 0;
1547    mcld::InputTree::const_bfs_iterator input, inEnd = pInfo.inputs().bfs_end();
1548    for (input=pInfo.inputs().bfs_begin(); input!=inEnd; ++input) {
1549      if ((*input)->type() == Input::Object) {
1550        ++object_count;
1551        const LDSection* sect = (*input)->context()->getSection(
1552                                                             ".note.GNU-stack");
1553        if (NULL != sect) {
1554          ++stack_note_count;
1555          // 2.1 found a stack note that is set as executable
1556          if (0 != (llvm::ELF::SHF_EXECINSTR & sect->flag())) {
1557            flag = llvm::ELF::SHF_EXECINSTR;
1558            break;
1559          }
1560        }
1561      }
1562    }
1563
1564    // 2.2 there are no stack note sections in all input objects
1565    if (0 == stack_note_count)
1566      return;
1567
1568    // 2.3 a special case. Use the target default to decide if the stack should
1569    //     be executable
1570    if (llvm::ELF::SHF_EXECINSTR != flag && object_count != stack_note_count)
1571      if (isDefaultExecStack())
1572        flag = llvm::ELF::SHF_EXECINSTR;
1573  }
1574
1575  if (pOutput.type() != Output::Object)
1576    m_ELFSegmentTable.produce(llvm::ELF::PT_GNU_STACK,
1577                              llvm::ELF::PF_R |
1578                              llvm::ELF::PF_W |
1579                              getSegmentFlag(flag));
1580  else
1581    pLinker.getOrCreateOutputSectHdr(".note.GNU-stack",
1582                                     LDFileFormat::Note,
1583                                     llvm::ELF::SHT_PROGBITS,
1584                                     flag);
1585}
1586
1587/// preLayout - Backend can do any needed modification before layout
1588void GNULDBackend::preLayout(const Output& pOutput,
1589                             const MCLDInfo& pLDInfo,
1590                             MCLinker& pLinker)
1591{
1592  // prelayout target first
1593  doPreLayout(pOutput, pLDInfo, pLinker);
1594
1595  if (pLDInfo.options().hasEhFrameHdr()) {
1596    // init EhFrameHdr and size the output section
1597    ELFFileFormat* format = getOutputFormat(pOutput);
1598    assert(NULL != getEhFrame());
1599    m_pEhFrameHdr = new EhFrameHdr(*getEhFrame(),
1600                                   format->getEhFrame(),
1601                                   format->getEhFrameHdr());
1602    m_pEhFrameHdr->sizeOutput();
1603  }
1604}
1605
1606/// postLayout - Backend can do any needed modification after layout
1607void GNULDBackend::postLayout(const Output& pOutput,
1608                              const MCLDInfo& pInfo,
1609                              MCLinker& pLinker)
1610{
1611  // 1. emit program headers
1612  if (pOutput.type() != Output::Object) {
1613    // 1.1 create program headers
1614    createProgramHdrs(pLinker.getLDInfo().output(), pInfo);
1615  }
1616
1617  // 1.2 create special GNU Stack note section or segment
1618  createGNUStackInfo(pOutput, pInfo, pLinker);
1619
1620  if (pOutput.type() != Output::Object) {
1621    // 1.3 set up the attributes of program headers
1622    setupProgramHdrs(pOutput, pInfo);
1623  }
1624
1625  // 2. target specific post layout
1626  doPostLayout(pOutput, pInfo, pLinker);
1627}
1628
1629void GNULDBackend::postProcessing(const Output& pOutput,
1630                                  const MCLDInfo& pInfo,
1631                                  MCLinker& pLinker)
1632{
1633  if (pInfo.options().hasEhFrameHdr()) {
1634    // emit eh_frame_hdr
1635    if (bitclass() == 32)
1636      m_pEhFrameHdr->emitOutput<32>(pLinker.getLDInfo().output(),
1637                                    pLinker);
1638  }
1639}
1640
1641/// getHashBucketCount - calculate hash bucket count.
1642/// @ref Google gold linker, dynobj.cc:791
1643unsigned GNULDBackend::getHashBucketCount(unsigned pNumOfSymbols,
1644                                          bool pIsGNUStyle)
1645{
1646  // @ref Google gold, dynobj.cc:loc 791
1647  static const unsigned int buckets[] =
1648  {
1649    1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
1650    16411, 32771, 65537, 131101, 262147
1651  };
1652  const unsigned buckets_count = sizeof buckets / sizeof buckets[0];
1653
1654  unsigned int result = 1;
1655  for (unsigned i = 0; i < buckets_count; ++i) {
1656    if (pNumOfSymbols < buckets[i])
1657      break;
1658    result = buckets[i];
1659  }
1660
1661  if (pIsGNUStyle && result < 2)
1662    result = 2;
1663
1664  return result;
1665}
1666
1667/// isDynamicSymbol
1668/// @ref Google gold linker: symtab.cc:311
1669bool GNULDBackend::isDynamicSymbol(const LDSymbol& pSymbol,
1670                                   const Output& pOutput)
1671{
1672  // If a local symbol is in the LDContext's symbol table, it's a real local
1673  // symbol. We should not add it
1674  if (pSymbol.binding() == ResolveInfo::Local)
1675    return false;
1676
1677  // If we are building shared object, and the visibility is external, we
1678  // need to add it.
1679  if (Output::DynObj == pOutput.type() || Output::Exec == pOutput.type())
1680    if (pSymbol.resolveInfo()->visibility() == ResolveInfo::Default ||
1681        pSymbol.resolveInfo()->visibility() == ResolveInfo::Protected)
1682      return true;
1683  return false;
1684}
1685
1686/// commonPageSize - the common page size of the target machine.
1687/// @ref gold linker: target.h:135
1688uint64_t GNULDBackend::commonPageSize(const MCLDInfo& pInfo) const
1689{
1690  if (pInfo.options().commPageSize() > 0)
1691    return std::min(pInfo.options().commPageSize(), abiPageSize(pInfo));
1692  else
1693    return std::min(static_cast<uint64_t>(0x1000), abiPageSize(pInfo));
1694}
1695
1696/// abiPageSize - the abi page size of the target machine.
1697/// @ref gold linker: target.h:125
1698uint64_t GNULDBackend::abiPageSize(const MCLDInfo& pInfo) const
1699{
1700  if (pInfo.options().maxPageSize() > 0)
1701    return pInfo.options().maxPageSize();
1702  else
1703    return static_cast<uint64_t>(0x1000);
1704}
1705
1706/// isOutputPIC - return whether the output is position-independent
1707bool GNULDBackend::isOutputPIC(const Output& pOutput,
1708                               const MCLDInfo& pInfo) const
1709{
1710  if (Output::DynObj == pOutput.type() || pInfo.options().isPIE())
1711    return true;
1712  return false;
1713}
1714
1715/// isStaticLink - return whether we're doing static link
1716bool GNULDBackend::isStaticLink(const Output& pOutput,
1717                                const MCLDInfo& pInfo) const
1718{
1719  InputTree::const_iterator it = pInfo.inputs().begin();
1720  if (!isOutputPIC(pOutput, pInfo) && (*it)->attribute()->isStatic())
1721    return true;
1722  return false;
1723}
1724
1725/// isSymbolPreemtible - whether the symbol can be preemted by other
1726/// link unit
1727/// @ref Google gold linker, symtab.h:551
1728bool GNULDBackend::isSymbolPreemptible(const ResolveInfo& pSym,
1729                                       const MCLDInfo& pLDInfo,
1730                                       const Output& pOutput) const
1731{
1732  if (pSym.other() != ResolveInfo::Default)
1733    return false;
1734
1735  if (Output::DynObj != pOutput.type())
1736    return false;
1737
1738  if (pLDInfo.options().Bsymbolic())
1739    return false;
1740
1741  return true;
1742}
1743
1744/// symbolNeedsPLT - return whether the symbol needs a PLT entry
1745/// @ref Google gold linker, symtab.h:596
1746bool GNULDBackend::symbolNeedsPLT(const ResolveInfo& pSym,
1747                                  const MCLDInfo& pLDInfo,
1748                                  const Output& pOutput) const
1749{
1750  if (pSym.isUndef() && !pSym.isDyn() && pOutput.type() != Output::DynObj)
1751    return false;
1752
1753  // An IndirectFunc symbol (i.e., STT_GNU_IFUNC) always needs a plt entry
1754  if (pSym.type() == ResolveInfo::IndirectFunc)
1755    return true;
1756
1757  if (pSym.type() != ResolveInfo::Function)
1758    return false;
1759
1760  if (isStaticLink(pOutput, pLDInfo) || pLDInfo.options().isPIE())
1761    return false;
1762
1763  return (pSym.isDyn() ||
1764          pSym.isUndef() ||
1765          isSymbolPreemptible(pSym, pLDInfo, pOutput));
1766}
1767
1768/// symbolNeedsDynRel - return whether the symbol needs a dynamic relocation
1769/// @ref Google gold linker, symtab.h:645
1770bool GNULDBackend::symbolNeedsDynRel(const ResolveInfo& pSym,
1771                                     bool pSymHasPLT,
1772                                     const MCLDInfo& pLDInfo,
1773                                     const Output& pOutput,
1774                                     bool isAbsReloc) const
1775{
1776  // an undefined reference in the executables should be statically
1777  // resolved to 0 and no need a dynamic relocation
1778  if (pSym.isUndef() && !pSym.isDyn() && (Output::Exec == pOutput.type()))
1779    return false;
1780  if (pSym.isAbsolute())
1781    return false;
1782  if (isOutputPIC(pOutput, pLDInfo) && isAbsReloc)
1783    return true;
1784  if (pSymHasPLT && ResolveInfo::Function == pSym.type())
1785    return false;
1786  if (!isOutputPIC(pOutput, pLDInfo) && pSymHasPLT)
1787    return false;
1788  if (pSym.isDyn() || pSym.isUndef() ||
1789      isSymbolPreemptible(pSym, pLDInfo, pOutput))
1790    return true;
1791
1792  return false;
1793}
1794
1795/// symbolNeedsCopyReloc - return whether the symbol needs a copy relocation
1796bool GNULDBackend::symbolNeedsCopyReloc(const Layout& pLayout,
1797                                        const Relocation& pReloc,
1798                                        const ResolveInfo& pSym,
1799                                        const MCLDInfo& pLDInfo,
1800                                        const Output& pOutput) const
1801{
1802  // only the reference from dynamic executable to non-function symbol in
1803  // the dynamic objects may need copy relocation
1804  if (isOutputPIC(pOutput, pLDInfo) ||
1805      !pSym.isDyn() ||
1806      pSym.type() == ResolveInfo::Function ||
1807      pSym.size() == 0)
1808    return false;
1809
1810  // check if the option -z nocopyreloc is given
1811  if (pLDInfo.options().hasNoCopyReloc())
1812    return false;
1813
1814  // TODO: Is this check necessary?
1815  // if relocation target place is readonly, a copy relocation is needed
1816  if ((pLayout.getOutputLDSection(*pReloc.targetRef().frag())->flag() &
1817      llvm::ELF::SHF_WRITE) == 0)
1818    return true;
1819
1820  return false;
1821}
1822
1823