[JITLink][RISCV] Support R_RISCV_SET* and R_RISCV_32_PCREL relocations

[fourdim]

Summary

This patch supports R_RISCV_SET* and R_RISCV_32_PCREL relocations in JITLink.

[jrtc27]

You can write tests just fine in assembly. Use .reloc if needed. You don't need .eh_frame for that.

llvm/include/llvm/ExecutionEngine/JITLink/riscv.h

94

These are all missing a /

llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp

300

These all operate on an 8/16/32-bit value (SET6 operates on the low 6 bits of an 8-bit value). These do not relocate instructions, they relocate data. Again, please look at LLD before implementing things rather than guessing.

325

This is not an R_RISCV_SET* relocation, yet the commit message says that's that is added

325

*that's all that is added

[fourdim]

In D117082#3236340, @jrtc27 wrote:

You can write tests just fine in assembly. Use .reloc if needed. You don't need .eh_frame for that.

Sorry for my stupid mistakes.
I'm planning to upload a new diff, however, I'm still confused about the .reloc.
It appears that it only adds a R_RISCV_SET* relocation in the binary.
I'm checking lld/test/ELF/riscv-reloc-add.s and D63183, and got no idea on how to set the value.
Particularly, D63183 says,

Note llvm-mc cannot currently produce R_RISCV_SET* so they are not tested.

And the test case now still does not add R_RISCV_SET* test.
Would you be so kind to give some hints on how to test it?

[jrtc27]

In D117082#3239455, @fourdim wrote:

In D117082#3236340, @jrtc27 wrote:

You can write tests just fine in assembly. Use .reloc if needed. You don't need .eh_frame for that.

Sorry for my stupid mistakes.
I'm planning to upload a new diff, however, I'm still confused about the .reloc.
It appears that it only adds a R_RISCV_SET* relocation in the binary.
I'm checking lld/test/ELF/riscv-reloc-add.s and D63183, and got no idea on how to set the value.
Particularly, D63183 says,

Note llvm-mc cannot currently produce R_RISCV_SET* so they are not tested.

And the test case now still does not add R_RISCV_SET* test.
Would you be so kind to give some hints on how to test it?

That comment likely predates .reloc support for RISC-V. You use .reloc like:

    .reloc 1f, R_RISCV_SET6, foo
1:  .byte 0

i.e. it takes the location to relocate, the relocation name and the value to use

[fourdim]

Add test cases and address the comments.

[fourdim]

Include the recent commits.

[StephenFan]

LGTM.

llvm/include/llvm/ExecutionEngine/JITLink/riscv.h

enum EdgeKind_riscv : Edge::Kind {
   R_RISCV_GOT_HI20,
 
   /// PC relative call by PLT
   ///
   /// Fixup expression:
   ///   Fixup <- (Target - Fixup + Addend)
   R_RISCV_CALL_PLT,
 
   /// 64 bits label addition
   ///
   /// Fixup expression:
   ///   Fixup <- (Target - *{8}Fixup + Addend)
   R_RISCV_ADD64,
 
   /// 32 bits label addition
   ///
   /// Fixup expression:
enum EdgeKind_riscv : Edge::Kind {
   /// Fixup expression
   ///   Fixup <- (Target - *{2}Fixup - Addend)
   R_RISCV_SUB16,
 
   /// 8 bits label subtraction
   ///
   /// Fixup expression
   ///   Fixup <- (Target - *{1}Fixup - Addend)
-  R_RISCV_SUB8
+  R_RISCV_SUB8,
+
+  /// Local label assignment
+  ///
+  /// Fixup expression:
+  ///   Fixup <- (Target + Addend)
+  R_RISCV_SET6,
+
+  /// Local label assignment
+  ///
+  /// Fixup expression:
+  ///   Fixup <- (Target + Addend)
+  R_RISCV_SET8,
+
+  /// Local label assignment
+  ///
+  /// Fixup expression:
+  ///   Fixup <- (Target + Addend)
+  R_RISCV_SET16,
+
+  /// Local label assignment
+  ///
+  /// Fixup expression:
+  ///   Fixup <- (Target + Addend)
+  R_RISCV_SET32,
+
+  /// Local label assignment
+  ///
+  /// Fixup expression:
+  ///   Fixup <- (Target - Fixup + Addend)
+  R_RISCV_32_PCREL,
 };
 
