[RISCV] Support R_RISCV_SET_ULEB128/R_RISCV_SUB_ULEB128 for .uleb128 directives

[MaskRay]

Summary

For a label difference like .uleb128 A-B, MC folds A-B even if A and B
are separated by a RISC-V linker-relaxable instruction. This incorrect
behavior is currently abused by DWARF v5 .debug_loclists/.debug_rnglists
(DW_LLE_offset_pair/DW_RLE_offset_pair entry kinds) implemented in
Clang/LLVM (see https://github.com/ClangBuiltLinux/linux/issues/1719 for
an instance).

https://github.com/riscv-non-isa/riscv-elf-psabi-doc/commit/96d6e190e9fc04a8517f9ff7fb9aed3e9876cbd6
defined R_RISCV_SET_ULEB128/R_RISCV_SUB_ULEB128. This patch generates such
a pair of relocations to represent A-B that should not be folded.
GNU assembler computes the directive size by ignoring shrinkable section
content, therefore after linking the value of A-B cannot use more bytes
than the reserved number (final size of uleb128 value at offset ... exceeds available space).
We make the same assumption.

w1:
  call foo
w2:
  .space 120
w3:
.uleb128 w2-w1  # 1 byte, 0x08
.uleb128 w3-w1  # 2 bytes, 0x80 0x01

We do not conservatively reserve 10 bytes (maximum size of an uleb128
for uint64_t) as that would pessimize DWARF v5
DW_LLE_offset_pair/DW_RLE_offset_pair, nullifying the benefits of
introducing R_RISCV_SET_ULEB128/R_RISCV_SUB_ULEB128 relocations.

The supported expressions are limited. For example,

• non-subtraction .uleb128 A is not allowed
• .uleb128 A-B: report an error unless A and B are both defined and in the same section

The new cl::opt -riscv-uleb128-reloc can be used to suppress the
relocations.

[kito-cheng]

We do not conservatively reserve 10 bytes (maximum size of an uleb128
for uint64_t) as that would pessimize DWARF v5
DW_LLE_offset_pair/DW_RLE_offset_pair, nullifying the benefits of
introducing R_RISCV_SET_ULEB128/R_RISCV_SUB_ULEB128 relocations.

That fixed one of major issue in my version (D142880), it will always reserve 10 bytes instead of just reserve enough byte, and apparently I didn't handle handle debug info properly.

RISC-V part LGTM, thanks :)

[jrtc27]

llvm/include/llvm/MC/MCFixup.h

48

I guess the sign is relevant here but not for the others because we have to know how to pad it? (Though what about FK_Data_8 on a 32-bit target?..)

llvm/test/MC/ELF/RISCV/gen-dwarf.s

53

Is this actually the null symbol or has this just not read in the symbol table properly?

llvm/test/MC/RISCV/leb128.s

33–34

Double spaces here

Also why is this one CHECK but w2-w1 is RELAX?

35

Make this CHECK and move it down as it's shared?

[MaskRay]

address comments

llvm/include/llvm/MC/MCFixup.h

48

I agree. Changed to FK_Data_leb128.

(Though what about FK_Data_8 on a 32-bit target?..)

They usually lead to errors.

llvm/test/MC/ELF/RISCV/gen-dwarf.s

53

This is a symbol with an empty name, not symbol index 0.

llvm-readobj since 82b4368f7f89e2b16b9eb09787b7a7af07e3b7cd (Jul 2023) prints <null>, matching GNU readelf.

[vpalatin]

llvm/lib/MC/MCAssembler.cpp

1020–1022

I'm seeing a failure on 'lld :: MachO/compact-unwind-lsda-folding.s' with this part of the change

