1 //===------- ELF_riscv.cpp -JIT linker implementation for ELF/riscv -------===// 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 // ELF/riscv jit-link implementation. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/ExecutionEngine/JITLink/ELF_riscv.h" 14 #include "ELFLinkGraphBuilder.h" 15 #include "JITLinkGeneric.h" 16 #include "PerGraphGOTAndPLTStubsBuilder.h" 17 #include "llvm/BinaryFormat/ELF.h" 18 #include "llvm/ExecutionEngine/JITLink/JITLink.h" 19 #include "llvm/ExecutionEngine/JITLink/riscv.h" 20 #include "llvm/Object/ELF.h" 21 #include "llvm/Object/ELFObjectFile.h" 22 #include "llvm/Support/Endian.h" 23 24 #define DEBUG_TYPE "jitlink" 25 using namespace llvm; 26 using namespace llvm::jitlink; 27 using namespace llvm::jitlink::riscv; 28 29 namespace { 30 31 class PerGraphGOTAndPLTStubsBuilder_ELF_riscv 32 : public PerGraphGOTAndPLTStubsBuilder< 33 PerGraphGOTAndPLTStubsBuilder_ELF_riscv> { 34 public: 35 static constexpr size_t StubEntrySize = 16; 36 static const uint8_t NullGOTEntryContent[8]; 37 static const uint8_t RV64StubContent[StubEntrySize]; 38 static const uint8_t RV32StubContent[StubEntrySize]; 39 40 using PerGraphGOTAndPLTStubsBuilder< 41 PerGraphGOTAndPLTStubsBuilder_ELF_riscv>::PerGraphGOTAndPLTStubsBuilder; 42 43 bool isRV64() const { return G.getPointerSize() == 8; } 44 45 bool isGOTEdgeToFix(Edge &E) const { return E.getKind() == R_RISCV_GOT_HI20; } 46 47 Symbol &createGOTEntry(Symbol &Target) { 48 Block &GOTBlock = 49 G.createContentBlock(getGOTSection(), getGOTEntryBlockContent(), 50 orc::ExecutorAddr(), G.getPointerSize(), 0); 51 GOTBlock.addEdge(isRV64() ? R_RISCV_64 : R_RISCV_32, 0, Target, 0); 52 return G.addAnonymousSymbol(GOTBlock, 0, G.getPointerSize(), false, false); 53 } 54 55 Symbol &createPLTStub(Symbol &Target) { 56 Block &StubContentBlock = G.createContentBlock( 57 getStubsSection(), getStubBlockContent(), orc::ExecutorAddr(), 4, 0); 58 auto &GOTEntrySymbol = getGOTEntry(Target); 59 StubContentBlock.addEdge(R_RISCV_CALL, 0, GOTEntrySymbol, 0); 60 return G.addAnonymousSymbol(StubContentBlock, 0, StubEntrySize, true, 61 false); 62 } 63 64 void fixGOTEdge(Edge &E, Symbol &GOTEntry) { 65 // Replace the relocation pair (R_RISCV_GOT_HI20, R_RISCV_PCREL_LO12) 66 // with (R_RISCV_PCREL_HI20, R_RISCV_PCREL_LO12) 67 // Therefore, here just change the R_RISCV_GOT_HI20 to R_RISCV_PCREL_HI20 68 E.setKind(R_RISCV_PCREL_HI20); 69 E.setTarget(GOTEntry); 70 } 71 72 void fixPLTEdge(Edge &E, Symbol &PLTStubs) { 73 assert(E.getKind() == R_RISCV_CALL_PLT && "Not a R_RISCV_CALL_PLT edge?"); 74 E.setKind(R_RISCV_CALL); 75 E.setTarget(PLTStubs); 76 } 77 78 bool isExternalBranchEdge(Edge &E) const { 79 return (E.getKind() == R_RISCV_CALL || E.getKind() == R_RISCV_CALL_PLT) && 80 !E.getTarget().isDefined(); 81 } 82 83 private: 84 Section &getGOTSection() const { 85 if (!GOTSection) 86 GOTSection = &G.createSection("$__GOT", orc::MemProt::Read); 87 return *GOTSection; 88 } 89 90 Section &getStubsSection() const { 91 if (!StubsSection) 92 StubsSection = 93 &G.createSection("$__STUBS", orc::MemProt::Read | orc::MemProt::Exec); 94 return *StubsSection; 95 } 96 97 ArrayRef<char> getGOTEntryBlockContent() { 98 return {reinterpret_cast<const char *>(NullGOTEntryContent), 99 G.getPointerSize()}; 100 } 101 102 ArrayRef<char> getStubBlockContent() { 103 auto StubContent = isRV64() ? RV64StubContent : RV32StubContent; 104 return {reinterpret_cast<const char *>(StubContent), StubEntrySize}; 105 } 106 107 mutable Section *GOTSection = nullptr; 108 mutable Section *StubsSection = nullptr; 109 }; 110 111 const uint8_t PerGraphGOTAndPLTStubsBuilder_ELF_riscv::NullGOTEntryContent[8] = 112 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; 113 114 const uint8_t 115 PerGraphGOTAndPLTStubsBuilder_ELF_riscv::RV64StubContent[StubEntrySize] = { 116 0x17, 0x0e, 0x00, 0x00, // auipc t3, literal 117 0x03, 0x3e, 0x0e, 0x00, // ld t3, literal(t3) 118 0x67, 0x00, 0x0e, 0x00, // jr t3 119 0x13, 0x00, 0x00, 0x00}; // nop 120 121 const uint8_t 122 PerGraphGOTAndPLTStubsBuilder_ELF_riscv::RV32StubContent[StubEntrySize] = { 123 0x17, 0x0e, 0x00, 0x00, // auipc t3, literal 124 0x03, 0x2e, 0x0e, 0x00, // lw t3, literal(t3) 125 0x67, 0x00, 0x0e, 0x00, // jr t3 126 0x13, 0x00, 0x00, 0x00}; // nop 127 } // namespace 128 namespace llvm { 129 namespace jitlink { 130 131 static Expected<const Edge &> getRISCVPCRelHi20(const Edge &E) { 132 using namespace riscv; 133 assert((E.getKind() == R_RISCV_PCREL_LO12_I || 134 E.getKind() == R_RISCV_PCREL_LO12_S) && 135 "Can only have high relocation for R_RISCV_PCREL_LO12_I or " 136 "R_RISCV_PCREL_LO12_S"); 137 138 const Symbol &Sym = E.getTarget(); 139 const Block &B = Sym.getBlock(); 140 orc::ExecutorAddrDiff Offset = Sym.getOffset(); 141 142 struct Comp { 143 bool operator()(const Edge &Lhs, orc::ExecutorAddrDiff Offset) { 144 return Lhs.getOffset() < Offset; 145 } 146 bool operator()(orc::ExecutorAddrDiff Offset, const Edge &Rhs) { 147 return Offset < Rhs.getOffset(); 148 } 149 }; 150 151 auto Bound = 152 std::equal_range(B.edges().begin(), B.edges().end(), Offset, Comp{}); 153 154 for (auto It = Bound.first; It != Bound.second; ++It) { 155 if (It->getKind() == R_RISCV_PCREL_HI20) 156 return *It; 157 } 158 159 return make_error<JITLinkError>( 160 "No HI20 PCREL relocation type be found for LO12 PCREL relocation type"); 161 } 162 163 static uint32_t extractBits(uint32_t Num, unsigned Low, unsigned Size) { 164 return (Num & (((1ULL << Size) - 1) << Low)) >> Low; 165 } 166 167 static inline bool isAlignmentCorrect(uint64_t Value, int N) { 168 return (Value & (N - 1)) ? false : true; 169 } 170 171 // Requires 0 < N <= 64. 172 static inline bool isInRangeForImm(int64_t Value, int N) { 173 return Value == llvm::SignExtend64(Value, N); 174 } 175 176 class ELFJITLinker_riscv : public JITLinker<ELFJITLinker_riscv> { 177 friend class JITLinker<ELFJITLinker_riscv>; 178 179 public: 180 ELFJITLinker_riscv(std::unique_ptr<JITLinkContext> Ctx, 181 std::unique_ptr<LinkGraph> G, PassConfiguration PassConfig) 182 : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {} 183 184 private: 185 Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const { 186 using namespace riscv; 187 using namespace llvm::support; 188 189 char *BlockWorkingMem = B.getAlreadyMutableContent().data(); 190 char *FixupPtr = BlockWorkingMem + E.getOffset(); 191 orc::ExecutorAddr FixupAddress = B.getAddress() + E.getOffset(); 192 switch (E.getKind()) { 193 case R_RISCV_32: { 194 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 195 *(little32_t *)FixupPtr = static_cast<uint32_t>(Value); 196 break; 197 } 198 case R_RISCV_64: { 199 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 200 *(little64_t *)FixupPtr = static_cast<uint64_t>(Value); 201 break; 202 } 203 case R_RISCV_BRANCH: { 204 int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress; 205 if (LLVM_UNLIKELY(!isInRangeForImm(Value >> 1, 12))) 206 return makeTargetOutOfRangeError(G, B, E); 207 if (LLVM_UNLIKELY(!isAlignmentCorrect(Value, 2))) 208 return makeAlignmentError(FixupAddress, Value, 2, E); 209 uint32_t Imm12 = extractBits(Value, 12, 1) << 31; 210 uint32_t Imm10_5 = extractBits(Value, 5, 6) << 25; 211 uint32_t Imm4_1 = extractBits(Value, 1, 4) << 8; 212 uint32_t Imm11 = extractBits(Value, 11, 1) << 7; 213 uint32_t RawInstr = *(little32_t *)FixupPtr; 214 *(little32_t *)FixupPtr = 215 (RawInstr & 0x1FFF07F) | Imm12 | Imm10_5 | Imm4_1 | Imm11; 216 break; 217 } 218 case R_RISCV_JAL: { 219 int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress; 220 if (LLVM_UNLIKELY(!isInRangeForImm(Value >> 1, 20))) 221 return makeTargetOutOfRangeError(G, B, E); 222 if (LLVM_UNLIKELY(!isAlignmentCorrect(Value, 2))) 223 return makeAlignmentError(FixupAddress, Value, 2, E); 224 uint32_t Imm20 = extractBits(Value, 20, 1) << 31; 225 uint32_t Imm10_1 = extractBits(Value, 1, 10) << 21; 226 uint32_t Imm11 = extractBits(Value, 11, 1) << 20; 227 uint32_t Imm19_12 = extractBits(Value, 12, 8) << 12; 228 uint32_t RawInstr = *(little32_t *)FixupPtr; 229 *(little32_t *)FixupPtr = 230 (RawInstr & 0xFFF) | Imm20 | Imm10_1 | Imm11 | Imm19_12; 231 break; 232 } 233 case R_RISCV_CALL_PLT: 234 case R_RISCV_CALL: { 235 int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress; 236 int64_t Hi = Value + 0x800; 237 if (LLVM_UNLIKELY(!isInRangeForImm(Hi, 32))) 238 return makeTargetOutOfRangeError(G, B, E); 239 int32_t Lo = Value & 0xFFF; 240 uint32_t RawInstrAuipc = *(little32_t *)FixupPtr; 241 uint32_t RawInstrJalr = *(little32_t *)(FixupPtr + 4); 242 *(little32_t *)FixupPtr = 243 RawInstrAuipc | (static_cast<uint32_t>(Hi & 0xFFFFF000)); 244 *(little32_t *)(FixupPtr + 4) = 245 RawInstrJalr | (static_cast<uint32_t>(Lo) << 20); 246 break; 247 } 248 // The relocations R_RISCV_CALL_PLT and R_RISCV_GOT_HI20 are handled by 249 // PerGraphGOTAndPLTStubsBuilder_ELF_riscv and are transformed into 250 // R_RISCV_CALL and R_RISCV_PCREL_HI20. 251 case R_RISCV_PCREL_HI20: { 252 int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress; 253 int64_t Hi = Value + 0x800; 254 if (LLVM_UNLIKELY(!isInRangeForImm(Hi, 32))) 255 return makeTargetOutOfRangeError(G, B, E); 256 uint32_t RawInstr = *(little32_t *)FixupPtr; 257 *(little32_t *)FixupPtr = 258 (RawInstr & 0xFFF) | (static_cast<uint32_t>(Hi & 0xFFFFF000)); 259 break; 260 } 261 case R_RISCV_PCREL_LO12_I: { 262 // FIXME: We assume that R_RISCV_PCREL_HI20 is present in object code and 263 // pairs with current relocation R_RISCV_PCREL_LO12_I. So here may need a 264 // check. 265 auto RelHI20 = getRISCVPCRelHi20(E); 266 if (!RelHI20) 267 return RelHI20.takeError(); 268 int64_t Value = RelHI20->getTarget().getAddress() + 269 RelHI20->getAddend() - E.getTarget().getAddress(); 270 int64_t Lo = Value & 0xFFF; 271 uint32_t RawInstr = *(little32_t *)FixupPtr; 272 *(little32_t *)FixupPtr = 273 (RawInstr & 0xFFFFF) | (static_cast<uint32_t>(Lo & 0xFFF) << 20); 274 break; 275 } 276 case R_RISCV_PCREL_LO12_S: { 277 // FIXME: We assume that R_RISCV_PCREL_HI20 is present in object code and 278 // pairs with current relocation R_RISCV_PCREL_LO12_S. So here may need a 279 // check. 280 auto RelHI20 = getRISCVPCRelHi20(E); 281 if (!RelHI20) 282 return RelHI20.takeError(); 283 int64_t Value = RelHI20->getTarget().getAddress() + 284 RelHI20->getAddend() - E.getTarget().getAddress(); 285 int64_t Lo = Value & 0xFFF; 286 uint32_t Imm11_5 = extractBits(Lo, 5, 7) << 25; 287 uint32_t Imm4_0 = extractBits(Lo, 0, 5) << 7; 288 uint32_t RawInstr = *(little32_t *)FixupPtr; 289 290 *(little32_t *)FixupPtr = (RawInstr & 0x1FFF07F) | Imm11_5 | Imm4_0; 291 break; 292 } 293 case R_RISCV_HI20: { 294 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 295 int64_t Hi = Value + 0x800; 296 if (LLVM_UNLIKELY(!isInRangeForImm(Hi, 32))) 297 return makeTargetOutOfRangeError(G, B, E); 298 uint32_t RawInstr = *(little32_t *)FixupPtr; 299 *(little32_t *)FixupPtr = 300 (RawInstr & 0xFFF) | (static_cast<uint32_t>(Hi & 0xFFFFF000)); 301 break; 302 } 303 case R_RISCV_LO12_I: { 304 // FIXME: We assume that R_RISCV_HI20 is present in object code and pairs 305 // with current relocation R_RISCV_LO12_I. So here may need a check. 306 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 307 int32_t Lo = Value & 0xFFF; 308 uint32_t RawInstr = *(little32_t *)FixupPtr; 309 *(little32_t *)FixupPtr = 310 (RawInstr & 0xFFFFF) | (static_cast<uint32_t>(Lo & 0xFFF) << 20); 311 break; 312 } 313 case R_RISCV_LO12_S: { 314 // FIXME: We assume that R_RISCV_HI20 is present in object code and pairs 315 // with current relocation R_RISCV_LO12_S. So here may need a check. 316 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 317 int64_t Lo = Value & 0xFFF; 318 uint32_t Imm11_5 = extractBits(Lo, 5, 7) << 25; 319 uint32_t Imm4_0 = extractBits(Lo, 0, 5) << 7; 320 uint32_t RawInstr = *(little32_t *)FixupPtr; 321 *(little32_t *)FixupPtr = (RawInstr & 0x1FFF07F) | Imm11_5 | Imm4_0; 322 break; 323 } 324 case R_RISCV_ADD8: { 325 int64_t Value = 326 (E.getTarget().getAddress() + 327 *(reinterpret_cast<const uint8_t *>(FixupPtr)) + E.getAddend()) 328 .getValue(); 329 *FixupPtr = static_cast<uint8_t>(Value); 330 break; 331 } 332 case R_RISCV_ADD16: { 333 int64_t Value = (E.getTarget().getAddress() + 334 support::endian::read16le(FixupPtr) + E.getAddend()) 335 .getValue(); 336 *(little16_t *)FixupPtr = static_cast<uint16_t>(Value); 337 break; 338 } 339 case R_RISCV_ADD32: { 340 int64_t Value = (E.getTarget().getAddress() + 341 support::endian::read32le(FixupPtr) + E.getAddend()) 342 .getValue(); 343 *(little32_t *)FixupPtr = static_cast<uint32_t>(Value); 344 break; 345 } 346 case R_RISCV_ADD64: { 347 int64_t Value = (E.getTarget().getAddress() + 348 support::endian::read64le(FixupPtr) + E.getAddend()) 349 .getValue(); 350 *(little64_t *)FixupPtr = static_cast<uint64_t>(Value); 351 break; 352 } 353 case R_RISCV_SUB8: { 354 int64_t Value = *(reinterpret_cast<const uint8_t *>(FixupPtr)) - 355 E.getTarget().getAddress().getValue() - E.getAddend(); 356 *FixupPtr = static_cast<uint8_t>(Value); 357 break; 358 } 359 case R_RISCV_SUB16: { 360 int64_t Value = support::endian::read16le(FixupPtr) - 361 E.getTarget().getAddress().getValue() - E.getAddend(); 362 *(little16_t *)FixupPtr = static_cast<uint32_t>(Value); 363 break; 364 } 365 case R_RISCV_SUB32: { 366 int64_t Value = support::endian::read32le(FixupPtr) - 367 E.getTarget().getAddress().getValue() - E.getAddend(); 368 *(little32_t *)FixupPtr = static_cast<uint32_t>(Value); 369 break; 370 } 371 case R_RISCV_SUB64: { 372 int64_t Value = support::endian::read64le(FixupPtr) - 373 E.getTarget().getAddress().getValue() - E.getAddend(); 374 *(little64_t *)FixupPtr = static_cast<uint64_t>(Value); 375 break; 376 } 377 case R_RISCV_RVC_BRANCH: { 378 int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress; 379 if (LLVM_UNLIKELY(!isInRangeForImm(Value >> 1, 8))) 380 return makeTargetOutOfRangeError(G, B, E); 381 if (LLVM_UNLIKELY(!isAlignmentCorrect(Value, 2))) 382 return makeAlignmentError(FixupAddress, Value, 2, E); 383 uint16_t Imm8 = extractBits(Value, 8, 1) << 12; 384 uint16_t Imm4_3 = extractBits(Value, 3, 2) << 10; 385 uint16_t Imm7_6 = extractBits(Value, 6, 2) << 5; 386 uint16_t Imm2_1 = extractBits(Value, 1, 2) << 3; 387 uint16_t Imm5 = extractBits(Value, 5, 1) << 2; 388 uint16_t RawInstr = *(little16_t *)FixupPtr; 389 *(little16_t *)FixupPtr = 390 (RawInstr & 0xE383) | Imm8 | Imm4_3 | Imm7_6 | Imm2_1 | Imm5; 391 break; 392 } 393 case R_RISCV_RVC_JUMP: { 394 int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress; 395 if (LLVM_UNLIKELY(!isInRangeForImm(Value >> 1, 11))) 396 return makeTargetOutOfRangeError(G, B, E); 397 if (LLVM_UNLIKELY(!isAlignmentCorrect(Value, 2))) 398 return makeAlignmentError(FixupAddress, Value, 2, E); 399 uint16_t Imm11 = extractBits(Value, 11, 1) << 12; 400 uint16_t Imm4 = extractBits(Value, 4, 1) << 11; 401 uint16_t Imm9_8 = extractBits(Value, 8, 2) << 9; 402 uint16_t Imm10 = extractBits(Value, 10, 1) << 8; 403 uint16_t Imm6 = extractBits(Value, 6, 1) << 7; 404 uint16_t Imm7 = extractBits(Value, 7, 1) << 6; 405 uint16_t Imm3_1 = extractBits(Value, 1, 3) << 3; 406 uint16_t Imm5 = extractBits(Value, 5, 1) << 2; 407 uint16_t RawInstr = *(little16_t *)FixupPtr; 408 *(little16_t *)FixupPtr = (RawInstr & 0xE003) | Imm11 | Imm4 | Imm9_8 | 409 Imm10 | Imm6 | Imm7 | Imm3_1 | Imm5; 410 break; 411 } 412 case R_RISCV_SUB6: { 413 int64_t Value = *(reinterpret_cast<const uint8_t *>(FixupPtr)) & 0x3f; 414 Value -= E.getTarget().getAddress().getValue() - E.getAddend(); 415 *FixupPtr = (*FixupPtr & 0xc0) | (static_cast<uint8_t>(Value) & 0x3f); 416 break; 417 } 418 case R_RISCV_SET6: { 419 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 420 uint32_t RawData = *(little32_t *)FixupPtr; 421 int64_t Word6 = Value & 0x3f; 422 *(little32_t *)FixupPtr = (RawData & 0xffffffc0) | Word6; 423 break; 424 } 425 case R_RISCV_SET8: { 426 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 427 uint32_t RawData = *(little32_t *)FixupPtr; 428 int64_t Word8 = Value & 0xff; 429 *(little32_t *)FixupPtr = (RawData & 0xffffff00) | Word8; 430 break; 431 } 432 case R_RISCV_SET16: { 433 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 434 uint32_t RawData = *(little32_t *)FixupPtr; 435 int64_t Word16 = Value & 0xffff; 436 *(little32_t *)FixupPtr = (RawData & 0xffff0000) | Word16; 437 break; 438 } 439 case R_RISCV_SET32: { 440 int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue(); 441 int64_t Word32 = Value & 0xffffffff; 442 *(little32_t *)FixupPtr = Word32; 443 break; 444 } 445 case R_RISCV_32_PCREL: { 446 int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress; 447 int64_t Word32 = Value & 0xffffffff; 448 *(little32_t *)FixupPtr = Word32; 449 break; 450 } 451 } 452 return Error::success(); 453 } 454 }; 455 456 template <typename ELFT> 457 class ELFLinkGraphBuilder_riscv : public ELFLinkGraphBuilder<ELFT> { 458 private: 459 static Expected<riscv::EdgeKind_riscv> 460 getRelocationKind(const uint32_t Type) { 461 using namespace riscv; 462 switch (Type) { 463 case ELF::R_RISCV_32: 464 return EdgeKind_riscv::R_RISCV_32; 465 case ELF::R_RISCV_64: 466 return EdgeKind_riscv::R_RISCV_64; 467 case ELF::R_RISCV_BRANCH: 468 return EdgeKind_riscv::R_RISCV_BRANCH; 469 case ELF::R_RISCV_JAL: 470 return EdgeKind_riscv::R_RISCV_JAL; 471 case ELF::R_RISCV_CALL: 472 return EdgeKind_riscv::R_RISCV_CALL; 473 case ELF::R_RISCV_CALL_PLT: 474 return EdgeKind_riscv::R_RISCV_CALL_PLT; 475 case ELF::R_RISCV_GOT_HI20: 476 return EdgeKind_riscv::R_RISCV_GOT_HI20; 477 case ELF::R_RISCV_PCREL_HI20: 478 return EdgeKind_riscv::R_RISCV_PCREL_HI20; 479 case ELF::R_RISCV_PCREL_LO12_I: 480 return EdgeKind_riscv::R_RISCV_PCREL_LO12_I; 481 case ELF::R_RISCV_PCREL_LO12_S: 482 return EdgeKind_riscv::R_RISCV_PCREL_LO12_S; 483 case ELF::R_RISCV_HI20: 484 return EdgeKind_riscv::R_RISCV_HI20; 485 case ELF::R_RISCV_LO12_I: 486 return EdgeKind_riscv::R_RISCV_LO12_I; 487 case ELF::R_RISCV_LO12_S: 488 return EdgeKind_riscv::R_RISCV_LO12_S; 489 case ELF::R_RISCV_ADD8: 490 return EdgeKind_riscv::R_RISCV_ADD8; 491 case ELF::R_RISCV_ADD16: 492 return EdgeKind_riscv::R_RISCV_ADD16; 493 case ELF::R_RISCV_ADD32: 494 return EdgeKind_riscv::R_RISCV_ADD32; 495 case ELF::R_RISCV_ADD64: 496 return EdgeKind_riscv::R_RISCV_ADD64; 497 case ELF::R_RISCV_SUB8: 498 return EdgeKind_riscv::R_RISCV_SUB8; 499 case ELF::R_RISCV_SUB16: 500 return EdgeKind_riscv::R_RISCV_SUB16; 501 case ELF::R_RISCV_SUB32: 502 return EdgeKind_riscv::R_RISCV_SUB32; 503 case ELF::R_RISCV_SUB64: 504 return EdgeKind_riscv::R_RISCV_SUB64; 505 case ELF::R_RISCV_RVC_BRANCH: 506 return EdgeKind_riscv::R_RISCV_RVC_BRANCH; 507 case ELF::R_RISCV_RVC_JUMP: 508 return EdgeKind_riscv::R_RISCV_RVC_JUMP; 509 case ELF::R_RISCV_SUB6: 510 return EdgeKind_riscv::R_RISCV_SUB6; 511 case ELF::R_RISCV_SET6: 512 return EdgeKind_riscv::R_RISCV_SET6; 513 case ELF::R_RISCV_SET8: 514 return EdgeKind_riscv::R_RISCV_SET8; 515 case ELF::R_RISCV_SET16: 516 return EdgeKind_riscv::R_RISCV_SET16; 517 case ELF::R_RISCV_SET32: 518 return EdgeKind_riscv::R_RISCV_SET32; 519 case ELF::R_RISCV_32_PCREL: 520 return EdgeKind_riscv::R_RISCV_32_PCREL; 521 } 522 523 return make_error<JITLinkError>( 524 "Unsupported riscv relocation:" + formatv("{0:d}: ", Type) + 525 object::getELFRelocationTypeName(ELF::EM_RISCV, Type)); 526 } 527 528 Error addRelocations() override { 529 LLVM_DEBUG(dbgs() << "Processing relocations:\n"); 530 531 using Base = ELFLinkGraphBuilder<ELFT>; 532 using Self = ELFLinkGraphBuilder_riscv<ELFT>; 533 for (const auto &RelSect : Base::Sections) 534 if (Error Err = Base::forEachRelaRelocation(RelSect, this, 535 &Self::addSingleRelocation)) 536 return Err; 537 538 return Error::success(); 539 } 540 541 Error addSingleRelocation(const typename ELFT::Rela &Rel, 542 const typename ELFT::Shdr &FixupSect, 543 Block &BlockToFix) { 544 using Base = ELFLinkGraphBuilder<ELFT>; 545 546 uint32_t Type = Rel.getType(false); 547 // We do not implement linker relaxation, except what is required for 548 // alignment (see below). 549 if (Type == llvm::ELF::R_RISCV_RELAX) 550 return Error::success(); 551 552 int64_t Addend = Rel.r_addend; 553 if (Type == llvm::ELF::R_RISCV_ALIGN) { 554 uint64_t Alignment = PowerOf2Ceil(Addend); 555 // FIXME: Implement support for ensuring alignment together with linker 556 // relaxation; 2 bytes are guaranteed by the length of compressed 557 // instructions, so this does not need any action from our side. 558 if (Alignment > 2) 559 return make_error<JITLinkError>( 560 formatv("Unsupported relocation R_RISCV_ALIGN with alignment {0} " 561 "larger than 2 (addend: {1})", 562 Alignment, Addend)); 563 return Error::success(); 564 } 565 566 Expected<riscv::EdgeKind_riscv> Kind = getRelocationKind(Type); 567 if (!Kind) 568 return Kind.takeError(); 569 570 uint32_t SymbolIndex = Rel.getSymbol(false); 571 auto ObjSymbol = Base::Obj.getRelocationSymbol(Rel, Base::SymTabSec); 572 if (!ObjSymbol) 573 return ObjSymbol.takeError(); 574 575 Symbol *GraphSymbol = Base::getGraphSymbol(SymbolIndex); 576 if (!GraphSymbol) 577 return make_error<StringError>( 578 formatv("Could not find symbol at given index, did you add it to " 579 "JITSymbolTable? index: {0}, shndx: {1} Size of table: {2}", 580 SymbolIndex, (*ObjSymbol)->st_shndx, 581 Base::GraphSymbols.size()), 582 inconvertibleErrorCode()); 583 584 auto FixupAddress = orc::ExecutorAddr(FixupSect.sh_addr) + Rel.r_offset; 585 Edge::OffsetT Offset = FixupAddress - BlockToFix.getAddress(); 586 Edge GE(*Kind, Offset, *GraphSymbol, Addend); 587 LLVM_DEBUG({ 588 dbgs() << " "; 589 printEdge(dbgs(), BlockToFix, GE, riscv::getEdgeKindName(*Kind)); 590 dbgs() << "\n"; 591 }); 592 593 BlockToFix.addEdge(std::move(GE)); 594 return Error::success(); 595 } 596 597 public: 598 ELFLinkGraphBuilder_riscv(StringRef FileName, 599 const object::ELFFile<ELFT> &Obj, Triple TT) 600 : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), FileName, 601 riscv::getEdgeKindName) {} 602 }; 603 604 Expected<std::unique_ptr<LinkGraph>> 605 createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) { 606 LLVM_DEBUG({ 607 dbgs() << "Building jitlink graph for new input " 608 << ObjectBuffer.getBufferIdentifier() << "...\n"; 609 }); 610 611 auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer); 612 if (!ELFObj) 613 return ELFObj.takeError(); 614 615 if ((*ELFObj)->getArch() == Triple::riscv64) { 616 auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj); 617 return ELFLinkGraphBuilder_riscv<object::ELF64LE>( 618 (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), 619 (*ELFObj)->makeTriple()) 620 .buildGraph(); 621 } else { 622 assert((*ELFObj)->getArch() == Triple::riscv32 && 623 "Invalid triple for RISCV ELF object file"); 624 auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj); 625 return ELFLinkGraphBuilder_riscv<object::ELF32LE>( 626 (*ELFObj)->getFileName(), ELFObjFile.getELFFile(), 627 (*ELFObj)->makeTriple()) 628 .buildGraph(); 629 } 630 } 631 632 void link_ELF_riscv(std::unique_ptr<LinkGraph> G, 633 std::unique_ptr<JITLinkContext> Ctx) { 634 PassConfiguration Config; 635 const Triple &TT = G->getTargetTriple(); 636 if (Ctx->shouldAddDefaultTargetPasses(TT)) { 637 if (auto MarkLive = Ctx->getMarkLivePass(TT)) 638 Config.PrePrunePasses.push_back(std::move(MarkLive)); 639 else 640 Config.PrePrunePasses.push_back(markAllSymbolsLive); 641 Config.PostPrunePasses.push_back( 642 PerGraphGOTAndPLTStubsBuilder_ELF_riscv::asPass); 643 } 644 if (auto Err = Ctx->modifyPassConfig(*G, Config)) 645 return Ctx->notifyFailed(std::move(Err)); 646 647 ELFJITLinker_riscv::link(std::move(Ctx), std::move(G), std::move(Config)); 648 } 649 650 } // namespace jitlink 651 } // namespace llvm 652