 /// Returns a string name for the given riscv edge. For debugging purposes
 /// only
 const char *getEdgeKindName(Edge::Kind K);
 } // namespace riscv
 } // namespace jitlink
 } // namespace llvm
 
 #endif

llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp

case R_RISCV_PCREL_LO12_S: {
       uint32_t Imm11_7 = extractBits(Lo, 0, 5) << 7;
       uint32_t RawInstr = *(little32_t *)FixupPtr;
 
       *(little32_t *)FixupPtr = (RawInstr & 0x1FFF07F) | Imm31_25 | Imm11_7;
       break;
     }
     case R_RISCV_ADD64: {
       int64_t Value = (E.getTarget().getAddress() +
                        support::endian::read64le(reinterpret_cast<const void *>(
                            FixupAddress.getValue())) +
                        E.getAddend())
                           .getValue();
       *(little64_t *)FixupPtr = static_cast<uint64_t>(Value);
       break;
     }
     case R_RISCV_ADD32: {
       int64_t Value = (E.getTarget().getAddress() +
                        support::endian::read32le(reinterpret_cast<const void *>(
                            FixupAddress.getValue())) +
                        E.getAddend())
                           .getValue();
       *(little32_t *)FixupPtr = static_cast<uint32_t>(Value);
       break;
     }
     case R_RISCV_ADD16: {
       int64_t Value = (E.getTarget().getAddress() +
                        support::endian::read16le(reinterpret_cast<const void *>(
                            FixupAddress.getValue())) +
                        E.getAddend())
                           .getValue();
       *(little16_t *)FixupPtr = static_cast<uint32_t>(Value);
       break;
     }
     case R_RISCV_ADD8: {
       int64_t Value =
           (E.getTarget().getAddress() +
            *(reinterpret_cast<const uint8_t *>(FixupAddress.getValue())) +
            E.getAddend())
               .getValue();
       *FixupPtr = static_cast<uint8_t>(Value);
       break;
     }
Error applyFixup(LinkGraph &G, Block &B, const Edge &E) const {
     }
     case R_RISCV_SUB8: {
       int64_t Value =
           *(reinterpret_cast<const uint8_t *>(FixupAddress.getValue())) -
           E.getTarget().getAddress().getValue() - E.getAddend();
       *FixupPtr = static_cast<uint8_t>(Value);
       break;
     }
+    case R_RISCV_SET6: {
+      int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue();
+      uint32_t RawData = *(little32_t *)FixupPtr;
+      int64_t Word6 = Value & 0x3f;
+      *(little32_t *)FixupPtr = (RawData & 0xffffffc0) | Word6;
+      break;
+    }
+    case R_RISCV_SET8: {
+      int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue();
+      uint32_t RawData = *(little32_t *)FixupPtr;
+      int64_t Word8 = Value & 0xff;
+      *(little32_t *)FixupPtr = (RawData & 0xffffff00) | Word8;
+      break;
+    }
+    case R_RISCV_SET16: {
+      int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue();
+      uint32_t RawData = *(little32_t *)FixupPtr;
+      int64_t Word16 = Value & 0xffff;
+      *(little32_t *)FixupPtr = (RawData & 0xffff0000) | Word16;
+      break;
+    }
+    case R_RISCV_SET32: {
+      int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue();
+      int64_t Word32 = Value & 0xffffffff;
+      *(little32_t *)FixupPtr = Word32;
+      break;
+    }
+    case R_RISCV_32_PCREL: {
+      int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress;
+      int64_t Word32 = Value & 0xffffffff;
+      *(little32_t *)FixupPtr = Word32;
+      break;
+    }
     }
     return Error::success();
   }
 };
 
 template <typename ELFT>
 class ELFLinkGraphBuilder_riscv : public ELFLinkGraphBuilder<ELFT> {
 private:
getRelocationKind(const uint32_t Type) {
     case ELF::R_RISCV_SUB64:
       return EdgeKind_riscv::R_RISCV_SUB64;
     case ELF::R_RISCV_SUB32:
       return EdgeKind_riscv::R_RISCV_SUB32;
     case ELF::R_RISCV_SUB16:
       return EdgeKind_riscv::R_RISCV_SUB16;
     case ELF::R_RISCV_SUB8:
       return EdgeKind_riscv::R_RISCV_SUB8;
+    case ELF::R_RISCV_SET6:
+      return EdgeKind_riscv::R_RISCV_SET6;
+    case ELF::R_RISCV_SET8:
+      return EdgeKind_riscv::R_RISCV_SET8;
+    case ELF::R_RISCV_SET16:
+      return EdgeKind_riscv::R_RISCV_SET16;
+    case ELF::R_RISCV_SET32:
+      return EdgeKind_riscv::R_RISCV_SET32;
+    case ELF::R_RISCV_32_PCREL:
+      return EdgeKind_riscv::R_RISCV_32_PCREL;
     }
 
     return make_error<JITLinkError>("Unsupported riscv relocation:" +
                                     formatv("{0:d}", Type));
   }
 
   Error addRelocations() override {
     LLVM_DEBUG(dbgs() << "Processing relocations:\n");

llvm/lib/ExecutionEngine/JITLink/riscv.cpp

const char *getEdgeKindName(Edge::Kind K) {
   case R_RISCV_SUB64:
     return "R_RISCV_SUB64";
   case R_RISCV_SUB32:
     return "R_RISCV_SUB32";
   case R_RISCV_SUB16:
     return "R_RISCV_SUB16";
   case R_RISCV_SUB8:
     return "R_RISCV_SUB8";
+  case R_RISCV_SET6:
+    return "R_RISCV_SET6";
+  case R_RISCV_SET8:
+    return "R_RISCV_SET8";
+  case R_RISCV_SET16:
+    return "R_RISCV_SET16";
+  case R_RISCV_SET32:
+    return "R_RISCV_SET32";
+  case R_RISCV_32_PCREL:
+    return "R_RISCV_32_PCREL";
   }
   return getGenericEdgeKindName(K);
 }
 } // namespace riscv
 } // namespace jitlink
 } // namespace llvm

