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