******************** TEST 'lld :: MachO/compact-unwind-lsda-folding.s' FAILED ********************
Script:
--
: 'RUN: at line 6';   rm -rf build.ASSERT/tools/lld/test/MachO/Output/compact-unwind-lsda-folding.s.tmp; mkdir build.ASSERT/tools/lld/test/MachO/Output/compact-unwind-lsda-folding.s.tmp
: 'RUN: at line 7';   build.ASSERT/bin/llvm-mc -filetype=obj -triple=x86_64-apple-macos11.0 -emit-compact-unwind-non-canonical=true -o build.ASSERT/tools/lld/test/MachO/Output/compact-unwind-lsda-folding.s.tmp/lsda.o lld/test/MachO/compact-unwind-lsda-folding.s
: 'RUN: at line 8';   ld64.lld -arch x86_64 -platform_version macos 11.0 11.0 -syslibroot lld/test/MachO/Inputs/MacOSX.sdk -lSystem -fatal_warnings -dylib --icf=all -lSystem -lc++ -o build.ASSERT/tools/lld/test/MachO/Output/compact-unwind-lsda-folding.s.tmp/liblsda.dylib build.ASSERT/tools/lld/test/MachO/Output/compact-unwind-lsda-folding.s.tmp/lsda.o
: 'RUN: at line 9';   build.ASSERT/bin/llvm-objdump --macho --syms --unwind-info build.ASSERT/tools/lld/test/MachO/Output/compact-unwind-lsda-folding.s.tmp/liblsda.dylib | build.ASSERT/bin/FileCheck lld/test/MachO/compact-unwind-lsda-folding.s
--
Exit Code: 1

Command Output (stderr):
--
lld/test/MachO/compact-unwind-lsda-folding.s:87:21: error: .uleb128 expression is not absolute
        .uleb128 Lfunc_end0-Ltmp1               ##   Call between Ltmp1 and Lfunc_end0

[MaskRay]

work around Mach-O .subsections_via_symbols

llvm/lib/MC/MCAssembler.cpp

1020–1022

Thanks. I added a llvm/test/MC test in 04c1e521b9547944333379528e8519f14e4a665c as this hasn't been tested by llvm/ before. Thanks to smeenai for creating this test!

[MaskRay]

Ready for re-review:)

[MaskRay]

Ping:)

