[RuntimeDyld] Adapt PPC64 relocations to PPC32

[pasaulais]

Summary

RuntimeDyldELF implements many PPC64 relocations but none for PPC32. This patch adapts (copies, really) from PPC64 the code for two relocations that can be used to access global variables like in the attached test case.

[hfinkel]

I don't know how the JIT is tested for the PPC target. There only seem to be X86 and ARM tests in test/ExecutionEngine/RuntimeDyld

That's not good. The generic MCJIT tests are run on PPC64, but otherwise I don't know.

Can you please add a test for this patch (in test/ExecutionEngine/RuntimeDyld sounds good if that's easiest) -- (just remember that the new directory needs a lit.local.cfg file, like the others, that tests for 'PowerPC').

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

851

This can be isInt<32>(delta).

[pasaulais]

Thanks for looking at the patch.

I have added a llvm-rtdyld testcase for 'R_PPC_ADDR16_LO' and 'R_PPC_ADDR16_HA' relocation types. It seems to work on my VM by running the commands manually. I haven't got around to test it with 'lit' yet however, as I currently cross-compile LLVM outside of the VM.

I also removed the code for 'R_PPC_REL32' since it is not exercised by the test case. It will be part of another patch once I write a test case for it.

[kariddi]

PPC eh.... Interesting :D

Marcello

[hfinkel]

test/ExecutionEngine/RuntimeDyld/PowerPC/ppc32_elf_rel_addr16.ll

1

Why is this file here? If this is just the file that was used to create the initial .s file, don't add it.

[pasaulais]

Hi Hal,

Sorry for the long hiatus. I have removed the .ll file that was used to generate the assembyl file, and ran the test on a PPC VM:

• Testing: 1 tests, 1 threads --

PASS: LLVM :: ExecutionEngine/RuntimeDyld/PowerPC/ppc32_elf_rel_addr16.s (1 of 1)
Testing Time: 0.42s

Expected Passes    : 1

Do you see any other issue with the patch?

Thanks,
Pierre-Andre

[hfinkel]

LGTM, thanks!

[pasaulais]

Thanks, Hal. As I don't have commit access, could you commit it for me please?

[hfinkel]

r243991

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

void resolveAArch64Relocation(const SectionEntry &Section, uint64_t Offset,
                                 uint64_t Value, uint32_t Type, int64_t Addend);
 
   void resolveARMRelocation(const SectionEntry &Section, uint64_t Offset,
                             uint32_t Value, uint32_t Type, int32_t Addend);
 
   void resolveMIPSRelocation(const SectionEntry &Section, uint64_t Offset,
                              uint32_t Value, uint32_t Type, int32_t Addend);
 
+  void resolvePPC32Relocation(const SectionEntry &Section, uint64_t Offset,
+                              uint64_t Value, uint32_t Type, int64_t Addend);
+
   void resolvePPC64Relocation(const SectionEntry &Section, uint64_t Offset,
                               uint64_t Value, uint32_t Type, int64_t Addend);
 
   void resolveSystemZRelocation(const SectionEntry &Section, uint64_t Offset,
                                 uint64_t Value, uint32_t Type, int64_t Addend);
 
   void resolveMIPS64Relocation(const SectionEntry &Section, uint64_t Offset,
                                uint64_t Value, uint32_t Type, int64_t Addend,

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp

 static inline uint16_t applyPPChighest(uint64_t value) {
   return (value >> 48) & 0xffff;
 }
 
 static inline uint16_t applyPPChighesta (uint64_t value) {
   return ((value + 0x8000) >> 48) & 0xffff;
 }
 
+void RuntimeDyldELF::resolvePPC32Relocation(const SectionEntry &Section,
+                                            uint64_t Offset, uint64_t Value,
+                                            uint32_t Type, int64_t Addend) {
+  uint8_t *LocalAddress = Section.Address + Offset;
+  switch (Type) {
+  default:
+    llvm_unreachable("Relocation type not implemented yet!");
+    break;
+  case ELF::R_PPC_ADDR16_LO:
+    writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
+    break;
+  case ELF::R_PPC_ADDR16_HI:
+    writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
+    break;
+  case ELF::R_PPC_ADDR16_HA:
+    writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
+    break;
+  }
+}
+
 void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
                                             uint64_t Offset, uint64_t Value,
                                             uint32_t Type, int64_t Addend) {
   uint8_t *LocalAddress = Section.Address + Offset;
   switch (Type) {
   default:
     llvm_unreachable("Relocation type not implemented yet!");
     break;
   case ELF::R_PPC64_ADDR16:
if (IsMipsO32ABI)
       resolveMIPSRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL),
                             Type, (uint32_t)(Addend & 0xffffffffL));
     else if (IsMipsN64ABI)
       resolveMIPS64Relocation(Section, Offset, Value, Type, Addend, SymOffset,
                               SectionID);
     else
       llvm_unreachable("Mips ABI not handled");
     break;
+  case Triple::ppc:
+    resolvePPC32Relocation(Section, Offset, Value, Type, Addend);
+    break;
   case Triple::ppc64: // Fall through.
   case Triple::ppc64le:
     resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
     break;
   case Triple::systemz:
     resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
     break;
   default:

test/ExecutionEngine/RuntimeDyld/PowerPC/lit.local.cfg

+if not 'PPC' in config.root.targets:
+    config.unsupported = True
+

test/ExecutionEngine/RuntimeDyld/PowerPC/ppc32_elf_rel_addr16.ll

+; ModuleID = 'ppc32_elf_rel_addr16.ll'
+target datalayout = "E-m:e-p:32:32-i64:64-n32"
+target triple = "powerpc-unknown-linux-gnu"
+
+@elements = global [8 x i32] [i32 14, i32 4, i32 1, i32 3, i32 13, i32 0, i32 32, i32 334], align 4
+
+; Function Attrs: nounwind readonly
+define i32 @lookup(i32 %index) #0 {
+  %ptr = getelementptr inbounds [8 x i32], [8 x i32]* @elements, i32 0, i32 %index
+  %element = load i32, i32* %ptr, align 4
+  ret i32 %element
+}
+
+attributes #0 = { nounwind readonly "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="ppc" "target-features"="-crypto,-extdiv,-power8-vector,-altivec,-qpx,-bpermd,-direct-move" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.ident = !{!0}
+
+!0 = !{!"clang version 3.7.0 "}

