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