[JITLink][AArch32] Implement ELF::R_ARM_JUMP24

[Eymay]

Summary

Added support and test for ELF::R_ARM_JUMP24

[sgraenitz]

Thanks!

Is the test actually working right now? Since we always use indirection stubs and we only have a Thumb implementation right now, my quick assumption was that the TargetSymbol should always have the ThumbSymbol flag set (and thus always bail out). Maybe I find the time in the next days to look into it myself and give some informed feedback.

llvm/lib/ExecutionEngine/JITLink/aarch32.cpp

412

Nit: bridging to Thumb

[Eymay]

In D157541#4574325, @sgraenitz wrote:

Thanks!

Is the test actually working right now? Since we always use indirection stubs and we only have a Thumb implementation right now, my quick assumption was that the TargetSymbol should always have the ThumbSymbol flag set (and thus always bail out). Maybe I find the time in the next days to look into it myself and give some informed feedback.

Yes it passes on my machine. I observe that TargetSymbol.hasTargetFlags(ThumbSymbol) outputs "0" in applyFixupArm so that might be the reason for not bailing out.

[sgraenitz]

I think this can land as soon as the test fits with the (now) existing ELF_static_arm_reloc.s and your previous patch is in.

[Eymay]

Updated test and squashed commits.

[Eymay]

(NFC) Correct error message

[Eymay]

Update author email.

[Eymay]

Update jitlink-check condition as an explicit offset similar to the change in D157533

[sgraenitz]

Thanks LGTM! Let me double-check the tests on my machine and land this for you.

llvm/include/llvm/ExecutionEngine/JITLink/aarch32.h

enum EdgeKind_aarch32 : Edge::Kind {
   /// Relocations of class Arm (covers fixed-width 4-byte instruction subset)
   ///
   FirstArmRelocation,
 
   /// Write immediate value for PC-relative branch with link (can bridge between
   /// Arm and Thumb).
   Arm_Call = FirstArmRelocation,
 
-  LastArmRelocation = Arm_Call,
+  /// Write immediate value for (unconditional) PC-relative branch without link.
+  Arm_Jump24,
+
+  LastArmRelocation = Arm_Jump24,
 
   ///
   /// Relocations of class Thumb16 and Thumb32 (covers Thumb instruction subset)
   ///
   FirstThumbRelocation,
 
   /// Write immediate value for PC-relative branch with link (can bridge between
   /// Arm and Thumb).

