contrib/llvm-project/lld/ELF/Target.cpp

   1 //===- Target.cpp ---------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Machine-specific things, such as applying relocations, creation of
  10 // GOT or PLT entries, etc., are handled in this file.
  11 //
  12 // Refer the ELF spec for the single letter variables, S, A or P, used
  13 // in this file.
  14 //
  15 // Some functions defined in this file has "relaxTls" as part of their names.
  16 // They do peephole optimization for TLS variables by rewriting instructions.
  17 // They are not part of the ABI but optional optimization, so you can skip
  18 // them if you are not interested in how TLS variables are optimized.
  19 // See the following paper for the details.
  20 //
  21 //   Ulrich Drepper, ELF Handling For Thread-Local Storage
  22 //   http://www.akkadia.org/drepper/tls.pdf
  23 //
  24 //===----------------------------------------------------------------------===//
  25
  26 #include "Target.h"
  27 #include "InputFiles.h"
  28 #include "OutputSections.h"
  29 #include "SymbolTable.h"
  30 #include "Symbols.h"
  31 #include "lld/Common/ErrorHandler.h"
  32 #include "llvm/Object/ELF.h"
  33
  34 using namespace llvm;
  35 using namespace llvm::object;
  36 using namespace llvm::ELF;
  37 using namespace lld;
  38 using namespace lld::elf;
  39
  40 const TargetInfo *elf::target;
  41
  42 std::string lld::toString(RelType type) {
  43   StringRef s = getELFRelocationTypeName(elf::config->emachine, type);
  44   if (s == "Unknown")
  45     return ("Unknown (" + Twine(type) + ")").str();
  46   return s;
  47 }
  48
  49 TargetInfo *elf::getTarget() {
  50   switch (config->emachine) {
  51   case EM_386:
  52   case EM_IAMCU:
  53     return getX86TargetInfo();
  54   case EM_AARCH64:
  55     return getAArch64TargetInfo();
  56   case EM_AMDGPU:
  57     return getAMDGPUTargetInfo();
  58   case EM_ARM:
  59     return getARMTargetInfo();
  60   case EM_AVR:
  61     return getAVRTargetInfo();
  62   case EM_HEXAGON:
  63     return getHexagonTargetInfo();
  64   case EM_MIPS:
  65     switch (config->ekind) {
  66     case ELF32LEKind:
  67       return getMipsTargetInfo<ELF32LE>();
  68     case ELF32BEKind:
  69       return getMipsTargetInfo<ELF32BE>();
  70     case ELF64LEKind:
  71       return getMipsTargetInfo<ELF64LE>();
  72     case ELF64BEKind:
  73       return getMipsTargetInfo<ELF64BE>();
  74     default:
  75       llvm_unreachable("unsupported MIPS target");
  76     }
  77   case EM_MSP430:
  78     return getMSP430TargetInfo();
  79   case EM_PPC:
  80     return getPPCTargetInfo();
  81   case EM_PPC64:
  82     return getPPC64TargetInfo();
  83   case EM_RISCV:
  84     return getRISCVTargetInfo();
  85   case EM_SPARCV9:
  86     return getSPARCV9TargetInfo();
  87   case EM_X86_64:
  88     return getX86_64TargetInfo();
  89   }
  90   llvm_unreachable("unknown target machine");
  91 }
  92
  93 template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *loc) {
  94   for (InputSectionBase *d : inputSections) {
  95     auto *isec = cast<InputSection>(d);
  96     if (!isec->getParent())
  97       continue;
  98
  99     uint8_t *isecLoc = Out::bufferStart + isec->getParent()->offset + isec->outSecOff;
 100     if (isecLoc <= loc && loc < isecLoc + isec->getSize())
 101       return {isec, isec->template getLocation<ELFT>(loc - isecLoc) + ": "};
 102   }
 103   return {};
 104 }
 105
 106 ErrorPlace elf::getErrorPlace(const uint8_t *loc) {
 107   switch (config->ekind) {
 108   case ELF32LEKind:
 109     return getErrPlace<ELF32LE>(loc);
 110   case ELF32BEKind:
 111     return getErrPlace<ELF32BE>(loc);
 112   case ELF64LEKind:
 113     return getErrPlace<ELF64LE>(loc);
 114   case ELF64BEKind:
 115     return getErrPlace<ELF64BE>(loc);
 116   default:
 117     llvm_unreachable("unknown ELF type");
 118   }
 119 }
 120
 121 TargetInfo::~TargetInfo() {}
 122
 123 int64_t TargetInfo::getImplicitAddend(const uint8_t *buf, RelType type) const {
 124   return 0;
 125 }
 126
 127 bool TargetInfo::usesOnlyLowPageBits(RelType type) const { return false; }
 128
 129 bool TargetInfo::needsThunk(RelExpr expr, RelType type, const InputFile *file,
 130                             uint64_t branchAddr, const Symbol &s) const {
 131   return false;
 132 }
 133
 134 bool TargetInfo::adjustPrologueForCrossSplitStack(uint8_t *loc, uint8_t *end,
 135                                                   uint8_t stOther) const {
 136   llvm_unreachable("Target doesn't support split stacks.");
 137 }
 138
 139 bool TargetInfo::inBranchRange(RelType type, uint64_t src, uint64_t dst) const {
 140   return true;
 141 }
 142
 143 void TargetInfo::writeIgotPlt(uint8_t *buf, const Symbol &s) const {
 144   writeGotPlt(buf, s);
 145 }
 146
 147 RelExpr TargetInfo::adjustRelaxExpr(RelType type, const uint8_t *data,
 148                                     RelExpr expr) const {
 149   return expr;
 150 }
 151
 152 void TargetInfo::relaxGot(uint8_t *loc, RelType type, uint64_t val) const {
 153   llvm_unreachable("Should not have claimed to be relaxable");
 154 }
 155
 156 void TargetInfo::relaxTlsGdToLe(uint8_t *loc, RelType type,
 157                                 uint64_t val) const {
 158   llvm_unreachable("Should not have claimed to be relaxable");
 159 }
 160
 161 void TargetInfo::relaxTlsGdToIe(uint8_t *loc, RelType type,
 162                                 uint64_t val) const {
 163   llvm_unreachable("Should not have claimed to be relaxable");
 164 }
 165
 166 void TargetInfo::relaxTlsIeToLe(uint8_t *loc, RelType type,
 167                                 uint64_t val) const {
 168   llvm_unreachable("Should not have claimed to be relaxable");
 169 }
 170
 171 void TargetInfo::relaxTlsLdToLe(uint8_t *loc, RelType type,
 172                                 uint64_t val) const {
 173   llvm_unreachable("Should not have claimed to be relaxable");
 174 }
 175
 176 uint64_t TargetInfo::getImageBase() const {
 177   // Use -image-base if set. Fall back to the target default if not.
 178   if (config->imageBase)
 179     return *config->imageBase;
 180   return config->isPic ? 0 : defaultImageBase;
 181 }