(The lld patch may take some time. I'll be out of town for about 10 days.)

[asb]

LGTM. I think Kito and Jessica are best placed to review this and it already got a LGTM from Kito. I think we should go ahead and merge this.

[MaskRay]

In D157657#4656446, @asb wrote:

LGTM. I think Kito and Jessica are best placed to review this and it already got a LGTM from Kito. I think we should go ahead and merge this.

Thanks! I'll merge this tomorrow if @jrtc27 does not have blocking comments.

[nikic]

It looks like this change has substantially increased the memory usage of ReleaseLTO-g builds on X86. Here are the max-rss stats for the linking step (data extracted from here):

kc.link 	232MiB 	238MiB (+2.58%)
sqlite3.link 	212MiB 	221MiB (+3.98%)
consumer-typeset.link 	158MiB 	161MiB (+1.99%)
bullet.link 	199MiB 	202MiB (+1.62%)
tramp3d-v4.link 	683MiB 	713MiB (+4.41%)
clamscan.link 	231MiB 	238MiB (+2.97%)
lencod.link 	274MiB 	281MiB (+2.75%)
7zip-benchmark.link 	457MiB 	473MiB (+3.60%)

So this increases memory usage by about 2-5% for builds using optimization and debug info.

Can something be done about this? It seems pretty bad that a RISCV specific change pessimizes other targets to this degree.

[craig.topper]

llvm/include/llvm/MC/MCFragment.h

438

Should this Contents field be removed?

[MaskRay]

llvm/include/llvm/MC/MCFragment.h

438

Thanks for 3b916ad6733b04a86ca0aec57be647daf4647d5b [MC] Remove duplicate Contents field from MCLEBFragment.

Another thing we can tune is the template arguments in MCEncodedFragmentWithFixups<10, 1>, e.g. <8, 0> <8, 1> <10, 1>.

[nikic]

llvm/include/llvm/MC/MCFragment.h

438

It looks like this helped somewhat, but didn't full recover the regression. Compare only the stage1-ReleaseLTO-g (link only) part here:

https://llvm-compile-time-tracker.com/compare.php?from=e17efa60b197c07ea21c2cba44670acf0dd75e60&to=1df5ea29b43690b6622db2cad7b745607ca4de6a&stat=max-rss&linkStats=on
http://llvm-compile-time-tracker.com/compare.php?from=dc4786b4877d67d73d3892c45baf6811af0e6f57&to=3b916ad6733b04a86ca0aec57be647daf4647d5b&stat=max-rss&linkStats=on

Originally went up by +2.4% (geomean) and then went down by -0.7%.

llvm/include/llvm/BinaryFormat/ELFRelocs/RISCV.def

 ELF_RELOC(R_RISCV_SUB6,              52)
 ELF_RELOC(R_RISCV_SET6,              53)
 ELF_RELOC(R_RISCV_SET8,              54)
 ELF_RELOC(R_RISCV_SET16,             55)
 ELF_RELOC(R_RISCV_SET32,             56)
 ELF_RELOC(R_RISCV_32_PCREL,          57)
 ELF_RELOC(R_RISCV_IRELATIVE,         58)
 ELF_RELOC(R_RISCV_PLT32,             59)
+ELF_RELOC(R_RISCV_SET_ULEB128,       60)
+ELF_RELOC(R_RISCV_SUB_ULEB128,       61)

llvm/include/llvm/MC/MCAsmBackend.h

 #include <cstdint>
 
 namespace llvm {
 
 class MCAlignFragment;
 class MCDwarfCallFrameFragment;
 class MCDwarfLineAddrFragment;
 class MCFragment;
+class MCLEBFragment;
 class MCRelaxableFragment;
 class MCSymbol;
 class MCAsmLayout;
 class MCAssembler;
 class MCContext;
 struct MCDwarfFrameInfo;
 struct MCFixupKindInfo;
 class MCInst;
virtual bool relaxDwarfLineAddr(MCDwarfLineAddrFragment &DF,
     return false;
   }
 
   virtual bool relaxDwarfCFA(MCDwarfCallFrameFragment &DF, MCAsmLayout &Layout,
                              bool &WasRelaxed) const {
     return false;
   }
 
+  // Defined by linker relaxation targets to possibly emit LEB128 relocations
+  // and set Value at the relocated location.
+  virtual bool relaxLEB128(MCLEBFragment &LF, MCAsmLayout &Layout,
+                           int64_t &Value) const {
+    return false;
+  }
+
   /// @}
 
   /// Returns the minimum size of a nop in bytes on this target. The assembler
   /// will use this to emit excess padding in situations where the padding
   /// required for simple alignment would be less than the minimum nop size.
   ///
   virtual unsigned getMinimumNopSize() const { return 1; }
 

llvm/include/llvm/MC/MCFixup.h

 
 /// Extensible enumeration to represent the type of a fixup.
 enum MCFixupKind {
   FK_NONE = 0,    ///< A no-op fixup.
   FK_Data_1,      ///< A one-byte fixup.
   FK_Data_2,      ///< A two-byte fixup.
   FK_Data_4,      ///< A four-byte fixup.
   FK_Data_8,      ///< A eight-byte fixup.
+  FK_Data_leb128, ///< A leb128 fixup.
   FK_PCRel_1,     ///< A one-byte pc relative fixup.
   FK_PCRel_2,     ///< A two-byte pc relative fixup.
   FK_PCRel_4,     ///< A four-byte pc relative fixup.
   FK_PCRel_8,     ///< A eight-byte pc relative fixup.
   FK_GPRel_1,     ///< A one-byte gp relative fixup.
   FK_GPRel_2,     ///< A two-byte gp relative fixup.
   FK_GPRel_4,     ///< A four-byte gp relative fixup.
   FK_GPRel_8,     ///< A eight-byte gp relative fixup.
   FK_DTPRel_4,    ///< A four-byte dtp relative fixup.
   FK_DTPRel_8,    ///< A eight-byte dtp relative fixup.
   FK_TPRel_4,     ///< A four-byte tp relative fixup.
   FK_TPRel_8,     ///< A eight-byte tp relative fixup.
   FK_SecRel_1,    ///< A one-byte section relative fixup.
   FK_SecRel_2,    ///< A two-byte section relative fixup.
   FK_SecRel_4,    ///< A four-byte section relative fixup.
   FK_SecRel_8,    ///< A eight-byte section relative fixup.
 
   FirstTargetFixupKind = 128,
 
   /// The range [FirstLiteralRelocationKind, MaxTargetFixupKind) is used for
   /// relocations coming from .reloc directive. Fixup kind
   /// FirstLiteralRelocationKind+V represents the relocation type with number V.
   FirstLiteralRelocationKind = 256,
 
   /// Set limit to accommodate the highest reloc type in use for all Targets,
   /// currently R_AARCH64_IRELATIVE at 1032, including room for expansion.
   MaxFixupKind = FirstLiteralRelocationKind + 1032 + 32,
 };
 

llvm/include/llvm/MC/MCFragment.h

public:
 
   SMLoc getLoc() const { return Loc; }
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_Org;
   }
 };
 