test/ExecutionEngine/RuntimeDyld/PowerPC/ppc32_elf_rel_addr16.s

+# RUN: llvm-mc -triple=powerpc-unknown-linux-gnu -filetype=obj -o %T/ppc32_elf_rel_addr16.o %s
+# RUN: llvm-rtdyld -triple=powerpc-unknown-linux-gnu -verify -check=%s %T/ppc32_elf_rel_addr16.o
+  .text
+  .file "ppc32_elf_rel_addr16.ll"
+  .globl  lookup
+  .align  2
+  .type lookup,@function
+lookup:                                 # @lookup
+.Lfunc_begin0:
+# BB#0:
+  stw 31, -4(1)
+  stwu 1, -16(1)
+insn_hi:
+# Check the higher 16-bits of the symbol's absolute address
+# rtdyld-check: decode_operand(insn_hi, 1) = elements[31:16]
+  lis 4, elements@ha
+  slwi 3, 3, 2
+  mr 31, 1
+insn_lo:
+# Check the lower 16-bits of the symbol's absolute address
+# rtdyld-check: decode_operand(insn_lo, 2) = elements[15:0]
+  la 4, elements@l(4)
+  lwzx 3, 4, 3
+  addi 1, 1, 16
+  lwz 31, -4(1)
+  blr
+.Lfunc_end0:
+  .size lookup, .Lfunc_end0-.Lfunc_begin0
+
+  .type elements,@object        # @elements
+  .data
+  .globl  elements
+  .align  2
+elements:
+  .long 14                      # 0xe
+  .long 4                       # 0x4
+  .long 1                       # 0x1
+  .long 3                       # 0x3
+  .long 13                      # 0xd
+  .long 0                       # 0x0
+  .long 32                      # 0x20
+  .long 334                     # 0x14e
+  .size elements, 32
+
+
+  .ident  "clang version 3.7.0 "
+  .section  ".note.GNU-stack","",@progbits