[JITLink][RISCV] Add R_RISCV_LO12_S relocation support

[StephenFan]

Summary

Fixes: https://github.com/llvm/llvm-project/issues/58979

[Hahnfeld]

LGTM

Btw we should probably order the relocations according to their enum values. But that should be a follow-up patch, I can try to take a look next weekend. I also have the compressed relocations implemented, but I need to write tests for them...

[StephenFan]

In D138030#3928307, @Hahnfeld wrote:

LGTM

Btw we should probably order the relocations according to their enum values. But that should be a follow-up patch, I can try to take a look next weekend. I also have the compressed relocations implemented, but I need to write tests for them...

Looking forward to it!

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

enum EdgeKind_riscv : Edge::Kind {
   R_RISCV_JAL,
 
   /// High 20 bits of 32-bit pointer value relocation
   ///
   /// Fixup expression
   ///   Fixup <- (Target + Addend + 0x800) >> 12
   R_RISCV_HI20,
 
+  /// Low 12 bits of 32-bit pointer value relocation, used by S type instruction
+  /// format
+  ///
+  /// Fixup expression
+  ///   Fixup <- (Target + Addend) & 0xFFF
+  R_RISCV_LO12_S,
+
   /// Low 12 bits of 32-bit pointer value relocation
   ///
   /// Fixup expression
   ///   Fixup <- (Target + Addend) & 0xFFF
   R_RISCV_LO12_I,
   /// High 20 bits of PC relative relocation
   ///
   /// Fixup expression:

llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp

case R_RISCV_LO12_I: {
       // with current relocation R_RISCV_LO12_I. So here may need a check.
       int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue();
       int32_t Lo = Value & 0xFFF;
       uint32_t RawInstr = *(little32_t *)FixupPtr;
       *(little32_t *)FixupPtr =
           (RawInstr & 0xFFFFF) | (static_cast<uint32_t>(Lo & 0xFFF) << 20);
       break;
     }
+    case R_RISCV_LO12_S: {
+      // FIXME: We assume that R_RISCV_HI20 is present in object code and pairs
+      // with current relocation R_RISCV_LO12_S. So here may need a check.
+      int64_t Value = (E.getTarget().getAddress() + E.getAddend()).getValue();
+      int64_t Lo = Value & 0xFFF;
+      uint32_t Imm31_25 = extractBits(Lo, 5, 7) << 25;
+      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_CALL: {
       int64_t Value = E.getTarget().getAddress() + E.getAddend() - FixupAddress;
       int64_t Hi = Value + 0x800;
       if (LLVM_UNLIKELY(!isInRangeForImm(Hi, 32)))
         return makeTargetOutOfRangeError(G, B, E);
       int32_t Lo = Value & 0xFFF;
       uint32_t RawInstrAuipc = *(little32_t *)FixupPtr;
       uint32_t RawInstrJalr = *(little32_t *)(FixupPtr + 4);
getRelocationKind(const uint32_t Type) {
     case ELF::R_RISCV_BRANCH:
       return EdgeKind_riscv::R_RISCV_BRANCH;
     case ELF::R_RISCV_JAL:
       return EdgeKind_riscv::R_RISCV_JAL;
     case ELF::R_RISCV_HI20:
       return EdgeKind_riscv::R_RISCV_HI20;
     case ELF::R_RISCV_LO12_I:
       return EdgeKind_riscv::R_RISCV_LO12_I;
+    case ELF::R_RISCV_LO12_S:
+      return EdgeKind_riscv::R_RISCV_LO12_S;
     case ELF::R_RISCV_CALL:
       return EdgeKind_riscv::R_RISCV_CALL;
     case ELF::R_RISCV_PCREL_HI20:
       return EdgeKind_riscv::R_RISCV_PCREL_HI20;
     case ELF::R_RISCV_PCREL_LO12_I:
       return EdgeKind_riscv::R_RISCV_PCREL_LO12_I;
     case ELF::R_RISCV_PCREL_LO12_S:
       return EdgeKind_riscv::R_RISCV_PCREL_LO12_S;

llvm/lib/ExecutionEngine/JITLink/riscv.cpp

const char *getEdgeKindName(Edge::Kind K) {
   case R_RISCV_BRANCH:
     return "R_RISCV_BRANCH";
   case R_RISCV_JAL:
     return "R_RISCV_JAL";
   case R_RISCV_HI20:
     return "R_RISCV_HI20";
   case R_RISCV_LO12_I:
     return "R_RISCV_LO12_I";
+  case R_RISCV_LO12_S:
+    return "R_RISCV_LO12_S";
   case R_RISCV_PCREL_HI20:
     return "R_RISCV_PCREL_HI20";
   case R_RISCV_PCREL_LO12_I:
     return "R_RISCV_PCREL_LO12_I";
   case R_RISCV_PCREL_LO12_S:
     return "R_RISCV_PCREL_LO12_S";
   case R_RISCV_CALL:
     return "R_RISCV_CALL";

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

 # RUN: rm -rf %t && mkdir -p %t
 # RUN: llvm-mc -triple=riscv64 -filetype=obj \
 # RUN:     -o %t/elf_riscv64_non_pc_indirect_reloc.o %s
 # RUN: llvm-mc -triple=riscv32 -filetype=obj \
 # RUN:     -o %t/elf_riscv32_non_pc_indirect_reloc.o %s
 # RUN: llvm-jitlink -noexec \
 # RUN:     -slab-allocate 100Kb -slab-address 0x1ff00000 -slab-page-size 4096 \
-# RUN:     -abs external_data=0x1ff10000 \
+# RUN:     -abs external_data=0x1ff11115 \
 # RUN:     -check %s %t/elf_riscv64_non_pc_indirect_reloc.o
 # RUN: llvm-jitlink -noexec \
 # RUN:     -slab-allocate 100Kb -slab-address 0x1ff00000 -slab-page-size 4096 \
-# RUN:     -abs external_data=0x1ff10000 \
+# RUN:     -abs external_data=0x1ff11115 \
 # RUN:     -check %s %t/elf_riscv32_non_pc_indirect_reloc.o
 #
 
         .text
         .file   "testcase.c"
 
 # Empty main entry point.
         .globl  main
         .p2align  1
         .type   main,@function
 main:
         ret
 
         .size   main, .-main
 
 # Test R_RISCV_HI20 and R_RISCV_LO12
 
 # jitlink-check: decode_operand(test_abs_rel, 1) = (external_data + 0x800)[31:12]
 # jitlink-check: decode_operand(test_abs_rel+4, 2)[11:0] = (external_data)[11:0]
+# jitlink-check: decode_operand(test_abs_rel+8, 2)[11:0] = (external_data)[11:0]
   .globl  test_abs_rel
   .p2align  1
   .type  test_abs_rel,@function
 test_abs_rel:
-  lui  a0, %hi(external_data)
-  lw  a0, %lo(external_data)(a0)
+  lui  a1, %hi(external_data)
+  lw  a0, %lo(external_data)(a1)
+  sw  a0, %lo(external_data)(a1)
 
   .size test_abs_rel, .-test_abs_rel