Add support for GOT relocation support to Hexagon

[sidneym]

Summary

Add support for R_HEX_GOT_11_X/R_HEX_GOT_32_6_X.
Create a new relocation expression, HEXAGON_GOT to handle the got offset calculation.

[ruiu]

ELF/InputSection.cpp

549 ↗

(On Diff #167815)

You are not using A nor P, so this expression is a constant. Is this code correct?

[sidneym]

ELF/InputSection.cpp

549 ↗

(On Diff #167815)

The ABI describes the added relocations (type G) as the, "offset into global offset table for the entry of a symbol". Access to the symbol starts first by getting the base of the global offset table,
r2=add(pc,_GLOBAL_OFFSET_TABLE_@PCREL) Then the entry: r0 = memw (r2+bar@GOT)

The immediate ##bar@GOT is calculated as Sym.getGotVA() - In.GotPLT->getVA(). I checked this with some existing hexagon code and everything seemed ok.

[ruiu]

Can you share the pointer to the ABI documentation?

[sidneym]

This is the link:
https://developer.qualcomm.com/download/hexagon/hexagon-application-binary-interface-specification.zip

There is a click-thru sign-in that is required to get to the document. I could not find a copy that was otherwise accessible.

[ruiu]

I need to contact a legal team before downloading the PDF since it requires me to agree with a Terms of Use to download it. I'll get back to you.

[ruiu]

OK, so looks like I cannot agree with the Terms of Use to download the spec. The exact words of the Terms of Use doesn't matter (though I'm not a lawyer), but in general, you cannot require a maintainer to sign a random legal document only to review your patch. Please consider consulting your legal team to make the spec publicly available if you can.

That said, fortunately, the only part I don't understand without the spec is the necessity of R_HEXAGON_GOT relocation type, and as per your explanation, I believe your patch is correct. So, LGTM. Please go ahead and submit.

But again, please consider contacting your legal team to publish the documentation. That makes my life as a maintainer much easier. Thanks!

lld/trunk/ELF/Arch/Hexagon.cpp

public:
   void writePlt(uint8_t *Buf, uint64_t GotPltEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
 };
 } // namespace
 
 Hexagon::Hexagon() {
   PltRel = R_HEX_JMP_SLOT;
   RelativeRel = R_HEX_RELATIVE;
+  GotRel = R_HEX_GLOB_DAT;
+  GotEntrySize = 4;
+  // The zero'th GOT entry is reserved for the address of _DYNAMIC.  The
+  // next 3 are reserved for the dynamic loader.
+  GotPltHeaderEntriesNum = 4;
+  GotPltEntrySize = 4;
+
   PltEntrySize = 16;
   PltHeaderSize = 32;
 
   // Hexagon Linux uses 64K pages by default.
   DefaultMaxPageSize = 0x10000;
   NoneRel = R_HEX_NONE;
 }
 
