[lld] Support dynamic linking in RISC-V

[PkmX]

Summary

This patch adds support for handling of PIC, generation of GOT/PLT and creation of PIE executables or DSO.

Some comments:

• It's currently missing the first entry of GOT which should be the address of .dynamic section. This seems to be the case for other targets as well, for example x86_64 ABI requires the address in .got so _GLOBAL_OFFSET_TABLE[0] == &_DYNAMIC but lld puts it in .got.plt instead. For now this doesn't appear to be used as well.
• RISC-V uses ADDN/SETN/SUBN relocation pairs to calculate differences of address in DWARF. This means that lld tries to create dynamic relocations for those while they are actually link-time constants as a pair, so we set those in RISCV::usesOnlyLowPageBits.

[ruiu]

ELF/Arch/RISCV.cpp

76–77 ↗

(On Diff #120368)

clang-format-diff please.

82–83 ↗

(On Diff #120368)

Use Config->Wordsize instead of sizeof(typename ELFT::uint);

107–111 ↗

(On Diff #120368)

I added a new file ELF/Bits.h. Please use writeUint and readUint defined in that file.

[ruiu]

ELF/Arch/RISCV.cpp

62–72 ↗

(On Diff #120542)

Since now we assume it is little-endian, we don't write it in a generic way. You can use just write32le and read32le.

I wonder if we even had to make this class a template class because the difference between RISCV64 and RISCV32 seem pretty small, and we can easily handle differences with Config->Is64.

[PkmX]

De-template RISCV class and assume little-endian.

[ruiu]

ELF/Arch/RISCV.cpp

110 ↗

(On Diff #120795)

Remove const

136–142 ↗

(On Diff #120795)

Please apply clang-format-diff.

ELF/Relocations.cpp

416–418 ↗

(On Diff #120795)

I think a better way of doing it is to define __global_pointer$ as a relative symbol in the first place. That's what we are doing for linker-synthesized symbols such as _etext or _edata. Please take a look at Writer.cpp.

[PkmX]

• Use write32le.
• Since __global_pointer$ is no longer absolute, remove workaround to make it a static link-time constant in PIE.

[PkmX]

clang-format-diff RISCV::writePLT.

[PkmX]

• Rebase onto latest master
• Clean up #includes

[PkmX]

Rebase onto latest master.

[PkmX]

Rebase onto master.

[PkmX]

Rebased.

RISCV now writes its own GOT header, with one entry that stores the address of .dynamic section. _GLOBAL_OFFSET_TABLE_ should be set to the head of .got so that _GLOBAL_OFFSET_TABLE_[0] == &_DYNAMIC.

[jrtc27]

This needs rebasing again as NoneRel = R_RISCV_NONE was added to the constructor. Otherwise, is there anything blocking this?

[ruiu]

Ditto -- if you can write tests in assembly, please convert them from YAML to assembly.

[PkmX]

In D39323#1280971, @ruiu wrote:

Ditto -- if you can write tests in assembly, please convert them from YAML to assembly.

LLVM RISC-V MC does not support generating PIC yet, so we can only use YAML at the moment.

[ruiu]

ELF/Arch/RISCV.cpp

33–43 ↗

(On Diff #158927)

Remove "virtual" for consistency. "override" implies it.

107 ↗

(On Diff #158927)

What is this field for? Perhaps a brief explanation of the structure of .got.plt header for RISC-V would be helpful for readers.

122 ↗

(On Diff #158927)

Side note: it is nice to see that many instructions for RISCV32 and RISCV64 are represented by the same bit pattern. I guess it's a beauty of the new clean ISA.

156 ↗

(On Diff #158927)

nit: indentation

[PkmX]

ELF/Arch/RISCV.cpp

107 ↗

(On Diff #158927)

It is a placeholder for the dynamic linker to fill with the address of _dl_runtime_resolve function. The content of .got.plt section is not explicitly described in the ABI spec, but you can sort of infer that from the PLT header:

https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#program-linkage-table

The first entry of .got.plt will be the address of _dl_runtime_resolve, and the second entry is the link map, passed as an argument to _dl_runtime_resolve. I don't think the initial values matter here, so I just take them from bfd's implementation: first entry is all ones and the second is all zeros.

[PkmX]

Rebased onto trunk.

[MaskRay]

ELF/Arch/RISCV.cpp

108 ↗

(On Diff #172307)

Verified the first entry is -1 set by bfd/elfnn-riscv.c

https://sourceware.org/git/?p=binutils-gdb.git;a=blob;hb=e8bf1ce461df242811e49de807f85c2e7ae17b77;f=bfd/elfnn-riscv.c#l2585

This was introduced in the initial import commit e23eba971dd409b999dd83d8df0f842680c1c642 , no history to help understand why -1 (a bit odd) was chosen.

In other bfd's other architectures and lld's (GotPltHeaderEntriesNum), _dl_runtime_resolve is 0 at link time.

115 ↗

(On Diff #172307)

The check if (ElfSym::GlobalOffsetTable) may be redundant.

[ruiu]

ELF/Arch/RISCV.cpp

107 ↗

(On Diff #158927)

We are trying to avoid cargo-culting and we should avoid writing values if the only reason to do so is to write the same value as ld.bfd. Let's just leave them as-is (i.e. leaving them as zero).

[jrtc27]

PkmX, any chance of addressing these points soon, please?

[jrtc27]

ELF/Arch/RISCV.cpp

115 ↗

(On Diff #172307)

If you want to write to the GOT header, you do need this guard (PPC64 doesn't, likely because of its TOCs and so the symbol is always used), as the GotSection constructor only adds GotHeaderEntriesNum to NumEntries if ElfSym::GlobalOffsetTable && !Target->GotBaseSymInGotPlt. Otherwise you risk clobbering the first GOT entry if it's a static link time constant.

However, I don't think we even need this header. BFD will emit this header on, for example, AArch64, if the GOT is non-empty (as will gold), but we never do this as far as I can tell. Thus unless RISC-V is special and the runtime really assumes this header entry is present, I think we should drop this header as it hasn't seemed to cause any problems with AArch64; we can always add it if we later find it necessary.

[ruiu]

ELF/Arch/RISCV.cpp

115 ↗

(On Diff #172307)

That' s a really good point. I remember at some point of the lld development, we wondered why we were adding this header even though it is not technically necessary. I turned out that we are doing it because the ABI standard requires it, but we couldn't find any technical reason to do so. Rafael wanted we stop adding this header because this is just a cargo-culting, but we decided to continue doing it for the sake of ABI compliance.

If you are defining a new ABI, I recommend you not blindly copy this header. I recommend you drop this header.

[MaskRay]

ELF/Arch/RISCV.cpp

115 ↗

(On Diff #172307)

Putting _GLOBAL_OFFSET_TABLE_[0] = _DYNAMIC in .got or .got.plt is a trick used by glibc/sysdeps/{aarch64,x86_64,riscv,...}/dl-machine.h.
It subtracts the link time address from the runtime time (usually relocated by a R_*_RELATIVE) to get the load address of ld.so

It seems to me a bit unnecessary that some old ABIs mandate the field as I think most userspace applications don't need this symbol.

[jrtc27]

ELF/Arch/RISCV.cpp

115 ↗

(On Diff #172307)

Ah, I see, it's needed when you're linking ld.so (and it uses the _GLOBAL_OFFSET_TABLE_ symbol as a variable containing a word, hence why we only do this when the symbol is referenced). So I guess we can't link glibc's ld.so on AArch64? If this is an issue affecting more than just RISC-V, I'd still be inclined to drop this from the patch, but then later fix both AArch64 and RISC-V (along with any other architectures also needing this) at the same time as a separate bug fix.

[jrtc27]

@PkmX Ping, any chance you could address the remaining few points, please?

[PkmX]

Rebased onto master and:

• Removed the GOT header per discussion
• Rewrote all tests in MC

[ruiu]

Overall looking good.

ELF/Arch/RISCV.cpp

116 ↗

(On Diff #194177)

It looks odd to me at first because you are setting the same value to all .got.plt slots. But I guess this is correct; jalr in .plt sets the return address to t3, so we can calculate a .plt index by t3 minus .plt start address. Nice. A little explanation would help readers understand this code, though.

121 ↗

(On Diff #194177)

Please use error() instead of fatal(). We use fatal() only to report corrupted files. After you report an error using error(), you can just return from this function.

[PkmX]

Addressed the review comments:

• Added comments to writeGotPlt.
• Use error instead of fatal when generating PLT on RV32E.

[ruiu]

LGTM

[lenary]

Am I correct in thinking that this functionality has already been upstreamed into LLD, and that this patch can now been abandoned?

[MaskRay]

In D39323#1631117, @lenary wrote:

Am I correct in thinking that this functionality has already been upstreamed into LLD, and that this patch can now been abandoned?

Yes, the functionality has already been upstreamed. I somehow forgot this one while I was doing that... Mainly D63076 (GOT,PLT,COPY,relative), D63220 (TLS) and a few other fixups.
The functionality should be pretty complete in the llvm 9 release: I built libc-test against glibc riscv64 and musl riscv64.

R_RISCV_RELAX/R_RISCV_ALIGN has not been implemented. There is some technical difficulty - shrinkable sections do not fit in lld's current framework. It can be implemented but generally I think R_RISCV_RELAX can have other problems... e.g. it breaks split dwarf, it disallows section symbols in object files, etc.

lld/ELF/Arch/RISCV.cpp

 //===- RISCV.cpp ----------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
+#include "Symbols.h"
+#include "SyntheticSections.h"
 #include "Target.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;
 
 namespace {
 
 class RISCV final : public TargetInfo {
 public:
   RISCV();
   uint32_t calcEFlags() const override;
   RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
+
+  void writeGotPltHeader(uint8_t *Buf) const override;
+  void writeGotPlt(uint8_t *Buf, const Symbol &S) const override;
+
+  void writePltHeader(uint8_t *Buf) const override;
+
+  void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
+                int32_t Index, unsigned RelOff) const override;
+
+  bool usesOnlyLowPageBits(RelType Type) const override;
 };
 
 } // end anonymous namespace
 
-RISCV::RISCV() { NoneRel = R_RISCV_NONE; }
+RISCV::RISCV() {
+  NoneRel = R_RISCV_NONE;
+  CopyRel = R_RISCV_COPY;
+  RelativeRel = R_RISCV_RELATIVE;
+  GotRel = Config->Is64 ? R_RISCV_64 : R_RISCV_32;
+  PltRel = R_RISCV_JUMP_SLOT;
+  GotEntrySize = Config->Wordsize;
+  GotPltEntrySize = Config->Wordsize;
+  PltEntrySize = 16;
+  PltHeaderSize = 32;
+  GotPltHeaderEntriesNum = 2;
+  GotBaseSymInGotPlt = false;
+}
 
 static uint32_t getEFlags(InputFile *F) {
   if (Config->Is64)
     return cast<ObjFile<ELF64LE>>(F)->getObj().getHeader()->e_flags;
   return cast<ObjFile<ELF32LE>>(F)->getObj().getHeader()->e_flags;
 }
 
 uint32_t RISCV::calcEFlags() const {
for (InputFile *F : ObjectFiles) {
     if ((EFlags & EF_RISCV_RVE) != (Target & EF_RISCV_RVE))
       error(toString(F) +
             ": cannot link object files with different EF_RISCV_RVE");
   }
 
   return Target;
 }
 
+bool RISCV::usesOnlyLowPageBits(RelType Type) const {
+  return Type == R_RISCV_LO12_I || Type == R_RISCV_PCREL_LO12_I ||
+         Type == R_RISCV_LO12_S || Type == R_RISCV_PCREL_LO12_S ||
+         // These are used in a pair to calculate relative address in debug
+         // sections, so they aren't really absolute. We list those here as a
+         // hack so the linker doesn't try to create dynamic relocations.
+         Type == R_RISCV_ADD8 || Type == R_RISCV_ADD16 ||
+         Type == R_RISCV_ADD32 || Type == R_RISCV_ADD64 ||
+         Type == R_RISCV_SUB8 || Type == R_RISCV_SUB16 ||
+         Type == R_RISCV_SUB32 || Type == R_RISCV_SUB64 ||
+         Type == R_RISCV_SUB6 ||
+         Type == R_RISCV_SET6 || Type == R_RISCV_SET8 ||
+         Type == R_RISCV_SET16 || Type == R_RISCV_SET32;
+}
+
+static void writeUint(uint8_t *Buf, uint64_t Val) {
+  if (Config->Is64)
+    write64(Buf, Val);
+  else
+    write32(Buf, Val);
+}
+
+void RISCV::writeGotPltHeader(uint8_t *Buf) const {
+  // These entries are used by the plt header and will be filled by the
+  // dynamic linker. Initalize both to zero at link time.
+  writeUint(Buf, 0);                   // _dl_runtime_resolve
+  writeUint(Buf + GotPltEntrySize, 0); // link_map
+}
+
+void RISCV::writeGotPlt(uint8_t *Buf, const Symbol &S) const {
+  // .got.plt is initialized with the address of the plt header, so the first
+  // time a plt function is called it will jump to the header, which computes
+  // the plt index by the difference between the return address and the start
+  // address of plt.
+  writeUint(Buf, In.Plt->getVA());
+}
+
+void RISCV::writePltHeader(uint8_t *Buf) const {
+  if (Config->EFlags & EF_RISCV_RVE) {
+    error("PLT is not supported with RVE ABI");
+    return;
+  }
+
+  uint64_t PcRelGotPlt = In.GotPlt->getVA() - In.Plt->getVA();
+
+  write32le(Buf + 0, 0x00000397);    // 1: auipc  t2, %pcrel_hi(.got.plt)
+  relocateOne(Buf + 0, R_RISCV_PCREL_HI20, PcRelGotPlt);
+  write32le(Buf + 4, 0x41c30333);    // sub    t1, t1, t3
+  if (Config->Is64) {
+    write32le(Buf + 8, 0x0003be03);  // ld     t3, %pcrel_lo(1b)(t2)
+  } else {
+    write32le(Buf + 8, 0x0003ae03);  // lw     t3, %pcrel_lo(1b)(t2)
+  }
+  relocateOne(Buf + 8, R_RISCV_PCREL_LO12_I, PcRelGotPlt);
+  write32le(Buf + 12, 0xfd430313);   // addi   t1, t1, -44
+  write32le(Buf + 16, 0x00038293);   // addi   t0, t2, %pcrel_lo(1b)
+  relocateOne(Buf + 16, R_RISCV_PCREL_LO12_I, PcRelGotPlt);
+  if (Config->Is64) {
+    write32le(Buf + 20, 0x00135313); // srli   t1, t1, 1
+    write32le(Buf + 24, 0x0082b283); // ld     t0, 8(t0)
+  } else {
+    write32le(Buf + 20, 0x00235313); // srli   t1, t1, 2
+    write32le(Buf + 24, 0x0042a283); // lw     t0, 4(t0)
+  }
+  write32le(Buf + 28, 0x000e0067);   // jr     t3
+}
+
+void RISCV::writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
+                     int32_t Index, unsigned RelOff) const {
+  if (Config->EFlags & EF_RISCV_RVE) {
+    error("PLT is not supported with RVE ABI");
+    return;
+  }
+
+  write32le(Buf + 0, 0x00000e17);   // auipc   t3, %pcrel_hi(f@.got.plt)
+  if (Config->Is64) {
+    write32le(Buf + 4, 0x000e3e03); // ld      t3, %pcrel_lo(-4)(t3)
+  } else {
+    write32le(Buf + 4, 0x000e2e03); // lw      t3, %pcrel_lo(-4)(t3)
+  }
+  write32le(Buf + 8, 0x000e0367);   // jalr    t1, t3
+  write32le(Buf + 12, 0x00000013);  // nop
+
+  relocateOne(Buf + 0, R_RISCV_PCREL_HI20, GotEntryAddr - PltEntryAddr);
+  relocateOne(Buf + 4, R_RISCV_PCREL_LO12_I, GotEntryAddr - PltEntryAddr);
+}
+
 RelExpr RISCV::getRelExpr(const RelType Type, const Symbol &S,
                           const uint8_t *Loc) const {
   switch (Type) {
   case R_RISCV_JAL:
   case R_RISCV_BRANCH:
   case R_RISCV_CALL:
   case R_RISCV_PCREL_HI20:
   case R_RISCV_RVC_BRANCH:
   case R_RISCV_RVC_JUMP:
   case R_RISCV_32_PCREL:
     return R_PC;
+  case R_RISCV_CALL_PLT:
+    return R_PLT_PC;
   case R_RISCV_PCREL_LO12_I:
   case R_RISCV_PCREL_LO12_S:
     return R_RISCV_PC_INDIRECT;
-  case R_RISCV_RELAX:
+  case R_RISCV_GOT_HI20:
+    return R_GOT_PC;
   case R_RISCV_ALIGN:
+  case R_RISCV_RELAX:
     return R_HINT;
   default:
     return R_ABS;
   }
 }
 
 // Extract bits V[Begin:End], where range is inclusive, and Begin must be < 63.
 static uint32_t extractBits(uint64_t V, uint32_t Begin, uint32_t End) {
case R_RISCV_BRANCH: {
     uint32_t Imm11 = extractBits(Val, 11, 11) << 7;
     Insn |= Imm12 | Imm10_5 | Imm4_1 | Imm11;
 
     write32le(Loc, Insn);
     return;
   }
 
   // auipc + jalr pair
+  case R_RISCV_CALL_PLT:
   case R_RISCV_CALL: {
     int64_t Hi = SignExtend64(Val + 0x800, Bits) >> 12;
     checkInt(Loc, Hi, 20, Type);
     if (isInt<20>(Hi)) {
       relocateOne(Loc, R_RISCV_PCREL_HI20, Val);
       relocateOne(Loc + 4, R_RISCV_PCREL_LO12_I, Val);
     }
     return;
   }
 
   case R_RISCV_PCREL_HI20:
+  case R_RISCV_GOT_HI20:
   case R_RISCV_HI20: {
     uint64_t Hi = Val + 0x800;
     checkInt(Loc, SignExtend64(Hi, Bits) >> 12, 20, Type);
     write32le(Loc, (read32le(Loc) & 0xFFF) | (Hi & 0xFFFFF000));
     return;
   }
 
   case R_RISCV_PCREL_LO12_I:

lld/ELF/InputSection.cpp

static Relocation *getRISCVPCRelHi20(const Symbol *Sym, uint64_t Addend) {
   R.Offset = D->Value;
   auto Range =
       std::equal_range(IS->Relocations.begin(), IS->Relocations.end(), R,
                        [](const Relocation &LHS, const Relocation &RHS) {
                          return LHS.Offset < RHS.Offset;
                        });
 
   for (auto It = Range.first; It != Range.second; ++It)
-    if (It->Expr == R_PC)
+    if (It->Expr == R_PC || It->Expr == R_PLT_PC || It->Expr == R_GOT_PC)
       return &*It;
 
   error("R_RISCV_PCREL_LO12 relocation points to " + IS->getObjMsg(D->Value) +
         " without an associated R_RISCV_PCREL_HI20 relocation");
   return nullptr;
 }
 
 // A TLS symbol's virtual address is relative to the TLS segment. Add a

lld/ELF/Relocations.cpp

return oneof<R_GOT, R_GOT_OFF, R_HEXAGON_GOT, R_MIPS_GOT_LOCAL_PAGE,
                R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_AARCH64_GOT_PAGE_PC,
                R_GOT_PC, R_GOTPLT>(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 oneof<R_PC, R_GOTREL, R_GOTPLTREL, R_MIPS_GOTREL, R_PPC_CALL,
-               R_PPC_CALL_PLT, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC>(Expr);
+               R_PPC_CALL_PLT, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC,
+               R_RISCV_PC_INDIRECT>(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.

lld/test/ELF/Inputs/riscv-shared.s

+.global f
+.type f, @function
+f:
+
+.data
+.global x
+.type x, @object
+.size x, 4
+x:
+    .word 42

lld/test/ELF/riscv-copy.s

+# REQUIRES: riscv
+
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=-relax %s -o %t.rv32.o
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=-relax -position-independent %p/Inputs/riscv-shared.s -o %t.shared.rv32.o
+# RUN: ld.lld -shared %t.shared.rv32.o -o %t.shared.rv32.so
+# RUN: ld.lld %t.rv32.o %t.shared.rv32.so -o %t.rv32
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64-unknown-elf -mattr=-relax %s -o %t.rv64.o
+# RUN: llvm-mc -filetype=obj -triple=riscv64-unknown-elf -mattr=-relax -position-independent %p/Inputs/riscv-shared.s -o %t.shared.rv64.o
+# RUN: ld.lld -shared %t.shared.rv64.o -o %t.shared.rv64.so
+# RUN: ld.lld %t.rv64.o %t.shared.rv64.so -o %t.rv64
+
+# RUN: llvm-readobj -dyn-relocations %t.rv32 | FileCheck %s
+# RUN: llvm-readobj -dyn-relocations %t.rv64 | FileCheck %s
+# CHECK:       Dynamic Relocations {
+# CHECK-NEXT:    0x{{[0-9a-f]+}} R_RISCV_COPY x 0x0
+# CHECK-NEXT:  }
+
+.global _start
+_start:
+    la   a0, x

lld/test/ELF/riscv-fpic-got.s

+# REQUIRES: riscv
+
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=-relax -position-independent %s -o %t.rv32.o
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=-relax -position-independent %p/Inputs/riscv-shared.s -o %t.shared.rv32.o
+# RUN: ld.lld -shared %t.shared.rv32.o -o %t.shared.rv32.so
+# RUN: ld.lld %t.rv32.o %t.shared.rv32.so -o %t.rv32
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64-unknown-elf -mattr=-relax -position-independent %s -o %t.rv64.o
+# RUN: llvm-mc -filetype=obj -triple=riscv64-unknown-elf -mattr=-relax -position-independent %p/Inputs/riscv-shared.s -o %t.shared.rv64.o
+# RUN: ld.lld -shared %t.shared.rv64.o -o %t.shared.rv64.so
+# RUN: ld.lld %t.rv64.o %t.shared.rv64.so -o %t.rv64
+
+# RUN: llvm-readobj -sections -dyn-relocations -dyn-symbols %t.rv32 | FileCheck -DXLEN=32 %s
+# RUN: llvm-readobj -sections -dyn-relocations -dyn-symbols %t.rv64 | FileCheck -DXLEN=64 %s
+# CHECK:       Section {
+# CHECK:         Name: .got
+# CHECK:         Address: [[GOT:0x[0-9A-F]+]]
+# CHECK:       }
+
+# CHECK:       Dynamic Relocations {
+# CHECK-NEXT:    [[GOT]] R_RISCV_[[XLEN]] x 0x0
+# CHECK-NEXT:  }
+
+# CHECK:       DynamicSymbols [
+# CHECK:         Name: x
+
+# RUN: llvm-objdump -d %t.rv32 | FileCheck --check-prefix=DISASM32 %s
+# _start = 0x11000, .got = 0x12060
+# DISASM32:      auipc   a0, 1
+# DISASM32-NEXT: lw      a0, 96(a0)
+
+# RUN: llvm-objdump -d %t.rv64 | FileCheck --check-prefix=DISASM64 %s
+# _start = 0x11000, .got = 0x120c0
+# DISASM64:      auipc   a0, 1
+# DISASM64-NEXT: ld      a0, 192(a0)
+
+.global _start
+_start:
+    la   a0, x

lld/test/ELF/riscv-fpic-pie.s

+# REQUIRES: riscv
+
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=-relax -position-independent %s -o %t.rv32.o
+# RUN: ld.lld -pie -Ttext=0x1000 %t.rv32.o -o %t.rv32
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64-unknown-elf -mattr=-relax -position-independent %s -o %t.rv64.o
+# RUN: ld.lld -pie -Ttext=0x1000 %t.rv64.o -o %t.rv64
+
+# RUN: llvm-readobj -sections -dyn-relocations %t.rv32 | FileCheck %s
+# RUN: llvm-readobj -sections -dyn-relocations %t.rv64 | FileCheck %s
+# CHECK:       Section {
+# CHECK:         Name: .got
+# CHECK:         Address: [[GOT:0x[0-9A-F]+]]
+# CHECK:       }
+
+# CHECK:       Dynamic Relocations {
+# CHECK-NEXT:    [[GOT]] R_RISCV_RELATIVE - 0x1000
+# CHECK-NEXT:  }
+
+# RUN: llvm-objdump -d %t.rv32 | FileCheck --check-prefix=DISASM32 %s
+# _start = 0x1000, .got = 0x3060
+# DISASM32:      auipc   a0, 2
+# DISASM32-NEXT: lw      a0, 96(a0)
+
+# RUN: llvm-objdump -d %t.rv64 | FileCheck --check-prefix=DISASM64 %s
+# _start = 0x1000, .got = 0x30c0
+# DISASM64:      auipc   a0, 2
+# DISASM64-NEXT: ld      a0, 192(a0)
+
+.global _start
+_start:
+    la   a0, _start

lld/test/ELF/riscv-fpic-plt.s

+# REQUIRES: riscv
+
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=-relax -position-independent %s -o %t.rv32.o
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=-relax -position-independent %p/Inputs/riscv-shared.s -o %t.shared.rv32.o
+# RUN: ld.lld -shared %t.shared.rv32.o -o %t.shared.rv32.so
+# RUN: ld.lld %t.rv32.o %t.shared.rv32.so -o %t.rv32
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64-unknown-elf -mattr=-relax -position-independent %s -o %t.rv64.o
+# RUN: llvm-mc -filetype=obj -triple=riscv64-unknown-elf -mattr=-relax -position-independent %p/Inputs/riscv-shared.s -o %t.shared.rv64.o
+# RUN: ld.lld -shared %t.shared.rv64.o -o %t.shared.rv64.so
+# RUN: ld.lld %t.rv64.o %t.shared.rv64.so -o %t.rv64
+
+# RUN: llvm-readobj -dyn-relocations -dyn-symbols %t.rv32 | FileCheck %s
+# RUN: llvm-readobj -dyn-relocations -dyn-symbols %t.rv64 | FileCheck %s
+# CHECK:       Dynamic Relocations {
+# CHECK-NEXT:    0x{{[0-9A-F]+}} R_RISCV_JUMP_SLOT f 0x0
+# CHECK-NEXT:  }
+
+# CHECK:       DynamicSymbols [
+# CHECK:         Name: f
+
+# RUN: llvm-objdump -d %t.rv32 | FileCheck --check-prefix=DIS %s
+# RUN: llvm-objdump -d %t.rv64 | FileCheck --check-prefix=DIS %s
+# _start = 0x11000, f@plt = 0x11030
+# DIS:      _start:
+# DIS-NEXT:  auipc   ra, 0
+# DIS-NEXT:  jalr    ra, ra, 48
+
+# RUN: llvm-objdump -d -j.plt %t.rv32 | FileCheck --check-prefix=PLT32 %s
+# .plt = 0x11010, .got.plt = 0x13000
+# PLT32:      11010 .plt:
+# PLT32-NEXT: auipc   t2, 2
+# PLT32-NEXT: sub     t1, t1, t3
+# PLT32-NEXT: lw      t3, -16(t2)
+# PLT32-NEXT: addi    t1, t1, -44
+# PLT32-NEXT: addi    t0, t2, -16
+# PLT32-NEXT: srli    t1, t1, 2
+# PLT32-NEXT: lw      t0, 4(t0)
+# PLT32-NEXT: jr      t3
+# f@plt = 0x11030, f = 0x13008
+# PLT32-NEXT: auipc   t3, 2
+# PLT32-NEXT: lw      t3, -40(t3)
+# PLT32-NEXT: jalr    t1, t3, 0
+# PLT32-NEXT: nop
+
+# RUN: llvm-objdump -d -j.plt %t.rv64 | FileCheck --check-prefix=PLT64 %s
+# .plt = 0x11010, .got.plt = 0x13000
+# PLT64:      11010 .plt:
+# PLT64-NEXT: auipc   t2, 2
+# PLT64-NEXT: sub     t1, t1, t3
+# PLT64-NEXT: ld      t3, -16(t2)
+# PLT64-NEXT: addi    t1, t1, -44
+# PLT64-NEXT: addi    t0, t2, -16
+# PLT64-NEXT: srli    t1, t1, 1
+# PLT64-NEXT: ld      t0, 8(t0)
+# PLT64-NEXT: jr      t3
+# f@plt = 0x11030, f = 0x13010
+# PLT64-NEXT: auipc   t3, 2
+# PLT64-NEXT: ld      t3, -32(t3)
+# PLT64-NEXT: jalr    t1, t3, 0
+# PLT64-NEXT: nop
+
+# RUN: llvm-objdump -s -j.got.plt %t.rv32 | FileCheck --check-prefix=GOTPLT32 %s
+# .plt = 0x00011010
+# GOTPLT32:      Contents of section .got.plt:
+# GOTPLT32-NEXT:  13000 00000000 00000000 10100100
+
+# RUN: llvm-objdump -s -j.got.plt %t.rv64 | FileCheck --check-prefix=GOTPLT64 %s
+# .plt = 0x0000000000011010
+# GOTPLT64:      Contents of section .got.plt:
+# GOTPLT64-NEXT:  13000 00000000 00000000 00000000 00000000
+# GOTPLT64-NEXT:  13010 10100100 00000000
+
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=+e,-relax -position-independent %s -o %t.rv32e.o
+# RUN: llvm-mc -filetype=obj -triple=riscv32-unknown-elf -mattr=+e,-relax -position-independent %p/Inputs/riscv-shared.s -o %t.shared.rv32e.o
+# RUN: ld.lld -shared %t.shared.rv32e.o -o %t.shared.rv32e.so
+# RUN: not ld.lld %t.rv32e.o %t.shared.rv32e.so -o %t.rv32e 2>&1 | FileCheck --check-prefix=RV32E %s
+# RV32E: error: PLT is not supported with RVE ABI
+
+.global _start
+_start:
+    call f@plt