[RISCV][LLD] Support R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128

[kito-cheng]

Summary

Support for the uleb128 related relocation[1].

R_RISCV_SET_ULEB128 should defer the relocation until
R_RISCV_SUB_ULEB128 appear since the symbol address of
R_RISCV_SET_ULEB128 might not fit the space of the current ULEB128
value, e.g. current ULEB128 value occupy 2 byte only, but the address of symbol
might not fit in 2 byte, it only fit for the address difference of
R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.

R_RISCV_SUB_ULEB128 must come after R_RISCV_SET_ULEB128, and rely value
of previous R_RISCV_SET_ULEB128 relocation.

[1] https://github.com/riscv-non-isa/riscv-elf-psabi-doc/pull/361

[kito-cheng]

NOTE: psABI spec has merged and binutils support also merged into trunk.

[kito-cheng]

Seem like I need to add at least one test case.

[kito-cheng]

Changes:

• add testcase.

[asb]

Just cross-linking to https://github.com/llvm/llvm-project/issues/64102 - as we discussed at the last RISC-V LLVM sync-up we really would like to land this and get it into the LLVM 17 branch if possible, to avoid compatibility issues with the next binutils release.

[MaskRay]

In D142880#4534918, @asb wrote:

Just cross-linking to https://github.com/llvm/llvm-project/issues/64102 - as we discussed at the last RISC-V LLVM sync-up we really would like to land this and get it into the LLVM 17 branch if possible, to avoid compatibility issues with the next binutils release.

I'll go on a trip and may be slow to respond. I'll do my best and I think there is still plenty of time.

[raj.khem]

In D142880#4534918, @asb wrote:

Just cross-linking to https://github.com/llvm/llvm-project/issues/64102 - as we discussed at the last RISC-V LLVM sync-up we really would like to land this and get it into the LLVM 17 branch if possible, to avoid compatibility issues with the next binutils release.

For cross reference. this review https://reviews.llvm.org/D142879 also needs to land together with this.

[raj.khem]

In D142880#4537432, @raj.khem wrote:

In D142880#4534918, @asb wrote:

Just cross-linking to https://github.com/llvm/llvm-project/issues/64102 - as we discussed at the last RISC-V LLVM sync-up we really would like to land this and get it into the LLVM 17 branch if possible, to avoid compatibility issues with the next binutils release.

For cross reference. this review https://reviews.llvm.org/D142879 also needs to land together with this.

I tried the existing patches as such on top 17.x branch and it crashes lld

| 0  libLLVM-17.so            0x00007f1bef819be4 llvm::sys::RunSignalHandlers() + 52
| 1  libLLVM-17.so            0x00007f1bef819d56
| 2  libc.so.6                0x00007f1bee65b6e0
| 3  riscv64-yoe-linux-ld.lld 0x00005595e8159d5e lld::elf::Symbol::getVA(long) const + 30
| 4  riscv64-yoe-linux-ld.lld 0x00005595e8214dd1
| 5  riscv64-yoe-linux-ld.lld 0x00005595e81081be void lld::elf::InputSection::relocateNonAlloc<llvm::object::ELFType<(llvm::support::endianness)1, true>, llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true>, true>>(unsigned char*, llvm::ArrayRef<llvm::object::Elf_Rel_Impl<llvm::object::ELFType<(llvm::support::endianness)1, true>, true>>) + 1886
| 6  riscv64-yoe-linux-ld.lld 0x00005595e813b5a3
| 7  libLLVM-17.so            0x00007f1bef785fd6
| 8  libLLVM-17.so            0x00007f1bef786b84
| 9  libstdc++.so.6           0x00007f1bee8df5e3
| 10 libc.so.6                0x00007f1bee6a5d63
| 11 libc.so.6                0x00007f1bee7247e0
| riscv64-yoe-linux-clang: error: unable to execute command: Segmentation fault (core dumped)
|

[kito-cheng]

@raj.khem ooops, thanks for report that, I am happy to debug that, so...it would be appreciate if you can provide files by -Wl,--reproduce=xx.tar :)

[kito-cheng]

Chagnes:

• Rebase and update testcase

[raj.khem]

In D142880#4538652, @kito-cheng wrote:

@raj.khem ooops, thanks for report that, I am happy to debug that, so...it would be appreciate if you can provide files by -Wl,--reproduce=xx.tar :)

@kito-cheng here is a reproducer from sed, the same crash is happening in lot of packages.

https://uclibc.org/~kraj/test.zip