RelExpr Hexagon::getRelExpr(RelType Type, const Symbol &S,
   case R_HEX_6_PCREL_X:
   case R_HEX_32_PCREL:
     return R_PC;
   case R_HEX_B22_PCREL:
   case R_HEX_PLT_B22_PCREL:
   case R_HEX_B22_PCREL_X:
   case R_HEX_B32_PCREL_X:
     return R_PLT_PC;
+  case R_HEX_GOT_11_X:
+  case R_HEX_GOT_32_6_X:
+    return R_HEXAGON_GOT;
   default:
     return R_ABS;
   }
 }
 
 static uint32_t findMaskR6(uint32_t Insn) {
   // There are (arguably too) many relocation masks for the DSP's
   // R_HEX_6_X type.  The table below is used to select the correct mask
case R_HEX_8_X:
     break;
   case R_HEX_9_X:
     or32le(Loc, applyMask(0x00003fe0, Val & 0x3f));
     break;
   case R_HEX_10_X:
     or32le(Loc, applyMask(0x00203fe0, Val & 0x3f));
     break;
   case R_HEX_11_X:
+  case R_HEX_GOT_11_X:
     or32le(Loc, applyMask(findMaskR11(read32le(Loc)), Val & 0x3f));
     break;
   case R_HEX_12_X:
     or32le(Loc, applyMask(0x000007e0, Val));
     break;
   case R_HEX_16_X: // This reloc only has 6 effective bits.
     or32le(Loc, applyMask(findMaskR16(read32le(Loc)), Val & 0x3f));
     break;
   case R_HEX_32:
   case R_HEX_32_PCREL:
     or32le(Loc, Val);
     break;
   case R_HEX_32_6_X:
+  case R_HEX_GOT_32_6_X:
     or32le(Loc, applyMask(0x0fff3fff, Val >> 6));
     break;
   case R_HEX_B9_PCREL:
     or32le(Loc, applyMask(0x003000fe, Val >> 2));
     break;
   case R_HEX_B9_PCREL_X:
     or32le(Loc, applyMask(0x003000fe, Val & 0x3f));
     break;

lld/trunk/ELF/InputSection.cpp

static uint64_t getRelocTargetVA(const InputFile *File, RelType Type, int64_t A,
   case R_RELAX_TLS_GD_TO_IE_GOT_OFF:
     return Sym.getGotOffset() + A;
   case R_GOT_PAGE_PC:
   case R_RELAX_TLS_GD_TO_IE_PAGE_PC:
     return getAArch64Page(Sym.getGotVA() + A) - getAArch64Page(P);
   case R_GOT_PC:
   case R_RELAX_TLS_GD_TO_IE:
     return Sym.getGotVA() + A - P;
+  case R_HEXAGON_GOT:
+    return Sym.getGotVA() - In.GotPlt->getVA();
   case R_MIPS_GOTREL:
     return Sym.getVA(A) - In.MipsGot->getGp(File);
   case R_MIPS_GOT_GP:
     return In.MipsGot->getGp(File) + A;
   case R_MIPS_GOT_GP_PC: {
     // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target
     // is _gp_disp symbol. In that case we should use the following
     // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at

lld/trunk/ELF/Relocations.h

enum RelExpr {
   R_GOTONLY_PC,
   R_GOTONLY_PC_FROM_END,
   R_GOTREL,
   R_GOTREL_FROM_END,
   R_GOT_FROM_END,
   R_GOT_OFF,
   R_GOT_PAGE_PC,
   R_GOT_PC,
+  R_HEXAGON_GOT,
   R_HINT,
   R_MIPS_GOTREL,
   R_MIPS_GOT_GP,
   R_MIPS_GOT_GP_PC,
   R_MIPS_GOT_LOCAL_PAGE,
   R_MIPS_GOT_OFF,
   R_MIPS_GOT_OFF32,
   R_MIPS_TLSGD,

lld/trunk/ELF/Relocations.cpp

 static bool needsPlt(RelExpr Expr) {
   return isRelExprOneOf<R_PLT_PC, R_PPC_CALL_PLT, R_PLT, R_PLT_PAGE_PC>(Expr);
 }
 
 // Returns true if Expr refers a GOT entry. Note that this function
 // returns false for TLS variables even though they need GOT, because
 // TLS variables uses GOT differently than the regular variables.
 static bool needsGot(RelExpr Expr) {
-  return isRelExprOneOf<R_GOT, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOT_OFF,
-                        R_MIPS_GOT_OFF32, R_GOT_PAGE_PC, R_GOT_PC,
-                        R_GOT_FROM_END>(Expr);
+  return isRelExprOneOf<R_GOT, R_GOT_OFF, R_HEXAGON_GOT, R_MIPS_GOT_LOCAL_PAGE,
+                        R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_GOT_PAGE_PC,
+                        R_GOT_PC, R_GOT_FROM_END>(Expr);
 }
 
 // True if this expression is of the form Sym - X, where X is a position in the
 // file (PC, or GOT for example).
 static bool isRelExpr(RelExpr Expr) {
   return isRelExprOneOf<R_PC, R_GOTREL, R_GOTREL_FROM_END, R_MIPS_GOTREL,
                         R_PPC_CALL, R_PPC_CALL_PLT, R_PAGE_PC,
                         R_RELAX_GOT_PC>(Expr);
 }
 
 // Returns true if a given relocation can be computed at link-time.
 //
 // For instance, we know the offset from a relocation to its target at
 // link-time if the relocation is PC-relative and refers a
 // non-interposable function in the same executable. This function
 // will return true for such relocation.
 //
 // If this function returns false, that means we need to emit a
 // dynamic relocation so that the relocation will be fixed at load-time.
 static bool isStaticLinkTimeConstant(RelExpr E, RelType Type, const Symbol &Sym,
                                      InputSectionBase &S, uint64_t RelOff) {
   // These expressions always compute a constant
   if (isRelExprOneOf<
-          R_GOT_FROM_END, R_GOT_OFF, R_TLSLD_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE,
-          R_MIPS_GOTREL, R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC,
-          R_MIPS_TLSGD, R_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC,
-          R_GOTONLY_PC_FROM_END, R_PLT_PC, R_TLSGD_GOT, R_TLSGD_GOT_FROM_END,
-          R_TLSGD_PC, R_PPC_CALL_PLT, R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT,
-          R_TLSLD_HINT, R_TLSIE_HINT>(E))
+          R_GOT_FROM_END, R_GOT_OFF, R_HEXAGON_GOT, R_TLSLD_GOT_OFF,
+          R_MIPS_GOT_LOCAL_PAGE, R_MIPS_GOTREL, R_MIPS_GOT_OFF,
+          R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC, R_MIPS_TLSGD, R_GOT_PAGE_PC,
+          R_GOT_PC, R_GOTONLY_PC, R_GOTONLY_PC_FROM_END, R_PLT_PC, R_TLSGD_GOT,
+          R_TLSGD_GOT_FROM_END, R_TLSGD_PC, R_PPC_CALL_PLT, R_TLSDESC_CALL,
+          R_TLSDESC_PAGE, R_HINT, R_TLSLD_HINT, R_TLSIE_HINT>(E))
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
 
   if (Sym.IsPreemptible)

lld/trunk/test/ELF/hexagon-shared.s

 # REQUIRES: hexagon
 # RUN: llvm-mc -filetype=obj -triple=hexagon-unknown-elf %s -o %t
 # RUN: llvm-mc -filetype=obj -triple=hexagon-unknown-elf %S/Inputs/hexagon-shared.s -o %t2.o
 # RUN: ld.lld -shared %t2.o -soname %t3.so -o %t3.so
 # RUN: ld.lld -shared %t %t3.so -soname %t4.so -o %t4.so
-# RUN: llvm-objdump -d -j=.plt %t4.so | FileCheck --check-prefix=PLT %s
-# RUN: llvm-objdump -d -j=.text %t4.so | FileCheck --check-prefix=TEXT %s
+# RUN: llvm-objdump -d -j .plt %t4.so | FileCheck --check-prefix=PLT %s
+# RUN: llvm-objdump -d -j .text %t4.so | FileCheck --check-prefix=TEXT %s
+# RUN: llvm-objdump -D -j .got %t4.so | FileCheck --check-prefix=GOT %s
 
 .global foo
 foo:
+
 # _HEX_32_PCREL
 .word _DYNAMIC - .
 call ##bar
+
 # R_HEX_PLT_B22_PCREL
 call bar@PLT
 
+# R_HEX_GOT_11_X and R_HEX_GOT_32_6_X
+r2=add(pc,##_GLOBAL_OFFSET_TABLE_@PCREL)
+r0 = memw (r2+##bar@GOT)
+jumpr r0
+
 # PLT: { immext(#65472
-# PLT: r28 = add(pc,##65520) }
+# PLT: r28 = add(pc,##65488) }
 # PLT: { r14 -= add(r28,#16)
 # PLT: r15 = memw(r28+#8)
 # PLT: r28 = memw(r28+#4) }
 # PLT: { r14 = asr(r14,#2)
 # PLT: jumpr r28 }
 # PLT: { trap0(#219) }
 # PLT: immext(#65472)
-# PLT: r14 = add(pc,##65488) }
+# PLT: r14 = add(pc,##65472) }
 # PLT: r28 = memw(r14+#0) }
 # PLT: jumpr r28 }
 
-# TEXT:  10000: 00 00 01 00 00010000
-# TEXT: {   call 0x10030 }
+# TEXT:  10000: 00 00 02 00 00020000
+# TEXT: {   call 0x10050 }
+
+# GOT: .got:
+# GOT: 30080: 00 00 00 00 00000000 <unknown>