 ///   Opcode      - Values of the op-code bits in the instruction, with
 ///                 unaffected bits nulled
 ///   OpcodeMask  - Mask with all bits set that encode the op-code
 ///   ImmMask     - Mask with all bits set that encode the immediate value
 ///   RegMask     - Mask with all bits set that encode the register
 ///
 template <EdgeKind_aarch32 Kind> struct FixupInfo {};
 
-template <> struct FixupInfo<Arm_Call> {
+template <> struct FixupInfo<Arm_Jump24> {
   static constexpr uint32_t Opcode = 0x0a000000;
-  static constexpr uint32_t OpcodeMask = 0x0e000000;
+  static constexpr uint32_t OpcodeMask = 0x0f000000;
   static constexpr uint32_t ImmMask = 0x00ffffff;
   static constexpr uint32_t Unconditional = 0xe0000000;
   static constexpr uint32_t CondMask = 0xe0000000; // excluding BLX bit
+};
+
+template <> struct FixupInfo<Arm_Call> : public FixupInfo<Arm_Jump24> {
+  static constexpr uint32_t OpcodeMask = 0x0e000000;
   static constexpr uint32_t BitH = 0x01000000;
   static constexpr uint32_t BitBlx = 0x10000000;
 };
 
 template <> struct FixupInfo<Thumb_Jump24> {
   static constexpr HalfWords Opcode{0xf000, 0x8000};
   static constexpr HalfWords OpcodeMask{0xf800, 0x8000};
   static constexpr HalfWords ImmMask{0x07ff, 0x2fff};

llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp

 Expected<aarch32::EdgeKind_aarch32> getJITLinkEdgeKind(uint32_t ELFType) {
   switch (ELFType) {
   case ELF::R_ARM_ABS32:
     return aarch32::Data_Pointer32;
   case ELF::R_ARM_REL32:
     return aarch32::Data_Delta32;
   case ELF::R_ARM_CALL:
     return aarch32::Arm_Call;
+  case ELF::R_ARM_JUMP24:
+    return aarch32::Arm_Jump24;
   case ELF::R_ARM_THM_CALL:
     return aarch32::Thumb_Call;
   case ELF::R_ARM_THM_JUMP24:
     return aarch32::Thumb_Jump24;
   case ELF::R_ARM_THM_MOVW_ABS_NC:
     return aarch32::Thumb_MovwAbsNC;
   case ELF::R_ARM_THM_MOVT_ABS:
     return aarch32::Thumb_MovtAbs;
   }
 
   return make_error<JITLinkError>(
       "Unsupported aarch32 relocation " + formatv("{0:d}: ", ELFType) +
       object::getELFRelocationTypeName(ELF::EM_ARM, ELFType));
 }
 
 /// Translate from JITLink-internal edge kind back to ELF relocation type.
 Expected<uint32_t> getELFRelocationType(Edge::Kind Kind) {
   switch (static_cast<aarch32::EdgeKind_aarch32>(Kind)) {
   case aarch32::Data_Delta32:
     return ELF::R_ARM_REL32;
   case aarch32::Data_Pointer32:
     return ELF::R_ARM_ABS32;
   case aarch32::Arm_Call:
     return ELF::R_ARM_CALL;
+  case aarch32::Arm_Jump24:
+    return ELF::R_ARM_JUMP24;
   case aarch32::Thumb_Call:
     return ELF::R_ARM_THM_CALL;
   case aarch32::Thumb_Jump24:
     return ELF::R_ARM_THM_JUMP24;
   case aarch32::Thumb_MovwAbsNC:
     return ELF::R_ARM_THM_MOVW_ABS_NC;
   case aarch32::Thumb_MovtAbs:
     return ELF::R_ARM_THM_MOVT_ABS;

llvm/lib/ExecutionEngine/JITLink/aarch32.cpp

Expected<int64_t> readAddendArm(LinkGraph &G, Block &B, const Edge &E) {
   Edge::Kind Kind = E.getKind();
 
   switch (Kind) {
   case Arm_Call:
     if (!checkOpcode<Arm_Call>(R))
       return makeUnexpectedOpcodeError(G, R, Kind);
     return decodeImmBA1BlA1BlxA2(R.Wd);
 
+  case Arm_Jump24:
+    if (!checkOpcode<Arm_Jump24>(R))
+      return makeUnexpectedOpcodeError(G, R, Kind);
+    return decodeImmBA1BlA1BlxA2(R.Wd);
+
   default:
     return make_error<JITLinkError>(
         "In graph " + G.getName() + ", section " + B.getSection().getName() +
         " can not read implicit addend for aarch32 edge kind " +
         G.getEdgeKindName(E.getKind()));
   }
 }
 
Error applyFixupArm(LinkGraph &G, Block &B, const Edge &E) {
   uint64_t FixupAddress = (B.getAddress() + E.getOffset()).getValue();
   int64_t Addend = E.getAddend();
   Symbol &TargetSymbol = E.getTarget();
   uint64_t TargetAddress = TargetSymbol.getAddress().getValue();
   if (hasTargetFlags(TargetSymbol, ThumbSymbol))
     TargetAddress |= 0x01;
 
   switch (Kind) {
+  case Arm_Jump24: {
+    if (!checkOpcode<Arm_Jump24>(R))
+      return makeUnexpectedOpcodeError(G, R, Kind);
+    if (hasTargetFlags(TargetSymbol, ThumbSymbol))
+      return make_error<JITLinkError>("Branch relocation needs interworking "
+                                      "stub when bridging to Thumb: " +
+                                      StringRef(G.getEdgeKindName(Kind)));
+
+    int64_t Value = TargetAddress - FixupAddress + Addend;
+
+    if (!isInt<26>(Value))
+      return makeTargetOutOfRangeError(G, B, E);
+    writeImmediate<Arm_Jump24>(R, encodeImmBA1BlA1BlxA2(Value));
+
+    return Error::success();
+  }
   case Arm_Call: {
     if (!checkOpcode<Arm_Call>(R))
       return makeUnexpectedOpcodeError(G, R, Kind);
-
     if ((R.Wd & FixupInfo<Arm_Call>::CondMask) !=
         FixupInfo<Arm_Call>::Unconditional)
       return make_error<JITLinkError>("Relocation expects an unconditional "
                                       "BL/BLX branch instruction: " +
                                       StringRef(G.getEdgeKindName(Kind)));
 
     int64_t Value = TargetAddress - FixupAddress + Addend;
 

 #define KIND_NAME_CASE(K)                                                      \
   case K:                                                                      \
     return #K;
 
   switch (K) {
     KIND_NAME_CASE(Data_Delta32)
     KIND_NAME_CASE(Data_Pointer32)
     KIND_NAME_CASE(Arm_Call)
+    KIND_NAME_CASE(Arm_Jump24)
     KIND_NAME_CASE(Thumb_Call)
     KIND_NAME_CASE(Thumb_Jump24)
     KIND_NAME_CASE(Thumb_MovwAbsNC)
     KIND_NAME_CASE(Thumb_MovtAbs)
   default:
     return getGenericEdgeKindName(K);
   }
 #undef KIND_NAME_CASE

llvm/test/ExecutionEngine/JITLink/AArch32/ELF_static_arm_reloc.s

call_site:
 
   .globl  call_target
   .type call_target,%function
   .p2align  2
 call_target:
   bx  lr
   .size call_target,  .-call_target
 
+# CHECK-TYPE: {{[0-9a-f]+}} R_ARM_JUMP24 jump24_target
+# CHECK-INSTR:  00000008 <jump24_site>:
+# CHECK-INSTR:         8: eafffffe     b      0x8 <jump24_site>
+# CHECK-INSTR:  0000000c <jump24_target>:
+# CHECK-INSTR:         c: e12fff1e     bx      lr
+# jitlink-check: decode_operand(jump24_site, 0) = jump24_target - (jump24_site + 8)
+  .globl  jump24_site
+  .type jump24_site,%function
+  .p2align  2
+jump24_site:
+  b.w jump24_target
+  .size jump24_site,  .-jump24_site
+
+  .globl  jump24_target
+  .type jump24_target,%function
+  .p2align  2
+jump24_target:
+  bx  lr
+  .size jump24_target,  .-jump24_target
+
 # Empty main function for jitlink to be happy
   .globl  main
   .type main,%function
   .p2align  2
 main:
   bx  lr
   .size main, .-main