There is a script called doit.sh inside the zip file which has the lld cmdline to reproduce the crash.

[jrtc27]

• What about relocations in non-SHF_ALLOC sections? Surely that can happen for debug info?

• Test has no coverage of errors

lld/ELF/Arch/RISCV.cpp

112–114

This doesn't make grammatical sense. Please rewrite this to be in the style of elf::reportRangeError; I'd like to see it print something like:

error: foo.o+0x1234: ULEB128 difference relocation pair overflow: 5 bytes needed but only 4 bytes allocated; references 'foo' - 'bar'
>>> 'foo' defined in foo.o
>>> 'bar' defined in bar.o
>>> referenced by bar.c:12
>>>               bar.o:(.baz+0x4)

and I guess also with the -fdebug-types-section message. reportRangeError does a lot of useful things, it would be a shame to deviate from that and lose the information.

333

config->wordsize * 8;

339

Why not just keep a pointer to the relocation around instead?

355

Why do you actually need to enforce this? So long as the SET/SUB pairs are adjacent it's fine

365

There are two cases this handles:

1. a SUB with no preceding SET
2. a SUB with a different preceding SET

This error isn't really correct. What you want to say is that you've found a SUB which is not, when looking at solely ULEB128 relocations, directly preceded by its corresponding SET.

371

What if this walks off the end of the buffer? It's an obscure edge case but could happen if you have a too-small buffer at the end of the file. Then we'll crash rather than catch the error early. Check getULEB128Size first.

[kito-cheng]

I am cooking some better way to resolve this, relocateNonAlloc case is harder to handle than I think.

Some ideas I tried:

• Introduce global variable to record prev relocation, binutils implementation this trick, but I know it's bad idea in lld, so I am not plan to going this way.
• Did ULEB128 relocation at elf::riscvFinalizeRelax, which will cause performance issue, more memory usage...and also kind of layer violation, I have workable patch for this, but I don't think it's acceptable (I won't accept that if I am reviewer too...:P)
• Pass pointer to Relocation rather than reference for TargetInfo::relocate(), so that I can get last relocation *in theory*, but I found it not work since relocateNoSym will pass local variable...
• Introduce new API into TargetInfo: TargetInfo::relocatePair(), I am working on this approach now, just need few more time to cook to patch, I guess this should be better than above approach.

[kito-cheng]

Changes:

• Rewrite in different way - introduce R_RELOCATE_PAIR_FIRST and R_RELOCATE_PAIR_SECOND.
• Add testcases to cover negative test and ULEB128 relocations in non-alloc section.

[aaronpuchert]

This comment was removed by aaronpuchert.

lld/ELF/Arch/RISCV.cpp

public:
   void writePltHeader(uint8_t *buf) const override;
   void writePlt(uint8_t *buf, const Symbol &sym,
                 uint64_t pltEntryAddr) const override;
   RelType getDynRel(RelType type) const override;
   RelExpr getRelExpr(RelType type, const Symbol &s,
                      const uint8_t *loc) const override;
   void relocate(uint8_t *loc, const Relocation &rel,
                 uint64_t val) const override;
+  void relocatePair(uint8_t *loc, const Relocation &relA, uint64_t valA,
+                    const Relocation &relB, uint64_t valB) const override;
   bool relaxOnce(int pass) const override;
 };
 
 } // end anonymous namespace
 
 // These are internal relocation numbers for GP relaxation. They aren't part
 // of the psABI spec.
 #define INTERNAL_R_RISCV_GPREL_I 256

 static uint32_t setLO12_I(uint32_t insn, uint32_t imm) {
   return (insn & 0xfffff) | (imm << 20);
 }
 static uint32_t setLO12_S(uint32_t insn, uint32_t imm) {
   return (insn & 0x1fff07f) | (extractBits(imm, 11, 5) << 25) |
          (extractBits(imm, 4, 0) << 7);
 }
 
