xref: /freebsd/contrib/llvm-project/lld/ELF/Target.cpp (revision ec0ea6efa1ad229d75c394c1a9b9cac33af2b1d3)
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 "SyntheticSections.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 const 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 std::string(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       llvm_unreachable("unsupported MIPS target");
77     }
78   case EM_MSP430:
79     return getMSP430TargetInfo();
80   case EM_PPC:
81     return getPPCTargetInfo();
82   case EM_PPC64:
83     return getPPC64TargetInfo();
84   case EM_RISCV:
85     return getRISCVTargetInfo();
86   case EM_SPARCV9:
87     return getSPARCV9TargetInfo();
88   case EM_X86_64:
89     return getX86_64TargetInfo();
90   }
91   llvm_unreachable("unknown target machine");
92 }
93 
94 template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *loc) {
95   assert(loc != nullptr);
96   for (InputSectionBase *d : inputSections) {
97     auto *isec = cast<InputSection>(d);
98     if (!isec->getParent() || (isec->type & SHT_NOBITS))
99       continue;
100 
101     const uint8_t *isecLoc =
102         Out::bufferStart
103             ? (Out::bufferStart + isec->getParent()->offset + isec->outSecOff)
104             : isec->data().data();
105     if (isecLoc == nullptr) {
106       assert(isa<SyntheticSection>(isec) && "No data but not synthetic?");
107       continue;
108     }
109     if (isecLoc <= loc && loc < isecLoc + isec->getSize())
110       return {isec, isec->template getLocation<ELFT>(loc - isecLoc) + ": "};
111   }
112   return {};
113 }
114 
115 ErrorPlace elf::getErrorPlace(const uint8_t *loc) {
116   switch (config->ekind) {
117   case ELF32LEKind:
118     return getErrPlace<ELF32LE>(loc);
119   case ELF32BEKind:
120     return getErrPlace<ELF32BE>(loc);
121   case ELF64LEKind:
122     return getErrPlace<ELF64LE>(loc);
123   case ELF64BEKind:
124     return getErrPlace<ELF64BE>(loc);
125   default:
126     llvm_unreachable("unknown ELF type");
127   }
128 }
129 
130 TargetInfo::~TargetInfo() {}
131 
132 int64_t TargetInfo::getImplicitAddend(const uint8_t *buf, RelType type) const {
133   internalLinkerError(getErrorLocation(buf),
134                       "cannot read addend for relocation " + toString(type));
135   return 0;
136 }
137 
138 bool TargetInfo::usesOnlyLowPageBits(RelType type) const { return false; }
139 
140 bool TargetInfo::needsThunk(RelExpr expr, RelType type, const InputFile *file,
141                             uint64_t branchAddr, const Symbol &s,
142                             int64_t a) const {
143   return false;
144 }
145 
146 bool TargetInfo::adjustPrologueForCrossSplitStack(uint8_t *loc, uint8_t *end,
147                                                   uint8_t stOther) const {
148   llvm_unreachable("Target doesn't support split stacks.");
149 }
150 
151 bool TargetInfo::inBranchRange(RelType type, uint64_t src, uint64_t dst) const {
152   return true;
153 }
154 
155 RelExpr TargetInfo::adjustTlsExpr(RelType type, RelExpr expr) const {
156   return expr;
157 }
158 
159 RelExpr TargetInfo::adjustGotPcExpr(RelType type, int64_t addend,
160                                     const uint8_t *data) const {
161   return R_GOT_PC;
162 }
163 
164 void TargetInfo::relaxGot(uint8_t *loc, const Relocation &rel,
165                           uint64_t val) const {
166   llvm_unreachable("Should not have claimed to be relaxable");
167 }
168 
169 void TargetInfo::relaxTlsGdToLe(uint8_t *loc, const Relocation &rel,
170                                 uint64_t val) const {
171   llvm_unreachable("Should not have claimed to be relaxable");
172 }
173 
174 void TargetInfo::relaxTlsGdToIe(uint8_t *loc, const Relocation &rel,
175                                 uint64_t val) const {
176   llvm_unreachable("Should not have claimed to be relaxable");
177 }
178 
179 void TargetInfo::relaxTlsIeToLe(uint8_t *loc, const Relocation &rel,
180                                 uint64_t val) const {
181   llvm_unreachable("Should not have claimed to be relaxable");
182 }
183 
184 void TargetInfo::relaxTlsLdToLe(uint8_t *loc, const Relocation &rel,
185                                 uint64_t val) const {
186   llvm_unreachable("Should not have claimed to be relaxable");
187 }
188 
189 uint64_t TargetInfo::getImageBase() const {
190   // Use -image-base if set. Fall back to the target default if not.
191   if (config->imageBase)
192     return *config->imageBase;
193   return config->isPic ? 0 : defaultImageBase;
194 }
195