-class MCLEBFragment : public MCFragment {
+class MCLEBFragment final : public MCEncodedFragmentWithFixups<10, 1> {
   /// True if this is a sleb128, false if uleb128.
   bool IsSigned;
 
   /// The value this fragment should contain.
   const MCExpr *Value;
 
   SmallString<8> Contents;
 
 public:
-  MCLEBFragment(const MCExpr &Value_, bool IsSigned_, MCSection *Sec = nullptr)
-      : MCFragment(FT_LEB, false, Sec), IsSigned(IsSigned_), Value(&Value_) {
+  MCLEBFragment(const MCExpr &Value, bool IsSigned, MCSection *Sec = nullptr)
+      : MCEncodedFragmentWithFixups<10, 1>(FT_LEB, false, Sec),
+        IsSigned(IsSigned), Value(&Value) {
     Contents.push_back(0);
   }
 
   const MCExpr &getValue() const { return *Value; }
+  void setValue(const MCExpr *Expr) { Value = Expr; }
 
   bool isSigned() const { return IsSigned; }
 
-  SmallString<8> &getContents() { return Contents; }
-  const SmallString<8> &getContents() const { return Contents; }
-
   /// @}
 
   static bool classof(const MCFragment *F) {
     return F->getKind() == MCFragment::FT_LEB;
   }
 };
 
 class MCDwarfLineAddrFragment : public MCEncodedFragmentWithFixups<8, 1> {

llvm/lib/MC/MCAsmBackend.cpp

 
 const MCFixupKindInfo &MCAsmBackend::getFixupKindInfo(MCFixupKind Kind) const {
   static const MCFixupKindInfo Builtins[] = {
       {"FK_NONE", 0, 0, 0},
       {"FK_Data_1", 0, 8, 0},
       {"FK_Data_2", 0, 16, 0},
       {"FK_Data_4", 0, 32, 0},
       {"FK_Data_8", 0, 64, 0},
+      {"FK_Data_leb128", 0, 0, 0},
       {"FK_PCRel_1", 0, 8, MCFixupKindInfo::FKF_IsPCRel},
       {"FK_PCRel_2", 0, 16, MCFixupKindInfo::FKF_IsPCRel},
       {"FK_PCRel_4", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
       {"FK_PCRel_8", 0, 64, MCFixupKindInfo::FKF_IsPCRel},
       {"FK_GPRel_1", 0, 8, 0},
       {"FK_GPRel_2", 0, 16, 0},
       {"FK_GPRel_4", 0, 32, 0},
       {"FK_GPRel_8", 0, 64, 0},

llvm/lib/MC/MCAssembler.cpp

for (MCFragment &Frag : Sec) {
         break;
       }
       case MCFragment::FT_DwarfFrame: {
         MCDwarfCallFrameFragment &DF = cast<MCDwarfCallFrameFragment>(Frag);
         Fixups = DF.getFixups();
         Contents = DF.getContents();
         break;
       }
+      case MCFragment::FT_LEB: {
+        auto &LF = cast<MCLEBFragment>(Frag);
+        Fixups = LF.getFixups();
+        Contents = LF.getContents();
+        break;
+      }
       case MCFragment::FT_PseudoProbe: {
         MCPseudoProbeAddrFragment &PF = cast<MCPseudoProbeAddrFragment>(Frag);
         Fixups = PF.getFixups();
         Contents = PF.getContents();
         break;
       }
       }
       for (const MCFixup &Fixup : Fixups) {
bool MCAssembler::relaxInstruction(MCAsmLayout &Layout,
   F.getFixups().clear();
   F.getContents().clear();
   getEmitter().encodeInstruction(Relaxed, F.getContents(), F.getFixups(),
                                  *F.getSubtargetInfo());
   return true;
 }
 
 bool MCAssembler::relaxLEB(MCAsmLayout &Layout, MCLEBFragment &LF) {
-  uint64_t OldSize = LF.getContents().size();
+  const unsigned OldSize = static_cast<unsigned>(LF.getContents().size());
+  unsigned PadTo = OldSize;
   int64_t Value;
-  bool Abs = LF.getValue().evaluateKnownAbsolute(Value, Layout);
+  SmallVectorImpl<char> &Data = LF.getContents();
+  LF.getFixups().clear();
+  // Use evaluateKnownAbsolute for Mach-O as a hack: .subsections_via_symbols
+  // requires that .uleb128 A-B is foldable where A and B reside in different
+  // fragments. This is used by __gcc_except_table.
+  bool Abs = getSubsectionsViaSymbols()
+                 ? LF.getValue().evaluateKnownAbsolute(Value, Layout)
+                 : LF.getValue().evaluateAsAbsolute(Value, Layout);
   if (!Abs) {
+    if (!getBackend().relaxLEB128(LF, Layout, Value)) {
       getContext().reportError(LF.getValue().getLoc(),
                                Twine(LF.isSigned() ? ".s" : ".u") +
                                    "leb128 expression is not absolute");
+      LF.setValue(MCConstantExpr::create(0, Context));
+    }
+    uint8_t Tmp[10]; // maximum size: ceil(64/7)
+    PadTo = std::max(PadTo, encodeULEB128(uint64_t(Value), Tmp));
   }
-  SmallString<8> &Data = LF.getContents();
   Data.clear();
   raw_svector_ostream OSE(Data);
   // The compiler can generate EH table assembly that is impossible to assemble
   // without either adding padding to an LEB fragment or adding extra padding
   // to a later alignment fragment. To accommodate such tables, relaxation can
   // only increase an LEB fragment size here, not decrease it. See PR35809.
   if (LF.isSigned())
-    encodeSLEB128(Value, OSE, OldSize);
+    encodeSLEB128(Value, OSE, PadTo);
   else
-    encodeULEB128(Value, OSE, OldSize);
+    encodeULEB128(Value, OSE, PadTo);
   return OldSize != LF.getContents().size();
 }
 
 /// Check if the branch crosses the boundary.
 ///
 /// \param StartAddr start address of the fused/unfused branch.
 /// \param Size size of the fused/unfused branch.
 /// \param BoundaryAlignment alignment requirement of the branch.

llvm/lib/Target/RISCV/MCTargetDesc/RISCVAsmBackend.h

public:
 
   void relaxInstruction(MCInst &Inst,
                         const MCSubtargetInfo &STI) const override;
 
   bool relaxDwarfLineAddr(MCDwarfLineAddrFragment &DF, MCAsmLayout &Layout,
                           bool &WasRelaxed) const override;
   bool relaxDwarfCFA(MCDwarfCallFrameFragment &DF, MCAsmLayout &Layout,
                      bool &WasRelaxed) const override;
+  bool relaxLEB128(MCLEBFragment &LF, MCAsmLayout &Layout,
+                   int64_t &Value) const override;
 
   bool writeNopData(raw_ostream &OS, uint64_t Count,
                     const MCSubtargetInfo *STI) const override;
 
   const MCTargetOptions &getTargetOptions() const { return TargetOptions; }
 };
 }
 
 #endif

llvm/lib/Target/RISCV/MCTargetDesc/RISCVAsmBackend.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static cl::opt<bool> RelaxBranches("riscv-asm-relax-branches", cl::init(true),
                                    cl::Hidden);
+// Temporary workaround for old linkers that do not support ULEB128 relocations,
+// which are abused by DWARF v5 DW_LLE_offset_pair/DW_RLE_offset_pair
+// implemented in Clang/LLVM.
+static cl::opt<bool> ULEB128Reloc(
+    "riscv-uleb128-reloc", cl::init(true), cl::Hidden,
+    cl::desc("Emit R_RISCV_SET_ULEB128/E_RISCV_SUB_ULEB128 if appropriate"));
 
 std::optional<MCFixupKind> RISCVAsmBackend::getFixupKind(StringRef Name) const {
   if (STI.getTargetTriple().isOSBinFormatELF()) {
     unsigned Type;
     Type = llvm::StringSwitch<unsigned>(Name)
 #define ELF_RELOC(X, Y) .Case(#X, Y)
 #include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
 #undef ELF_RELOC
if (Fixup.getKind() >= FirstLiteralRelocationKind)
     return true;
   switch (Fixup.getTargetKind()) {
   default:
     break;
   case FK_Data_1:
   case FK_Data_2:
   case FK_Data_4:
   case FK_Data_8:
+  case FK_Data_leb128:
     if (Target.isAbsolute())
       return false;
     break;
   case RISCV::fixup_riscv_got_hi20:
   case RISCV::fixup_riscv_tls_got_hi20:
   case RISCV::fixup_riscv_tls_gd_hi20:
     return true;
   }
bool RISCVAsmBackend::relaxDwarfCFA(MCDwarfCallFrameFragment &DF,
   } else {
     llvm_unreachable("unsupported CFA encoding");
   }
 
   WasRelaxed = OldSize != Data.size();
   return true;
 }
 
+bool RISCVAsmBackend::relaxLEB128(MCLEBFragment &LF, MCAsmLayout &Layout,
+                                  int64_t &Value) const {
+  if (LF.isSigned())
+    return false;
+  const MCExpr &Expr = LF.getValue();
+  if (ULEB128Reloc) {
+    LF.getFixups().push_back(
+        MCFixup::create(0, &Expr, FK_Data_leb128, Expr.getLoc()));
+  }
+  return Expr.evaluateKnownAbsolute(Value, Layout);
+}
+
 // Given a compressed control flow instruction this function returns
 // the expanded instruction.
 unsigned RISCVAsmBackend::getRelaxedOpcode(unsigned Op) const {
   switch (Op) {
   default:
     return Op;
   case RISCV::C_BEQZ:
     return RISCV::BEQ;
static uint64_t adjustFixupValue(const MCFixup &Fixup, uint64_t Value,
   case RISCV::fixup_riscv_got_hi20:
   case RISCV::fixup_riscv_tls_got_hi20:
   case RISCV::fixup_riscv_tls_gd_hi20:
     llvm_unreachable("Relocation should be unconditionally forced\n");
   case FK_Data_1:
   case FK_Data_2:
   case FK_Data_4:
   case FK_Data_8:
+  case FK_Data_leb128:
     return Value;
   case RISCV::fixup_riscv_lo12_i:
   case RISCV::fixup_riscv_pcrel_lo12_i:
   case RISCV::fixup_riscv_tprel_lo12_i:
     return Value & 0xfff;
   case RISCV::fixup_riscv_12_i:
     if (!isInt<12>(Value)) {
       Ctx.reportError(Fixup.getLoc(),
bool RISCVAsmBackend::handleAddSubRelocations(const MCAsmLayout &Layout,
   case llvm::FK_Data_4:
     TA = ELF::R_RISCV_ADD32;
     TB = ELF::R_RISCV_SUB32;
     break;
   case llvm::FK_Data_8:
     TA = ELF::R_RISCV_ADD64;
     TB = ELF::R_RISCV_SUB64;
     break;
+  case llvm::FK_Data_leb128:
+    TA = ELF::R_RISCV_SET_ULEB128;
+    TB = ELF::R_RISCV_SUB_ULEB128;
+    break;
   default:
     llvm_unreachable("unsupported fixup size");
   }
   MCValue A = MCValue::get(Target.getSymA(), nullptr, Target.getConstant());
   MCValue B = MCValue::get(Target.getSymB());
   auto FA = MCFixup::create(
       Fixup.getOffset(), nullptr,
       static_cast<MCFixupKind>(FirstLiteralRelocationKind + TA));

llvm/test/MC/ELF/RISCV/gen-dwarf.s

 # RELOC-NEXT:   0x1C R_RISCV_32_PCREL <null> 0x0
 # RELOC-NEXT:   0x20 R_RISCV_ADD32 <null> 0x0
 # RELOC-NEXT:   0x20 R_RISCV_SUB32 <null> 0x0
 # RELOC-NEXT:   0x25 R_RISCV_SET6 <null> 0x0
 # RELOC-NEXT:   0x25 R_RISCV_SUB6 <null> 0x0
 # RELOC-NEXT:   0x34 R_RISCV_32_PCREL <null> 0x0
 # RELOC-NEXT: }
 
-## TODO A section needs two relocations.
 # RELOC:      Section ([[#]]) .rela.debug_rnglists {
 # RELOC-NEXT:   0xD R_RISCV_64 .text.foo 0x0
+# RELOC-NEXT:   0x15 R_RISCV_SET_ULEB128 <null> 0x0
+# RELOC-NEXT:   0x15 R_RISCV_SUB_ULEB128 .text.foo 0x0
 # RELOC-NEXT:   0x17 R_RISCV_64 .text.bar 0x0
 # RELOC-NEXT: }
 
 # RELOC:      Section ([[#]]) .rela.debug_line {
 # RELOC:        R_RISCV_ADD16 <null> 0x0
 # RELOC-NEXT:   R_RISCV_SUB16 <null> 0x0
 # RELOC-NEXT:   R_RISCV_ADD16 <null> 0x0
 # RELOC-NEXT:   R_RISCV_SUB16 <null> 0x0

llvm/test/MC/RISCV/leb128.s

+# RUN: llvm-mc -filetype=obj -triple=riscv32 -mattr=-relax %s -o %t
+# RUN: llvm-readobj -r -x .alloc_w %t| FileCheck %s
+# RUN: llvm-mc -filetype=obj -triple=riscv32 -mattr=+relax %s -o %t.relax
+# RUN: llvm-readobj -r -x .alloc_w %t.relax | FileCheck %s --check-prefixes=CHECK,RELAX
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=-relax %s -o %t
+# RUN: llvm-readobj -r -x .alloc_w %t | FileCheck %s
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=+relax %s -o %t.relax
+# RUN: llvm-readobj -r -x .alloc_w %t.relax | FileCheck %s --check-prefixes=CHECK,RELAX
+
+## Test temporary workaround for suppressting relocations for actually-non-foldable
+## DWARF v5 DW_LLE_offset_pair/DW_RLE_offset_pair.
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=-relax -riscv-uleb128-reloc=0 %s -o %t0
+# RUN: llvm-readobj -r -x .alloc_w %t0 | FileCheck %s --check-prefix=CHECK0
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=+relax -riscv-uleb128-reloc=0 %s -o %t0.relax
+# RUN: llvm-readobj -r -x .alloc_w %t0.relax | FileCheck %s --check-prefixes=CHECK0,RELAX0
+
+# RUN: not llvm-mc -filetype=obj -triple=riscv64 -mattr=-relax --defsym ERR=1 %s -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ERR
+# RUN: not llvm-mc -filetype=obj -triple=riscv64 -mattr=+relax --defsym ERR=1 %s -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=ERR
+
+# CHECK0:      Relocations [
+# CHECK0-NEXT:   .rela.alloc_w {
+# CHECK0-NEXT:     0x2 R_RISCV_CALL_PLT foo 0x0
+# RELAX0-NEXT:     0x2 R_RISCV_RELAX - 0x0
+# CHECK0-NEXT:   }
+# CHECK0-NEXT: ]
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   .rela.alloc_w {
+# CHECK-NEXT:     0x0 R_RISCV_SET_ULEB128 w1 0x0
+# CHECK-NEXT:     0x0 R_RISCV_SUB_ULEB128 w 0x0
+# RELAX-NEXT:     0x1 R_RISCV_SET_ULEB128 w2 0x0
+# RELAX-NEXT:     0x1 R_RISCV_SUB_ULEB128 w1 0x0
+# CHECK-NEXT:     0x2 R_RISCV_CALL_PLT foo 0x0
+# RELAX-NEXT:     0x2 R_RISCV_RELAX - 0x0
+# RELAX-NEXT:     0xA R_RISCV_SET_ULEB128 w2 0x0
+# RELAX-NEXT:     0xA R_RISCV_SUB_ULEB128 w1 0x0
+# RELAX-NEXT:     0xB R_RISCV_SET_ULEB128 w2 0x78
+# RELAX-NEXT:     0xB R_RISCV_SUB_ULEB128 w1 0x0
+# RELAX-NEXT:     0xD R_RISCV_SET_ULEB128 w1 0x0
+# RELAX-NEXT:     0xD R_RISCV_SUB_ULEB128 w2 0x0
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+## R_RISCV_SET_ULEB128 relocated locations contain values not accounting for linker relaxation.
+# CHECK:      Hex dump of section '.alloc_w':
+# CHECK-NEXT: 0x00000000 02089700 0000e780 00000880 01f8ffff ................
+# CHECK-NEXT: 0x00000010 ffffffff ffff01                     .......
+
+.section .alloc_w,"ax",@progbits; w:
+.uleb128 w1-w       # w1 is later defined in the same section
+.uleb128 w2-w1      # w1 and w2 are separated by a linker relaxable instruction
+w1:
+  call foo
+w2:
+.uleb128 w2-w1      # 0x08
+.uleb128 w2-w1+120  # 0x0180
+.uleb128 -(w2-w1)   # 0x01fffffffffffffffff8
+
+.ifdef ERR
+# ERR: :[[#@LINE+1]]:16: error: .uleb128 expression is not absolute
+.uleb128 extern-w   # extern is undefined
+# ERR: :[[#@LINE+1]]:11: error: .uleb128 expression is not absolute
+.uleb128 w-extern
+# ERR: :[[#@LINE+1]]:11: error: .uleb128 expression is not absolute
+.uleb128 x-w        # x is later defined in another section
+
+.section .alloc_x,"aw",@progbits; x:
+# ERR: :[[#@LINE+1]]:11: error: .uleb128 expression is not absolute
+.uleb128 y-x
+.section .alloc_y,"aw",@progbits; y:
+# ERR: :[[#@LINE+1]]:11: error: .uleb128 expression is not absolute
+.uleb128 x-y
+
+# ERR: :[[#@LINE+1]]:10: error: .uleb128 expression is not absolute
+.uleb128 extern
+# ERR: :[[#@LINE+1]]:10: error: .uleb128 expression is not absolute
+.uleb128 y
+.endif