llvm/test/ExecutionEngine/JITLink/RISCV/ELF_pc_relative.s

+# RUN: rm -rf %t && mkdir -p %t
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t/riscv64_pc_relative.o %s
+# RUN: llvm-mc -triple=riscv32 -filetype=obj -o %t/riscv32_pc_relative.o %s
+# RUN: llvm-jitlink -noexec -check %s %t/riscv64_pc_relative.o
+# RUN: llvm-jitlink -noexec -check %s %t/riscv32_pc_relative.o
+
+# jitlink-check: *{4}(foo) = 0x4
+
+.global main
+main:
+  lw a0, foo
+
+.section ".text","",@progbits
+.type foo,@function
+foo:
+  nop
+  nop
+  .reloc foo, R_RISCV_32_PCREL, foo+4
+  .size foo, 8

llvm/test/ExecutionEngine/JITLink/RISCV/ELF_reloc_set.s

+# RUN: rm -rf %t && mkdir -p %t
+# RUN: llvm-mc -triple=riscv64 -filetype=obj -o %t/riscv64_reloc_set.o %s
+# RUN: llvm-mc -triple=riscv32 -filetype=obj -o %t/riscv32_reloc_set.o %s
+# RUN: llvm-jitlink -noexec \
+# RUN:  -slab-allocate 100Kb -slab-address 0xfff0f0f0 -slab-page-size 4096 \
+# RUN:  -check %s %t/riscv64_reloc_set.o
+# RUN: llvm-jitlink -noexec \
+# RUN:  -slab-allocate 100Kb -slab-address 0xfff0f0f0 -slab-page-size 4096 \
+# RUN:  -check %s %t/riscv32_reloc_set.o
+
+# jitlink-check: *{4}(foo) = foo
+# jitlink-check: *{2}(foo+4) = foo[15:0]
+# jitlink-check: *{1}(foo+6) = foo[7:0]
+# jitlink-check: *{1}(foo+7) = foo[5:0]
+
+.global main
+main:
+  lw a0, foo
+
+.section ".rodata","",@progbits
+.type foo,@object
+foo:
+  .reloc foo, R_RISCV_SET32, foo
+  .reloc foo+4, R_RISCV_SET16, foo
+  .reloc foo+6, R_RISCV_SET8, foo
+  .reloc foo+7, R_RISCV_SET6, foo
+  .word 0
+  .half 0
+  .byte 0
+  .byte 0
+  .size foo, 8