+static void reportULEB128LengthExtend(uint8_t *loc, const RelType type,
+                                      Symbol &setSymbol, Symbol &subSymbol,
+                                      unsigned oldLength, unsigned newLength) {
+  ErrorPlace errPlace = getErrorPlace(loc);
+  error(errPlace.loc + "ULEB128 difference relocation pair overflow: " +
+        Twine(newLength) + " bytes needed but only " + Twine(oldLength) +
+        " bytes allocated; references '" + toString(setSymbol) + "' - '" +
+        toString(subSymbol) + "'");
+}
+
 RISCV::RISCV() {
   copyRel = R_RISCV_COPY;
   pltRel = R_RISCV_JUMP_SLOT;
   relativeRel = R_RISCV_RELATIVE;
   iRelativeRel = R_RISCV_IRELATIVE;
   if (config->is64) {
     symbolicRel = R_RISCV_64;
     tlsModuleIndexRel = R_RISCV_TLS_DTPMOD64;
RelExpr RISCV::getRelExpr(const RelType type, const Symbol &s,
   case R_RISCV_SET16:
   case R_RISCV_SET32:
   case R_RISCV_SUB6:
   case R_RISCV_SUB8:
   case R_RISCV_SUB16:
   case R_RISCV_SUB32:
   case R_RISCV_SUB64:
     return R_RISCV_ADD;
+  case R_RISCV_SET_ULEB128:
+    return R_RELOCATE_PAIR_FIRST;
+  case R_RISCV_SUB_ULEB128:
+    return R_RELOCATE_PAIR_SECOND;
   case R_RISCV_JAL:
   case R_RISCV_BRANCH:
   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:
case R_RISCV_RELAX:
     return config->relax ? R_RELAX_HINT : R_NONE;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }
 
+void RISCV::relocatePair(uint8_t *loc, const Relocation &relA, uint64_t valA,
+                         const Relocation &relB, uint64_t valB) const {
+  unsigned oldLength;
+  decodeULEB128(loc, &oldLength);
+  uint64_t newVal = valA - valB;
+  unsigned newLength = getULEB128Size(newVal);
+  if (newLength <= oldLength)
+    encodeULEB128(newVal, loc, /*PadTo*/ oldLength);
+  else
+    reportULEB128LengthExtend(loc, relA.type, *relA.sym, *relB.sym, oldLength,
+                              newLength);
+}
 void RISCV::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
   const unsigned bits = config->wordsize * 8;
 
   switch (rel.type) {
   case R_RISCV_32:
     write32le(loc, val);
     return;
   case R_RISCV_64:
     write64le(loc, val);
     return;
 
   case R_RISCV_RVC_BRANCH: {
     checkInt(loc, val, 9, rel);
     checkAlignment(loc, val, 2, rel);
     uint16_t insn = read16le(loc) & 0xE383;
     uint16_t imm8 = extractBits(val, 8, 8) << 12;
     uint16_t imm4_3 = extractBits(val, 4, 3) << 10;
     uint16_t imm7_6 = extractBits(val, 7, 6) << 5;
     uint16_t imm2_1 = extractBits(val, 2, 1) << 3;
     uint16_t imm5 = extractBits(val, 5, 5) << 2;
     insn |= imm8 | imm4_3 | imm7_6 | imm2_1 | imm5;
 
     write16le(loc, insn);
     return;
   }
 
   case R_RISCV_RVC_JUMP: {
     checkInt(loc, val, 12, rel);
     checkAlignment(loc, val, 2, rel);
     uint16_t insn = read16le(loc) & 0xE003;
     uint16_t imm11 = extractBits(val, 11, 11) << 12;
     uint16_t imm4 = extractBits(val, 4, 4) << 11;
     uint16_t imm9_8 = extractBits(val, 9, 8) << 9;
     uint16_t imm10 = extractBits(val, 10, 10) << 8;
     uint16_t imm6 = extractBits(val, 6, 6) << 7;
     uint16_t imm7 = extractBits(val, 7, 7) << 6;

lld/ELF/InputSection.cpp

uint64_t InputSectionBase::getRelocTargetVA(const InputFile *file, RelType type,
                                             int64_t a, uint64_t p,
                                             const Symbol &sym, RelExpr expr) {
   switch (expr) {
   case R_ABS:
   case R_DTPREL:
   case R_RELAX_TLS_LD_TO_LE_ABS:
   case R_RELAX_GOT_PC_NOPIC:
   case R_RISCV_ADD:
+  case R_RELOCATE_PAIR_FIRST:
+  case R_RELOCATE_PAIR_SECOND:
     return sym.getVA(a);
   case R_ADDEND:
     return a;
   case R_RELAX_HINT:
     return 0;
   case R_ARM_SBREL:
     return sym.getVA(a) - getARMStaticBase(sym);
   case R_GOT:
void InputSection::relocateNonAlloc(uint8_t *buf, ArrayRef<RelTy> rels) {
   const bool isDebugLine = isDebug && name == ".debug_line";
   std::optional<uint64_t> tombstone;
   for (const auto &patAndValue : llvm::reverse(config->deadRelocInNonAlloc))
     if (patAndValue.first.match(this->name)) {
       tombstone = patAndValue.second;
       break;
     }
 
-  for (const RelTy &rel : rels) {
+  for (auto [i, rel] : llvm::enumerate(rels)) {
     RelType type = rel.getType(config->isMips64EL);
 
     // GCC 8.0 or earlier have a bug that they emit R_386_GOTPC relocations
     // against _GLOBAL_OFFSET_TABLE_ for .debug_info. The bug has been fixed
     // in 2017 (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82630), but we
     // need to keep this bug-compatible code for a while.
     if (config->emachine == EM_386 && type == R_386_GOTPC)
       continue;
for (auto [i, rel] : llvm::enumerate(rels)) {
     // R_ABS/R_DTPREL and some other relocations can be used from non-SHF_ALLOC
     // sections.
     if (expr == R_ABS || expr == R_DTPREL || expr == R_GOTPLTREL ||
         expr == R_RISCV_ADD) {
       target.relocateNoSym(bufLoc, type, SignExtend64<bits>(sym.getVA(addend)));
       continue;
     }
 
+    // Relocation pairs should appear together; we always handle them at the
+    // later one.
+    if (expr == R_RELOCATE_PAIR_FIRST || expr == R_RELOCATE_PAIR_SECOND) {
+      RelExpr expectedOther = expr == R_RELOCATE_PAIR_FIRST
+                                  ? R_RELOCATE_PAIR_SECOND
+                                  : R_RELOCATE_PAIR_FIRST;
+      bool foundPair = false;
+      const RelTy *otherRel = nullptr;
+      RelExpr otherExpr = R_NONE;
+      RelType otherType = R_NONE;
+      Symbol *otherSym = nullptr;
+      bool isSecondOne = false;
+
+      auto getRelInfo = [&](size_t idx) {
+        otherRel = &rels[idx];
+        otherType = otherRel->getType(config->isMips64EL);
+        otherSym = &getFile<ELFT>()->getRelocTargetSym(*otherRel);
+        otherExpr = target.getRelExpr(otherType, *otherSym, bufLoc);
+      };
+
+      // Try to look towards the front.
+      if (i + 1 < rels.size()) {
+        getRelInfo(i + 1);
+        if (expectedOther == otherExpr)
+          foundPair = true;
+      }
+      // Try to look towards the back.
+      if (!foundPair && i >= 1) {
+        getRelInfo(i - 1);
+        if (expectedOther == otherExpr) {
+          foundPair = true;
+          isSecondOne = true;
+        }
+      }
+      if (!foundPair) {
+        std::string msg = getLocation(offset) +
+                          ": found orphan paired relocation " + toString(type) +
+                          " against symbol '" + toString(sym) + "'";
+        error(msg);
+        continue;
+      }
+      if (isSecondOne)
+        target.relocatePair(
+            bufLoc, Relocation{R_NONE, otherType, 0, 0, otherSym},
+            SignExtend64<bits>(otherSym->getVA(addend)),
+            Relocation{R_NONE, type, 0, 0,
+                       &getFile<ELFT>()->getRelocTargetSym(rel)},
+            SignExtend64<bits>(sym.getVA(addend)));
+      continue;
+    }
+
     std::string msg = getLocation(offset) + ": has non-ABS relocation " +
                       toString(type) + " against symbol '" + toString(sym) +
                       "'";
     if (expr != R_PC && expr != R_ARM_PCA) {
       error(msg);
       return;
     }
 

lld/ELF/Relocations.h

enum RelExpr {
   R_RELAX_TLS_GD_TO_IE_ABS,
   R_RELAX_TLS_GD_TO_IE_GOT_OFF,
   R_RELAX_TLS_GD_TO_IE_GOTPLT,
   R_RELAX_TLS_GD_TO_LE,
   R_RELAX_TLS_GD_TO_LE_NEG,
   R_RELAX_TLS_IE_TO_LE,
   R_RELAX_TLS_LD_TO_LE,
   R_RELAX_TLS_LD_TO_LE_ABS,
+  R_RELOCATE_PAIR_FIRST,
+  R_RELOCATE_PAIR_SECOND,
   R_SIZE,
   R_TPREL,
   R_TPREL_NEG,
   R_TLSDESC,
   R_TLSDESC_CALL,
   R_TLSDESC_PC,
   R_TLSDESC_GOTPLT,
   R_TLSGD_GOT,

lld/ELF/Target.h

virtual bool inBranchRange(RelType type, uint64_t src,
                              uint64_t dst) const;
 
   virtual void relocate(uint8_t *loc, const Relocation &rel,
                         uint64_t val) const = 0;
   void relocateNoSym(uint8_t *loc, RelType type, uint64_t val) const {
     relocate(loc, Relocation{R_NONE, type, 0, 0, nullptr}, val);
   }
   virtual void relocateAlloc(InputSectionBase &sec, uint8_t *buf) const;
+  void reportOrphanRelocationPair(uint8_t *loc, const Relocation &rel) const;
+  virtual void relocatePair(uint8_t *loc, const Relocation &relA, uint64_t valA,
+                            const Relocation &relB, uint64_t valB) const;
 
   // Do a linker relaxation pass and return true if we changed something.
   virtual bool relaxOnce(int pass) const { return false; }
 
   virtual void applyJumpInstrMod(uint8_t *loc, JumpModType type,
                                  JumpModType val) const {}
 
   virtual ~TargetInfo();

lld/ELF/Target.cpp

RelExpr TargetInfo::adjustGotPcExpr(RelType type, int64_t addend,
   return R_GOT_PC;
 }
 
 void TargetInfo::relocateAlloc(InputSectionBase &sec, uint8_t *buf) const {
   const unsigned bits = config->is64 ? 64 : 32;
   uint64_t secAddr = sec.getOutputSection()->addr;
   if (auto *s = dyn_cast<InputSection>(&sec))
     secAddr += s->outSecOff;
-  for (const Relocation &rel : sec.relocs()) {
+  for (auto [i, rel] : llvm::enumerate(sec.relocs())) {
     uint8_t *loc = buf + rel.offset;
     const uint64_t val = SignExtend64(
         sec.getRelocTargetVA(sec.file, rel.type, rel.addend,
                              secAddr + rel.offset, *rel.sym, rel.expr),
         bits);
-    if (rel.expr != R_RELAX_HINT)
+    switch (rel.expr) {
+    case R_RELAX_HINT:
+      break;
+    case R_RELOCATE_PAIR_FIRST: {
+      if (i + 1 >= sec.relocs().size()) {
+        reportOrphanRelocationPair(loc, rel);
+        break;
+      }
+
+      auto nextRel = sec.relocs()[i + 1];
+      uint64_t nextVal = SignExtend64(
+          sec.getRelocTargetVA(sec.file, nextRel.type, nextRel.addend,
+                               secAddr + nextRel.offset, *nextRel.sym,
+                               nextRel.expr),
+          bits);
+      relocatePair(loc, rel, val, nextRel, nextVal);
+    } break;
+    case R_RELOCATE_PAIR_SECOND:
+      if (i < 1 ||
+          (i > 1 && sec.relocs()[i - 1].expr != R_RELOCATE_PAIR_FIRST)) {
+        reportOrphanRelocationPair(loc, rel);
+      }
+      break;
+    default:
       relocate(loc, rel, val);
+      break;
     }
   }
+}
+
+void TargetInfo::reportOrphanRelocationPair(uint8_t *loc,
+                                            const Relocation &rel) const {
+  ErrorPlace errPlace = getErrorPlace(loc);
+  std::string msg = errPlace.loc + ": found orphan paired relocation " +
+                    toString(rel.type) + " against symbol '" +
+                    toString(*rel.sym) + "'";
+  error(msg);
+}
+
+void TargetInfo::relocatePair(uint8_t *loc, const Relocation &relA,
+                              uint64_t valA, const Relocation &relB,
+                              uint64_t valB) const {
+  llvm_unreachable("Target doesn't support relocatePair.");
+}
 
 uint64_t TargetInfo::getImageBase() const {
   // Use --image-base if set. Fall back to the target default if not.
   if (config->imageBase)
     return *config->imageBase;
   return config->isPic ? 0 : defaultImageBase;
 }

lld/test/ELF/riscv-bad-uleb128-ext-len-noalloc.s

+# REQUIRES: riscv
+## Relax R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+
+## RELAX
+# RUN: yaml2obj a.yml -o a.o
+# RUN: not ld.lld -T lds a.o -o 32c 2>&1 | FileCheck %s
+
+# CHECK: ULEB128 difference relocation pair overflow: 2 bytes needed but only 1 bytes allocated; references '.Lend_start' - '_start' 
+
+#--- a.yml
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_RISCV
+  Flags:           [ EF_RISCV_RVC, EF_RISCV_FLOAT_ABI_SOFT ]
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x2
+    Content:         '01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010097000000E78000008280'
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         '0000000000'
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .text
+    Relocations:
+      - Offset:          0x1FE
+        Symbol:          a
+        Type:            R_RISCV_CALL_PLT
+      - Offset:          0x1FE
+        Type:            R_RISCV_RELAX
+  - Name:            .rela.debug_info
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .debug_info
+    Relocations:
+      - Symbol:          .Lend_start
+        Type:            R_RISCV_SET_ULEB128
+      - Symbol:          _start
+        Type:            R_RISCV_SUB_ULEB128
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .debug_info
+      - Name:            .rela.debug_info
+      - Name:            .symtab
+Symbols:
+  - Name:            '$x.0'
+    Section:         .text
+  - Name:            a
+    Section:         .text
+    Value:           0x206
+  - Name:            .Lend_start
+    Section:         .text
+    Value:           0x206
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x206
+...
+
+
+#--- lds
+SECTIONS {
+  .text 0x10000 : { *(.text) }
+  .data 0x20000 : { *(.data) }
+}

lld/test/ELF/riscv-bad-uleb128-ext-len.s

+# REQUIRES: riscv
+## Relax R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+
+## RELAX
+# RUN: yaml2obj a.yml -o a.o
+# RUN: not ld.lld -T lds a.o -o 32c 2>&1 | FileCheck %s
+
+# CHECK: ULEB128 difference relocation pair overflow: 2 bytes needed but only 1 bytes allocated; references '.Lend_start' - '_start' 
+
+#--- a.yml
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_RISCV
+  Flags:           [ EF_RISCV_RVC, EF_RISCV_FLOAT_ABI_SOFT ]
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x2
+    Content:         '01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010097000000E78000008280'
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x1
+    Content:         '0000000000'
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .text
+    Relocations:
+      - Offset:          0x1FE
+        Symbol:          a
+        Type:            R_RISCV_CALL_PLT
+      - Offset:          0x1FE
+        Type:            R_RISCV_RELAX
+  - Name:            .rela.data
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .data
+    Relocations:
+      - Symbol:          .Lend_start
+        Type:            R_RISCV_SET_ULEB128
+      - Symbol:          _start
+        Type:            R_RISCV_SUB_ULEB128
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .data
+      - Name:            .rela.data
+      - Name:            .symtab
+Symbols:
+  - Name:            '$x.0'
+    Section:         .text
+  - Name:            a
+    Section:         .text
+    Value:           0x206
+  - Name:            .Lend_start
+    Section:         .text
+    Value:           0x206
+  - Name:            '$d.1'
+    Section:         .data
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x206
+...
+
+
+#--- lds
+SECTIONS {
+  .text 0x10000 : { *(.text) }
+  .data 0x20000 : { *(.data) }
+}

lld/test/ELF/riscv-bad-uleb128-no-pair-1.s

+# REQUIRES: riscv
+## Relax R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+
+## RELAX
+# RUN: yaml2obj a.yml -o a.o
+# RUN: not ld.lld -T lds a.o -o 32c 2>&1 | FileCheck %s
+
+# CHECK: found orphan paired relocation R_RISCV_SET_ULEB128 against symbol '.Lend_start'
+
+#--- a.yml
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_RISCV
+  Flags:           [ EF_RISCV_RVC, EF_RISCV_FLOAT_ABI_SOFT ]
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x2
+    Content:         '01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010097000000E78000008280'
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x1
+    Content:         '0000000000'
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .text
+    Relocations:
+      - Offset:          0x1FE
+        Symbol:          a
+        Type:            R_RISCV_CALL_PLT
+      - Offset:          0x1FE
+        Type:            R_RISCV_RELAX
+  - Name:            .rela.data
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .data
+    Relocations:
+      - Symbol:          .Lend_start
+        Type:            R_RISCV_SET_ULEB128
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .data
+      - Name:            .rela.data
+      - Name:            .symtab
+Symbols:
+  - Name:            '$x.0'
+    Section:         .text
+  - Name:            a
+    Section:         .text
+    Value:           0x206
+  - Name:            .Lend_start
+    Section:         .text
+    Value:           0x206
+  - Name:            '$d.1'
+    Section:         .data
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x206
+...
+
+
+#--- lds
+SECTIONS {
+  .text 0x10000 : { *(.text) }
+  .data 0x20000 : { *(.data) }
+}

lld/test/ELF/riscv-bad-uleb128-no-pair-2.s

+# REQUIRES: riscv
+## Relax R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+
+## RELAX
+# RUN: yaml2obj a.yml -o a.o
+# RUN: not ld.lld -T lds a.o -o 32c 2>&1 | FileCheck %s
+
+# CHECK: found orphan paired relocation R_RISCV_SUB_ULEB128 against symbol '_start'
+
+#--- a.yml
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_RISCV
+  Flags:           [ EF_RISCV_RVC, EF_RISCV_FLOAT_ABI_SOFT ]
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x2
+    Content:         '01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010097000000E78000008280'
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x1
+    Content:         '0000000000'
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .text
+    Relocations:
+      - Offset:          0x1FE
+        Symbol:          a
+        Type:            R_RISCV_CALL_PLT
+      - Offset:          0x1FE
+        Type:            R_RISCV_RELAX
+  - Name:            .rela.data
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .data
+    Relocations:
+      - Symbol:          _start
+        Type:            R_RISCV_SUB_ULEB128
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .data
+      - Name:            .rela.data
+      - Name:            .symtab
+Symbols:
+  - Name:            '$x.0'
+    Section:         .text
+  - Name:            a
+    Section:         .text
+    Value:           0x206
+  - Name:            .Lend_start
+    Section:         .text
+    Value:           0x206
+  - Name:            '$d.1'
+    Section:         .data
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x206
+...
+
+
+#--- lds
+SECTIONS {
+  .text 0x10000 : { *(.text) }
+  .data 0x20000 : { *(.data) }
+}

lld/test/ELF/riscv-bad-uleb128-no-pair-3.s

+# REQUIRES: riscv
+## Relax R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+
+## RELAX
+# RUN: yaml2obj a.yml -o a.o
+# RUN: not ld.lld -T lds a.o -o 32c 2>&1 | FileCheck %s
+
+# CHECK: found orphan paired relocation R_RISCV_SET_ULEB128 against symbol '.Lend_start'
+
+#--- a.yml
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_RISCV
+  Flags:           [ EF_RISCV_RVC, EF_RISCV_FLOAT_ABI_SOFT ]
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x2
+    Content:         '01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010097000000E78000008280'
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         '0000000000'
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .text
+    Relocations:
+      - Offset:          0x1FE
+        Symbol:          a
+        Type:            R_RISCV_CALL_PLT
+      - Offset:          0x1FE
+        Type:            R_RISCV_RELAX
+  - Name:            .rela.debug_info
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .debug_info
+    Relocations:
+      - Symbol:          .Lend_start
+        Type:            R_RISCV_SET_ULEB128
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .debug_info
+      - Name:            .rela.debug_info
+      - Name:            .symtab
+Symbols:
+  - Name:            '$x.0'
+    Section:         .text
+  - Name:            a
+    Section:         .text
+    Value:           0x206
+  - Name:            .Lend_start
+    Section:         .text
+    Value:           0x206
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x206
+...
+
+
+#--- lds
+SECTIONS {
+  .text 0x10000 : { *(.text) }
+  .data 0x20000 : { *(.data) }
+}

lld/test/ELF/riscv-bad-uleb128-no-pair-4.s

+# REQUIRES: riscv
+## Relax R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+
+## RELAX
+# RUN: yaml2obj a.yml -o a.o
+# RUN: not ld.lld -T lds a.o -o 32c 2>&1 | FileCheck %s
+
+# CHECK: found orphan paired relocation R_RISCV_SUB_ULEB128 against symbol '_start'
+
+#--- a.yml
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_RISCV
+  Flags:           [ EF_RISCV_RVC, EF_RISCV_FLOAT_ABI_SOFT ]
+  SectionHeaderStringTable: .strtab
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x2
+    Content:         '01000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010001000100010097000000E78000008280'
+  - Name:            .debug_info
+    Type:            SHT_PROGBITS
+    AddressAlign:    0x1
+    Content:         '0000000000'
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .text
+    Relocations:
+      - Offset:          0x1FE
+        Symbol:          a
+        Type:            R_RISCV_CALL_PLT
+      - Offset:          0x1FE
+        Type:            R_RISCV_RELAX
+  - Name:            .rela.debug_info
+    Type:            SHT_RELA
+    Flags:           [ SHF_INFO_LINK ]
+    Link:            .symtab
+    AddressAlign:    0x4
+    Info:            .debug_info
+    Relocations:
+      - Symbol:          _start
+        Type:            R_RISCV_SUB_ULEB128
+  - Type:            SectionHeaderTable
+    Sections:
+      - Name:            .strtab
+      - Name:            .text
+      - Name:            .rela.text
+      - Name:            .debug_info
+      - Name:            .rela.debug_info
+      - Name:            .symtab
+Symbols:
+  - Name:            '$x.0'
+    Section:         .text
+  - Name:            a
+    Section:         .text
+    Value:           0x206
+  - Name:            .Lend_start
+    Section:         .text
+    Value:           0x206
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x206
+...
+
+
+#--- lds
+SECTIONS {
+  .text 0x10000 : { *(.text) }
+  .data 0x20000 : { *(.data) }
+}

lld/test/ELF/riscv-relax-uleb128.s

+# REQUIRES: riscv
+## Relax R_RISCV_SET_ULEB128 and R_RISCV_SUB_ULEB128.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+
+## RELAX
+# RUN: llvm-mc -filetype=obj -triple=riscv32 -riscv-enable-uleb128 -mattr=+c,+relax a.s -o a.32c.o
+# RUN: ld.lld -T lds a.32c.o -o 32c
+# RUN: llvm-objdump -td -j .text -j .data -M no-aliases 32c | FileCheck %s --check-prefixes=RELAX,RELAX32
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -riscv-enable-uleb128 -mattr=+c,+relax a.s -o a.64c.o
+# RUN: ld.lld -T lds a.64c.o -o 64c
+# RUN: llvm-objdump -td -j .text -j .data -M no-aliases 64c | FileCheck %s --check-prefixes=RELAX,RELAX64
+
+## --no-relax disables relaxation.
+# RUN: ld.lld -T lds a.64c.o --no-relax -o 64c.norelax
+# RUN: llvm-objdump -td -j .text -j .data -M no-aliases 64c.norelax | FileCheck %s --check-prefixes=NORELAX
+
+# RELAX32:       00010002 l       .text  00000000 a
+# RELAX32:       00010002 l       .text  00000000 .Lend_start
+# RELAX32:       00010000 g       .text  00000002 _start
+
+# RELAX64:       0000000000010004 l       .text  0000000000000000 a
+# RELAX64:       0000000000010004 l       .text  0000000000000000 .Lend_start
+# RELAX64:       0000000000010000 g       .text  0000000000000004 _start
+
+# RELAX-LABEL:   <_start>:
+# RELAX32-NEXT:    10000: 09 20         c.jal   0x10002 <a>
+# RELAX64-NEXT:    10000: ef 00 40 00   jal     ra, 0x10004 <a>
+# RELAX-EMPTY:
+# RELAX-NEXT:    <a>:
+# RELAX32-NEXT:      10002: 82 80         c.jr    ra
+# RELAX64-NEXT:      10004: 82 80         c.jr    ra
+# RELAX-EMPTY:
+
+# RELAX-LABEL:   <.data>:
+# RELAX32:        20000: 82 80
+# RELAX32-NEXT:   20002: 80 80
+# RELAX32-NEXT:   20004: 00
+# RELAX64:        20000: 84 80
+# RELAX64-NEXT:   20002: 80 80
+# RELAX64-NEXT:   20004: 80 80
+# RELAX64-NEXT:   20006: 80 80
+# RELAX64-NEXT:   20008: 80 00
+# RELAX-EMPTY:
+
+# NORELAX-LABEL: <_start>:
+# NORELAX:           10000:  97 00 00 00   auipc   ra, 0
+# NORELAX-NEXT:              e7 80 80 00   jalr    ra, 8(ra)
+# NORELAX-EMPTY:
+
+# NORELAX-LABEL:   <.data>:
+# NORELAX:           20000: 88 80
+# NORELAX-NEXT:      20002: 80 80
+# NORELAX-NEXT:      20004: 80 80
+# NORELAX-NEXT:      20006: 80 80
+# NORELAX-NEXT:      20008: 80 00
+# NORELAX-EMPTY:
+
+
+#--- a.s
+.global _start
+_start:
+  call a          # rv32c: c.jal; rv64c: jal
+.Lend_start:
+.size _start, . - _start
+
+a:
+  ret
+.data
+.uleb128 .Lend_start-_start
+
+#--- lds
+SECTIONS {
+  .text 0x10000 : { *(.text) }
+  .data 0x20000 : { *(.data) }
+}