contrib/llvm/tools/lld/ELF/Target.cpp

   1 //===- Target.cpp ---------------------------------------------------------===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Machine-specific things, such as applying relocations, creation of
  11 // GOT or PLT entries, etc., are handled in this file.
  12 //
  13 // Refer the ELF spec for the single letter variables, S, A or P, used
  14 // in this file.
  15 //
  16 // Some functions defined in this file has "relaxTls" as part of their names.
  17 // They do peephole optimization for TLS variables by rewriting instructions.
  18 // They are not part of the ABI but optional optimization, so you can skip
  19 // them if you are not interested in how TLS variables are optimized.
  20 // See the following paper for the details.
  21 //
  22 //   Ulrich Drepper, ELF Handling For Thread-Local Storage
  23 //   http://www.akkadia.org/drepper/tls.pdf
  24 //
  25 //===----------------------------------------------------------------------===//
  26
  27 #include "Target.h"
  28 #include "InputFiles.h"
  29 #include "OutputSections.h"
  30 #include "SymbolTable.h"
  31 #include "Symbols.h"
  32 #include "lld/Common/ErrorHandler.h"
  33 #include "llvm/Object/ELF.h"
  34
  35 using namespace llvm;
  36 using namespace llvm::object;
  37 using namespace llvm::ELF;
  38 using namespace lld;
  39 using namespace lld::elf;
  40
  41 TargetInfo *elf::Target;
  42
  43 std::string lld::toString(RelType Type) {
  44   StringRef S = getELFRelocationTypeName(elf::Config->EMachine, Type);
  45   if (S == "Unknown")
  46     return ("Unknown (" + Twine(Type) + ")").str();
  47   return S;
  48 }
  49
  50 TargetInfo *elf::getTarget() {
  51   switch (Config->EMachine) {
  52   case EM_386:
  53   case EM_IAMCU:
  54     return getX86TargetInfo();
  55   case EM_AARCH64:
  56     return getAArch64TargetInfo();
  57   case EM_AMDGPU:
  58     return getAMDGPUTargetInfo();
  59   case EM_ARM:
  60     return getARMTargetInfo();
  61   case EM_AVR:
  62     return getAVRTargetInfo();
  63   case EM_HEXAGON:
  64     return getHexagonTargetInfo();
  65   case EM_MIPS:
  66     switch (Config->EKind) {
  67     case ELF32LEKind:
  68       return getMipsTargetInfo<ELF32LE>();
  69     case ELF32BEKind:
  70       return getMipsTargetInfo<ELF32BE>();
  71     case ELF64LEKind:
  72       return getMipsTargetInfo<ELF64LE>();
  73     case ELF64BEKind:
  74       return getMipsTargetInfo<ELF64BE>();
  75     default:
  76       fatal("unsupported MIPS target");
  77     }
  78   case EM_PPC:
  79     return getPPCTargetInfo();
  80   case EM_PPC64:
  81     return getPPC64TargetInfo();
  82   case EM_SPARCV9:
  83     return getSPARCV9TargetInfo();
  84   case EM_X86_64:
  85     if (Config->EKind == ELF32LEKind)
  86       return getX32TargetInfo();
  87     return getX86_64TargetInfo();
  88   }
  89   fatal("unknown target machine");
  90 }
  91
  92 template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *Loc) {
  93   for (InputSectionBase *D : InputSections) {
  94     auto *IS = cast<InputSection>(D);
  95     if (!IS->getParent())
  96       continue;
  97
  98     uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
  99     if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
 100       return {IS, IS->template getLocation<ELFT>(Loc - ISLoc) + ": "};
 101   }
 102   return {};
 103 }
 104
 105 ErrorPlace elf::getErrorPlace(const uint8_t *Loc) {
 106   switch (Config->EKind) {
 107   case ELF32LEKind:
 108     return getErrPlace<ELF32LE>(Loc);
 109   case ELF32BEKind:
 110     return getErrPlace<ELF32BE>(Loc);
 111   case ELF64LEKind:
 112     return getErrPlace<ELF64LE>(Loc);
 113   case ELF64BEKind:
 114     return getErrPlace<ELF64BE>(Loc);
 115   default:
 116     llvm_unreachable("unknown ELF type");
 117   }
 118 }
 119
 120 TargetInfo::~TargetInfo() {}
 121
 122 int64_t TargetInfo::getImplicitAddend(const uint8_t *Buf, RelType Type) const {
 123   return 0;
 124 }
 125
 126 bool TargetInfo::usesOnlyLowPageBits(RelType Type) const { return false; }
 127
 128 bool TargetInfo::needsThunk(RelExpr Expr, RelType Type, const InputFile *File,
 129                             uint64_t BranchAddr, const Symbol &S) const {
 130   return false;
 131 }
 132
 133 bool TargetInfo::adjustPrologueForCrossSplitStack(uint8_t *Loc,
 134                                                   uint8_t *End) const {
 135   llvm_unreachable("Target doesn't support split stacks.");
 136 }
 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, 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() {
 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->Pic ? 0 : DefaultImageBase;
 181 }