1 //===-- Hexagon.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 #include "InputFiles.h"
11 #include "Symbols.h"
12 #include "SyntheticSections.h"
13 #include "Target.h"
14 #include "lld/Common/ErrorHandler.h"
15 #include "llvm/BinaryFormat/ELF.h"
16 #include "llvm/Object/ELF.h"
17 #include "llvm/Support/Endian.h"
18
19 using namespace llvm;
20 using namespace llvm::object;
21 using namespace llvm::support::endian;
22 using namespace llvm::ELF;
23 using namespace lld;
24 using namespace lld::elf;
25
26 namespace {
27 class Hexagon final : public TargetInfo {
28 public:
29 Hexagon();
30 uint32_t calcEFlags() const override;
31 RelExpr getRelExpr(RelType Type, const Symbol &S,
32 const uint8_t *Loc) const override;
33 void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
34 void writePltHeader(uint8_t *Buf) const override;
35 void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
36 int32_t Index, unsigned RelOff) const override;
37 };
38 } // namespace
39
Hexagon()40 Hexagon::Hexagon() {
41 PltRel = R_HEX_JMP_SLOT;
42 RelativeRel = R_HEX_RELATIVE;
43 GotRel = R_HEX_GLOB_DAT;
44 GotEntrySize = 4;
45 // The zero'th GOT entry is reserved for the address of _DYNAMIC. The
46 // next 3 are reserved for the dynamic loader.
47 GotPltHeaderEntriesNum = 4;
48 GotPltEntrySize = 4;
49
50 PltEntrySize = 16;
51 PltHeaderSize = 32;
52
53 // Hexagon Linux uses 64K pages by default.
54 DefaultMaxPageSize = 0x10000;
55 NoneRel = R_HEX_NONE;
56 }
57
calcEFlags() const58 uint32_t Hexagon::calcEFlags() const {
59 assert(!ObjectFiles.empty());
60
61 // The architecture revision must always be equal to or greater than
62 // greatest revision in the list of inputs.
63 uint32_t Ret = 0;
64 for (InputFile *F : ObjectFiles) {
65 uint32_t EFlags = cast<ObjFile<ELF32LE>>(F)->getObj().getHeader()->e_flags;
66 if (EFlags > Ret)
67 Ret = EFlags;
68 }
69 return Ret;
70 }
71
applyMask(uint32_t Mask,uint32_t Data)72 static uint32_t applyMask(uint32_t Mask, uint32_t Data) {
73 uint32_t Result = 0;
74 size_t Off = 0;
75
76 for (size_t Bit = 0; Bit != 32; ++Bit) {
77 uint32_t ValBit = (Data >> Off) & 1;
78 uint32_t MaskBit = (Mask >> Bit) & 1;
79 if (MaskBit) {
80 Result |= (ValBit << Bit);
81 ++Off;
82 }
83 }
84 return Result;
85 }
86
getRelExpr(RelType Type,const Symbol & S,const uint8_t * Loc) const87 RelExpr Hexagon::getRelExpr(RelType Type, const Symbol &S,
88 const uint8_t *Loc) const {
89 switch (Type) {
90 case R_HEX_B9_PCREL:
91 case R_HEX_B9_PCREL_X:
92 case R_HEX_B13_PCREL:
93 case R_HEX_B15_PCREL:
94 case R_HEX_B15_PCREL_X:
95 case R_HEX_6_PCREL_X:
96 case R_HEX_32_PCREL:
97 return R_PC;
98 case R_HEX_B22_PCREL:
99 case R_HEX_PLT_B22_PCREL:
100 case R_HEX_B22_PCREL_X:
101 case R_HEX_B32_PCREL_X:
102 return R_PLT_PC;
103 case R_HEX_GOT_11_X:
104 case R_HEX_GOT_16_X:
105 case R_HEX_GOT_32_6_X:
106 return R_HEXAGON_GOT;
107 default:
108 return R_ABS;
109 }
110 }
111
findMaskR6(uint32_t Insn)112 static uint32_t findMaskR6(uint32_t Insn) {
113 // There are (arguably too) many relocation masks for the DSP's
114 // R_HEX_6_X type. The table below is used to select the correct mask
115 // for the given instruction.
116 struct InstructionMask {
117 uint32_t CmpMask;
118 uint32_t RelocMask;
119 };
120
121 static const InstructionMask R6[] = {
122 {0x38000000, 0x0000201f}, {0x39000000, 0x0000201f},
123 {0x3e000000, 0x00001f80}, {0x3f000000, 0x00001f80},
124 {0x40000000, 0x000020f8}, {0x41000000, 0x000007e0},
125 {0x42000000, 0x000020f8}, {0x43000000, 0x000007e0},
126 {0x44000000, 0x000020f8}, {0x45000000, 0x000007e0},
127 {0x46000000, 0x000020f8}, {0x47000000, 0x000007e0},
128 {0x6a000000, 0x00001f80}, {0x7c000000, 0x001f2000},
129 {0x9a000000, 0x00000f60}, {0x9b000000, 0x00000f60},
130 {0x9c000000, 0x00000f60}, {0x9d000000, 0x00000f60},
131 {0x9f000000, 0x001f0100}, {0xab000000, 0x0000003f},
132 {0xad000000, 0x0000003f}, {0xaf000000, 0x00030078},
133 {0xd7000000, 0x006020e0}, {0xd8000000, 0x006020e0},
134 {0xdb000000, 0x006020e0}, {0xdf000000, 0x006020e0}};
135
136 // Duplex forms have a fixed mask and parse bits 15:14 are always
137 // zero. Non-duplex insns will always have at least one bit set in the
138 // parse field.
139 if ((0xC000 & Insn) == 0x0)
140 return 0x03f00000;
141
142 for (InstructionMask I : R6)
143 if ((0xff000000 & Insn) == I.CmpMask)
144 return I.RelocMask;
145
146 error("unrecognized instruction for R_HEX_6 relocation: 0x" +
147 utohexstr(Insn));
148 return 0;
149 }
150
findMaskR8(uint32_t Insn)151 static uint32_t findMaskR8(uint32_t Insn) {
152 if ((0xff000000 & Insn) == 0xde000000)
153 return 0x00e020e8;
154 if ((0xff000000 & Insn) == 0x3c000000)
155 return 0x0000207f;
156 return 0x00001fe0;
157 }
158
findMaskR11(uint32_t Insn)159 static uint32_t findMaskR11(uint32_t Insn) {
160 if ((0xff000000 & Insn) == 0xa1000000)
161 return 0x060020ff;
162 return 0x06003fe0;
163 }
164
findMaskR16(uint32_t Insn)165 static uint32_t findMaskR16(uint32_t Insn) {
166 if ((0xff000000 & Insn) == 0x48000000)
167 return 0x061f20ff;
168 if ((0xff000000 & Insn) == 0x49000000)
169 return 0x061f3fe0;
170 if ((0xff000000 & Insn) == 0x78000000)
171 return 0x00df3fe0;
172 if ((0xff000000 & Insn) == 0xb0000000)
173 return 0x0fe03fe0;
174
175 error("unrecognized instruction for R_HEX_16_X relocation: 0x" +
176 utohexstr(Insn));
177 return 0;
178 }
179
or32le(uint8_t * P,int32_t V)180 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
181
relocateOne(uint8_t * Loc,RelType Type,uint64_t Val) const182 void Hexagon::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
183 switch (Type) {
184 case R_HEX_NONE:
185 break;
186 case R_HEX_6_PCREL_X:
187 case R_HEX_6_X:
188 or32le(Loc, applyMask(findMaskR6(read32le(Loc)), Val));
189 break;
190 case R_HEX_8_X:
191 or32le(Loc, applyMask(findMaskR8(read32le(Loc)), Val));
192 break;
193 case R_HEX_9_X:
194 or32le(Loc, applyMask(0x00003fe0, Val & 0x3f));
195 break;
196 case R_HEX_10_X:
197 or32le(Loc, applyMask(0x00203fe0, Val & 0x3f));
198 break;
199 case R_HEX_11_X:
200 case R_HEX_GOT_11_X:
201 or32le(Loc, applyMask(findMaskR11(read32le(Loc)), Val & 0x3f));
202 break;
203 case R_HEX_12_X:
204 or32le(Loc, applyMask(0x000007e0, Val));
205 break;
206 case R_HEX_16_X: // These relocs only have 6 effective bits.
207 case R_HEX_GOT_16_X:
208 or32le(Loc, applyMask(findMaskR16(read32le(Loc)), Val & 0x3f));
209 break;
210 case R_HEX_32:
211 case R_HEX_32_PCREL:
212 or32le(Loc, Val);
213 break;
214 case R_HEX_32_6_X:
215 case R_HEX_GOT_32_6_X:
216 or32le(Loc, applyMask(0x0fff3fff, Val >> 6));
217 break;
218 case R_HEX_B9_PCREL:
219 or32le(Loc, applyMask(0x003000fe, Val >> 2));
220 break;
221 case R_HEX_B9_PCREL_X:
222 or32le(Loc, applyMask(0x003000fe, Val & 0x3f));
223 break;
224 case R_HEX_B13_PCREL:
225 or32le(Loc, applyMask(0x00202ffe, Val >> 2));
226 break;
227 case R_HEX_B15_PCREL:
228 or32le(Loc, applyMask(0x00df20fe, Val >> 2));
229 break;
230 case R_HEX_B15_PCREL_X:
231 or32le(Loc, applyMask(0x00df20fe, Val & 0x3f));
232 break;
233 case R_HEX_B22_PCREL:
234 case R_HEX_PLT_B22_PCREL:
235 or32le(Loc, applyMask(0x1ff3ffe, Val >> 2));
236 break;
237 case R_HEX_B22_PCREL_X:
238 or32le(Loc, applyMask(0x1ff3ffe, Val & 0x3f));
239 break;
240 case R_HEX_B32_PCREL_X:
241 or32le(Loc, applyMask(0x0fff3fff, Val >> 6));
242 break;
243 case R_HEX_HI16:
244 or32le(Loc, applyMask(0x00c03fff, Val >> 16));
245 break;
246 case R_HEX_LO16:
247 or32le(Loc, applyMask(0x00c03fff, Val));
248 break;
249 default:
250 error(getErrorLocation(Loc) + "unrecognized reloc " + toString(Type));
251 break;
252 }
253 }
254
writePltHeader(uint8_t * Buf) const255 void Hexagon::writePltHeader(uint8_t *Buf) const {
256 const uint8_t PltData[] = {
257 0x00, 0x40, 0x00, 0x00, // { immext (#0)
258 0x1c, 0xc0, 0x49, 0x6a, // r28 = add (pc, ##GOT0@PCREL) } # @GOT0
259 0x0e, 0x42, 0x9c, 0xe2, // { r14 -= add (r28, #16) # offset of GOTn
260 0x4f, 0x40, 0x9c, 0x91, // r15 = memw (r28 + #8) # object ID at GOT2
261 0x3c, 0xc0, 0x9c, 0x91, // r28 = memw (r28 + #4) }# dynamic link at GOT1
262 0x0e, 0x42, 0x0e, 0x8c, // { r14 = asr (r14, #2) # index of PLTn
263 0x00, 0xc0, 0x9c, 0x52, // jumpr r28 } # call dynamic linker
264 0x0c, 0xdb, 0x00, 0x54, // trap0(#0xdb) # bring plt0 into 16byte alignment
265 };
266 memcpy(Buf, PltData, sizeof(PltData));
267
268 // Offset from PLT0 to the GOT.
269 uint64_t Off = In.GotPlt->getVA() - In.Plt->getVA();
270 relocateOne(Buf, R_HEX_B32_PCREL_X, Off);
271 relocateOne(Buf + 4, R_HEX_6_PCREL_X, Off);
272 }
273
writePlt(uint8_t * Buf,uint64_t GotPltEntryAddr,uint64_t PltEntryAddr,int32_t Index,unsigned RelOff) const274 void Hexagon::writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr,
275 uint64_t PltEntryAddr, int32_t Index,
276 unsigned RelOff) const {
277 const uint8_t Inst[] = {
278 0x00, 0x40, 0x00, 0x00, // { immext (#0)
279 0x0e, 0xc0, 0x49, 0x6a, // r14 = add (pc, ##GOTn@PCREL) }
280 0x1c, 0xc0, 0x8e, 0x91, // r28 = memw (r14)
281 0x00, 0xc0, 0x9c, 0x52, // jumpr r28
282 };
283 memcpy(Buf, Inst, sizeof(Inst));
284
285 relocateOne(Buf, R_HEX_B32_PCREL_X, GotPltEntryAddr - PltEntryAddr);
286 relocateOne(Buf + 4, R_HEX_6_PCREL_X, GotPltEntryAddr - PltEntryAddr);
287 }
288
getHexagonTargetInfo()289 TargetInfo *elf::getHexagonTargetInfo() {
290 static Hexagon Target;
291 return &Target;
292 }
293