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 "Error.h"
  29 #include "InputFiles.h"
  30 #include "OutputSections.h"
  31 #include "SymbolTable.h"
  32 #include "Symbols.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(uint32_t 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::createTarget() {
  51   switch (Config->EMachine) {
  52   case EM_386:
  53   case EM_IAMCU:
  54     return createX86TargetInfo();
  55   case EM_AARCH64:
  56     return createAArch64TargetInfo();
  57   case EM_AMDGPU:
  58     return createAMDGPUTargetInfo();
  59   case EM_ARM:
  60     return createARMTargetInfo();
  61   case EM_AVR:
  62     return createAVRTargetInfo();
  63   case EM_MIPS:
  64     switch (Config->EKind) {
  65     case ELF32LEKind:
  66       return createMipsTargetInfo<ELF32LE>();
  67     case ELF32BEKind:
  68       return createMipsTargetInfo<ELF32BE>();
  69     case ELF64LEKind:
  70       return createMipsTargetInfo<ELF64LE>();
  71     case ELF64BEKind:
  72       return createMipsTargetInfo<ELF64BE>();
  73     default:
  74       fatal("unsupported MIPS target");
  75     }
  76   case EM_PPC:
  77     return createPPCTargetInfo();
  78   case EM_PPC64:
  79     return createPPC64TargetInfo();
  80   case EM_X86_64:
  81     if (Config->EKind == ELF32LEKind)
  82       return createX32TargetInfo();
  83     return createX86_64TargetInfo();
  84   }
  85   fatal("unknown target machine");
  86 }
  87
  88 template <class ELFT> static std::string getErrorLoc(const uint8_t *Loc) {
  89   for (InputSectionBase *D : InputSections) {
  90     auto *IS = dyn_cast_or_null<InputSection>(D);
  91     if (!IS || !IS->getParent())
  92       continue;
  93
  94     uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
  95     if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
  96       return IS->template getLocation<ELFT>(Loc - ISLoc) + ": ";
  97   }
  98   return "";
  99 }
 100
 101 std::string elf::getErrorLocation(const uint8_t *Loc) {
 102   switch (Config->EKind) {
 103   case ELF32LEKind:
 104     return getErrorLoc<ELF32LE>(Loc);
 105   case ELF32BEKind:
 106     return getErrorLoc<ELF32BE>(Loc);
 107   case ELF64LEKind:
 108     return getErrorLoc<ELF64LE>(Loc);
 109   case ELF64BEKind:
 110     return getErrorLoc<ELF64BE>(Loc);
 111   default:
 112     llvm_unreachable("unknown ELF type");
 113   }
 114 }
 115
 116 TargetInfo::~TargetInfo() {}
 117
 118 int64_t TargetInfo::getImplicitAddend(const uint8_t *Buf, uint32_t Type) const {
 119   return 0;
 120 }
 121
 122 bool TargetInfo::usesOnlyLowPageBits(uint32_t Type) const { return false; }
 123
 124 bool TargetInfo::needsThunk(RelExpr Expr, uint32_t RelocType,
 125                             const InputFile *File, const SymbolBody &S) const {
 126   return false;
 127 }
 128
 129 void TargetInfo::writeIgotPlt(uint8_t *Buf, const SymbolBody &S) const {
 130   writeGotPlt(Buf, S);
 131 }
 132
 133 RelExpr TargetInfo::adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
 134                                     RelExpr Expr) const {
 135   return Expr;
 136 }
 137
 138 void TargetInfo::relaxGot(uint8_t *Loc, uint64_t Val) const {
 139   llvm_unreachable("Should not have claimed to be relaxable");
 140 }
 141
 142 void TargetInfo::relaxTlsGdToLe(uint8_t *Loc, uint32_t Type,
 143                                 uint64_t Val) const {
 144   llvm_unreachable("Should not have claimed to be relaxable");
 145 }
 146
 147 void TargetInfo::relaxTlsGdToIe(uint8_t *Loc, uint32_t Type,
 148                                 uint64_t Val) const {
 149   llvm_unreachable("Should not have claimed to be relaxable");
 150 }
 151
 152 void TargetInfo::relaxTlsIeToLe(uint8_t *Loc, uint32_t Type,
 153                                 uint64_t Val) const {
 154   llvm_unreachable("Should not have claimed to be relaxable");
 155 }
 156
 157 void TargetInfo::relaxTlsLdToLe(uint8_t *Loc, uint32_t Type,
 158                                 uint64_t Val) const {
 159   llvm_unreachable("Should not have claimed to be relaxable");
 160 }