[RISCV] Emit relocation for uleb128

[kito-cheng]

Summary

Support for the uleb128 related relocation[1], ULEB128 format has used
by DWARF and exception handling table, which used ULEB128 to record data
and the distance of two symbols, however the linker relaxation might
change the symbol address, so we need to insert relocations for those
data to make sure they are still correct after linker relaxation.

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

[kito-cheng]

Changes:

• Add testcase.

[craig.topper]

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

249

Looks like most other places in RISCV use MCFixupKind(RISCV::fixup_riscv_set_uleb128) instead of the static_cast.

[jrtc27]

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

237

encodeULEB128 takes a uint64_t

241

Why not just use encodeULEB128's PadTo and encode 0?

[MaskRay]

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

231

delete the blank line. The prevailing LLVM style does not prefer inserting a blank line after a declaration.

241

-1ll is not tested. This needs a test with llvm-readelf -x $name or llvm-objdump -s dumping the section content.

llvm/test/MC/RISCV/fixups-expr.s

30 ↗

(On Diff #493308)

Suggest: create a new file for .uleb128. Add a test where .uleb128 precedes the label definition (it currently crashes).

Add a test with labels defined relative to two different sections.

I don't have a very strong opinion about whether non-local symbols should be allowed. For psABI, it may be safer to start with more restriction.

[craig.topper]

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

57

59 has been claimed by R_RISCV_PLT32 now.

[kito-cheng]

Changes:

• Update relocation number to 60 and 61.
• Move testcase to fixups-expr-uleb128.s
• Reserved enough bytes when the symbol can't evaluated at assembly time.

[kito-cheng]

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

237

evaluateAsAbsolute take int64_t &...added a check to make sure that won't overflow.

[kito-cheng]

Changes:

• Rebase
• Add new option to control the relocation emition for ULEB128: -riscv-enable-uleb128
• Default disable to prevent potential incompatible issue with old binutils, will default turn on in future.

[kito-cheng]

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

[kito-cheng]

ping :)

[MaskRay]

This patch looks fine as to implement the functionality, but I am afraid that the used requiresFixup and evaluateAsAbsolute are not really reliable (https://maskray.me/blog/2021-03-14-the-dark-side-of-riscv-linker-relaxation "Label differences related to text section symbols"). Ideally we should not need`EnableULEB128Reloc`.

I plan to improve the reliability shortly.

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

33

[kito-cheng]

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

33

The intention of this option is considering the binutils compatibility, binuilts has support that on trunk which will be part of binutils 2.41, but it's still not release yet.

Anyway personally I don't have strong opinion on the default value of this option.

[kito-cheng]

Changes:

• Rebase to trunk.
• Apply @MaskRay's suggesion.

[MaskRay]

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

231

evaluateAsAbsolute has now been correct (D153097). I am now mainly concerned with our inaccurate requiresFixups and whether there will be users rely on a possibly buggy behavior...

llvm/test/MC/RISCV/fixups-expr-uleb128.s

61

Add -NEXT whenever applicable. Check the preceding line .rela.xxx { and the the pairing } to assert that there is no other relocations.

[kito-cheng]

Changes:

• Update testcase to make sure no other unexpected relocation.

[kito-cheng]

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

231

Did you have suggestion on this, I guess I am not really family enough around that :(

[MaskRay]

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

231

I took quite some time today to investigate it.... See D155357

I think we need a custom fixup to represent the fixup_riscv_set_uleb128 and fixup_riscv_sub_uleb128 pair.

In .handleAddSubRelocations, split the fixup into 2 relocations.

[MaskRay]

llvm/test/MC/RISCV/fixups-expr-uleb128.s

60

The interesting case is when we use a linker-relaxable instruction here.

+relax and -relax can check the behavior. See my llvm/test/MC/RISCV/fixups-expr.s change.

[kito-cheng]

Changes:

• Update testcase
• Based on D155357

[kito-cheng]

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

231

Thanks, I am based on D155357 now :)

[kito-cheng]

ping

[MaskRay]

I am out of town for a few days, but I'll try to read this soon.

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

134

Only used once. Inline the variable where it is used.

138

Delete blank line here.

llvm/test/MC/RISCV/fixups-expr-uleb128.s

19

For a cl::opt option that defaults to false, we usually don't test the case when we explicitly set it to false. This additional case doesn't pull its weight.

[kito-cheng]

Changes:

• Address @MaskRay's comments.

[MaskRay]

llvm/include/llvm/MC/MCFixup.h

28

We do not need this generic fixup.

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

164

These fixup_riscv_{set,add,sub}_* from D103539 are unneeded. I did not put the cleanup into D155357 to minimize the changes in D155357 . I have now removed the unneeded fixup kinds in c8ed138c34ddb22610f18468c1b7938f9e2abae5.

I think you can just use FirstLiteralRelocationKind + ELF::R_RISCV_SET_ULEB128 instead of adding new fixup kinds.

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

149

Prefer getContext().reportError for possible error paths. report_fatal_error should be avoided if possible.

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

110

Unneeded. See my other comment.

[MaskRay]

I think the right implementation will be quite different from this patch. We need to modify quite a few more places including shouldForceRelocation, MCAssembler::relaxLEB (new function, similar to relaxDwarf*), and MCObjectStreamer::emitULEB128Value.
I am working on an alternative (current draft: https://github.com/MaskRay/llvm-project/tree/mc-uleb128)

[kito-cheng]

@MaskRay Really appropriate your help! it seems like I didn't handle the dwarf stuffs right according your version, and ULEB128 relocation support might be a compatible issue between GNU and LLVM toolchain, so I wondering do you think it's better to split this patch into add relocation number only and add the lld support(D142880) first for LLVM 17 branch?

[MaskRay]

In D142879#4576026, @kito-cheng wrote:

@MaskRay Really appropriate your help! it seems like I didn't handle the dwarf stuffs right according your version, and ULEB128 relocation support might be a compatible issue between GNU and LLVM toolchain, so I wondering do you think it's better to split this patch into add relocation number only and add the lld support(D142880) first for LLVM 17 branch?

Thanks:) Having the ELF_RELOC(R_RISCV_SET_ULEB128, 60) ... 61 change in release/17.x will be useful.

Having the lld change will be good for our compatibility story if we can catch the release schedule. But it seems that the change is quite complex and I am unsure we have sufficient time...

[kito-cheng]

MaskRay has landed a better version :)

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

 ELF_RELOC(R_RISCV_RELAX,             51)
 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/MCFixup.h

 #include "llvm/Support/SMLoc.h"
 #include <cassert>
 
 namespace llvm {
 class MCExpr;
 
 /// 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_6b,     ///< A six-bits 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.
+  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_6b,      ///< A six-bits fixup.
+  FK_Data_uleb128, ///< A uleb128 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,
 
public:
 
   const MCExpr *getValue() const { return Value; }
 
   /// Return the generic fixup kind for a value with the given size. It
   /// is an error to pass an unsupported size.
   static MCFixupKind getKindForSize(unsigned Size, bool IsPCRel) {
     switch (Size) {
     default: llvm_unreachable("Invalid generic fixup size!");
+    case 0:
+      return FK_Data_uleb128;
     case 1:
       return IsPCRel ? FK_PCRel_1 : FK_Data_1;
     case 2:
       return IsPCRel ? FK_PCRel_2 : FK_Data_2;
     case 4:
       return IsPCRel ? FK_PCRel_4 : FK_Data_4;
     case 8:
       return IsPCRel ? FK_PCRel_8 : FK_Data_8;
     }
   }
 
   /// Return the generic fixup kind for a value with the given size in bits.
   /// It is an error to pass an unsupported size.
   static MCFixupKind getKindForSizeInBits(unsigned Size, bool IsPCRel) {
     switch (Size) {
     default:
       llvm_unreachable("Invalid generic fixup size!");
+    case 0:
+      return FK_Data_uleb128;
     case 6:
       assert(!IsPCRel && "Invalid pc-relative fixup size!");
       return FK_Data_6b;
     case 8:
       return IsPCRel ? FK_PCRel_1 : FK_Data_1;
     case 16:
       return IsPCRel ? FK_PCRel_2 : FK_Data_2;
     case 32:

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_6b", 0, 6, 0},
+      {"FK_Data_uleb128", 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/Target/RISCV/MCTargetDesc/RISCVAsmBackend.cpp

const static MCFixupKindInfo Infos[] = {
       {"fixup_riscv_add_32", 0, 32, 0},
       {"fixup_riscv_sub_32", 0, 32, 0},
 
       {"fixup_riscv_add_64", 0, 64, 0},
       {"fixup_riscv_sub_64", 0, 64, 0},
 
       {"fixup_riscv_set_6b", 2, 6, 0},
       {"fixup_riscv_sub_6b", 2, 6, 0},
+
+      {"fixup_riscv_set_uleb128", 0, 0, 0},
+      {"fixup_riscv_sub_uleb128", 0, 0, 0},
   };
   static_assert((std::size(Infos)) == RISCV::NumTargetFixupKinds,
                 "Not all fixup kinds added to Infos array");
 
   // Fixup kinds from .reloc directive are like R_RISCV_NONE. They
   // do not require any extra processing.
   if (Kind >= FirstLiteralRelocationKind)
     return MCAsmBackend::getFixupKindInfo(FK_NONE);
static uint64_t adjustFixupValue(const MCFixup &Fixup, uint64_t Value,
   case RISCV::fixup_riscv_set_16:
   case RISCV::fixup_riscv_add_16:
   case RISCV::fixup_riscv_sub_16:
   case RISCV::fixup_riscv_set_32:
   case RISCV::fixup_riscv_add_32:
   case RISCV::fixup_riscv_sub_32:
   case RISCV::fixup_riscv_add_64:
   case RISCV::fixup_riscv_sub_64:
+  case RISCV::fixup_riscv_set_uleb128:
+  case RISCV::fixup_riscv_sub_uleb128:
   case FK_Data_1:
   case FK_Data_2:
   case FK_Data_4:
   case FK_Data_8:
   case FK_Data_6b:
+  case FK_Data_uleb128:
     return Value;
   case RISCV::fixup_riscv_set_6b:
     return Value & 0x03;
   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:
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_uleb128:
+    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/lib/Target/RISCV/MCTargetDesc/RISCVELFObjectWriter.cpp

unsigned RISCVELFObjectWriter::getRelocType(MCContext &Ctx,
   case RISCV::fixup_riscv_set_16:
     return ELF::R_RISCV_SET16;
   case RISCV::fixup_riscv_add_16:
     return ELF::R_RISCV_ADD16;
   case RISCV::fixup_riscv_sub_16:
     return ELF::R_RISCV_SUB16;
   case RISCV::fixup_riscv_set_32:
     return ELF::R_RISCV_SET32;
   case RISCV::fixup_riscv_add_32:
     return ELF::R_RISCV_ADD32;
   case RISCV::fixup_riscv_sub_32:
     return ELF::R_RISCV_SUB32;
   case RISCV::fixup_riscv_add_64:
     return ELF::R_RISCV_ADD64;
   case RISCV::fixup_riscv_sub_64:
     return ELF::R_RISCV_SUB64;
+  case RISCV::fixup_riscv_set_uleb128:
+    return ELF::R_RISCV_SET_ULEB128;
+  case RISCV::fixup_riscv_sub_uleb128:
+    return ELF::R_RISCV_SUB_ULEB128;
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createRISCVELFObjectWriter(uint8_t OSABI, bool Is64Bit) {
   return std::make_unique<RISCVELFObjectWriter>(OSABI, Is64Bit);
 }

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

RISCVELFStreamer(MCContext &C, std::unique_ptr<MCAsmBackend> MAB,
                    std::unique_ptr<MCCodeEmitter> MCE)
       : MCELFStreamer(C, std::move(MAB), std::move(MOW), std::move(MCE)) {}
 
   void changeSection(MCSection *Section, const MCExpr *Subsection) override;
   void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
   void emitBytes(StringRef Data) override;
   void emitFill(const MCExpr &NumBytes, uint64_t FillValue, SMLoc Loc) override;
   void emitValueImpl(const MCExpr *Value, unsigned Size, SMLoc Loc) override;
+  void emitULEB128Value(const MCExpr *Value) override;
 };
 
 namespace llvm {
 
 class RISCVTargetELFStreamer : public RISCVTargetStreamer {
 private:
   StringRef CurrentVendor;
 

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

 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCObjectWriter.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCValue.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/RISCVAttributes.h"
 
 using namespace llvm;
 
+static cl::opt<bool>
+    EnableULEB128Reloc("riscv-enable-uleb128", cl::Hidden,
+                       cl::desc("Enable relocation emission for ULEB128."));
+
 // This part is for ELF object output.
 RISCVTargetELFStreamer::RISCVTargetELFStreamer(MCStreamer &S,
                                                const MCSubtargetInfo &STI)
     : RISCVTargetStreamer(S), CurrentVendor("riscv"), STI(STI) {
   MCAssembler &MCA = getStreamer().getAssembler();
   const FeatureBitset &Features = STI.getFeatureBits();
   auto &MAB = static_cast<RISCVAsmBackend &>(MCA.getBackend());
   setTargetABI(RISCVABI::computeTargetABI(STI.getTargetTriple(), Features,
void RISCVTargetELFStreamer::reset() {
   AttributeSection = nullptr;
 }
 
 void RISCVTargetELFStreamer::emitDirectiveVariantCC(MCSymbol &Symbol) {
   getStreamer().getAssembler().registerSymbol(Symbol);
   cast<MCSymbolELF>(Symbol).setOther(ELF::STO_RISCV_VARIANT_CC);
 }
 
+void RISCVELFStreamer::emitULEB128Value(const MCExpr *Value) {
+  if (!EnableULEB128Reloc)
+    return MCELFStreamer::emitULEB128Value(Value);
+
+  int64_t IntValue;
+  unsigned PadTo = 0;
+  if (!Value->evaluateAsAbsolute(IntValue, getAssemblerPtr())) {
+    const FeatureBitset &Features =
+        getContext().getSubtargetInfo()->getFeatureBits();
+    unsigned XLen = Features[RISCV::Feature64Bit] ? 64 : 32;
+
+    // Emit a placeholder to make sure we'll emit enough space could be filled
+    // by linker later.
+    IntValue = 0;
+    // Each byte in ULEB128 format can encoding at most 7 bits.
+    PadTo = divideCeil(XLen, 7);
+  }
+
+  if (IntValue < 0)
+    report_fatal_error("Can't encoding negative value in uleb128 format.");
+
+  MCDataFragment *DF = getOrCreateDataFragment();
+  flushPendingLabels(DF, DF->getContents().size());
+  MCDwarfLineEntry::make(this, getCurrentSectionOnly());
+
+  DF->getFixups().push_back(MCFixup::create(DF->getContents().size(), Value,
+                                            MCFixup::getKindForSize(0, false),
+                                            Value->getLoc()));
+
+  SmallString<128> Tmp;
+  raw_svector_ostream OSE(Tmp);
+  encodeULEB128(IntValue, OSE, PadTo);
+  emitBytes(OSE.str());
+}
+
 void RISCVELFStreamer::reset() {
   static_cast<RISCVTargetStreamer *>(getTargetStreamer())->reset();
   MCELFStreamer::reset();
   MappingSymbolCounter = 0;
   LastMappingSymbols.clear();
   LastEMS = EMS_None;
 }
 

 void RISCVELFStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
                                      SMLoc Loc) {
   emitDataMappingSymbol();
   MCELFStreamer::emitValueImpl(Value, Size, Loc);
 }
 
 namespace llvm {
 MCELFStreamer *createRISCVELFStreamer(MCContext &C,
                                       std::unique_ptr<MCAsmBackend> MAB,
                                       std::unique_ptr<MCObjectWriter> MOW,
                                       std::unique_ptr<MCCodeEmitter> MCE,
                                       bool RelaxAll) {
   RISCVELFStreamer *S =
       new RISCVELFStreamer(C, std::move(MAB), std::move(MOW), std::move(MCE));
   S->getAssembler().setRelaxAll(RelaxAll);
   return S;
 }
 } // namespace llvm

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

enum Fixups {
   // paired relocations.
   fixup_riscv_sub_64,
   // 6-bit fixup corresponding to R_RISCV_SET6 for local label assignment in
   // DWARF CFA.
   fixup_riscv_set_6b,
   // 6-bit fixup corresponding to R_RISCV_SUB6 for local label assignment in
   // DWARF CFA.
   fixup_riscv_sub_6b,
+  // fixup corresponding to R_RISCV_SET_ULEB128 for local label assignment.
+  fixup_riscv_set_uleb128,
+  // fixup corresponding to R_RISCV_SUB_ULEB128 for local label assignment.
+  fixup_riscv_sub_uleb128,
 
   // Used as a sentinel, must be the last
   fixup_riscv_invalid,
   NumTargetFixupKinds = fixup_riscv_invalid - FirstTargetFixupKind
 };
 
 static inline std::pair<MCFixupKind, MCFixupKind>
 getRelocPairForSize(unsigned Size) {

llvm/test/MC/RISCV/fixups-expr-uleb128.s

+# RUN: llvm-mc -filetype=obj -triple=riscv32 -mattr=+relax %s \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,NO-EMIT-RELOC %s
+# RUN: llvm-mc -filetype=obj -triple=riscv32 -mattr=-relax %s \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,NORELAX,NO-EMIT-RELOC %s
+
+# RUN: llvm-mc -filetype=obj -triple=riscv32 -mattr=+relax \
+# RUN:         %s -riscv-enable-uleb128 \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,EMIT-RELOC,EMIT-RELOC-32 %s
+# RUN: llvm-mc -filetype=obj -triple=riscv32 -mattr=-relax \
+# RUN:         %s -riscv-enable-uleb128 \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,NORELAX,NO-EMIT-RELOC %s
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=+relax %s \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,NO-EMIT-RELOC %s
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=-relax %s \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,NORELAX,NO-EMIT-RELOC %s
+
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=+relax \
+# RUN:         %s -riscv-enable-uleb128 \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,EMIT-RELOC,EMIT-RELOC-64 %s
+# RUN: llvm-mc -filetype=obj -triple=riscv64 -mattr=-relax \
+# RUN:         %s -riscv-enable-uleb128 \
+# RUN:     | llvm-readobj -r - \
+# RUN:     | FileCheck -check-prefixes CHECK,NORELAX,NO-EMIT-RELOC %s
+
+# Check that subtraction expressions are emitted as two relocations always.
+
+.text
+.globl G1
+.globl G2
+.L1:
+G1:
+call extern
+.L2:
+G2:
+
+.data
+.uleb128 G3-G1
+.uleb128 .L2-.L1
+.uleb128 G2-G1
+
+# NO-EMIT-RELOC-NOT: R_RISCV_SET_ULEB128
+# NO-EMIT-RELOC-NOT: R_RISCV_SUB_ULEB128
+
+# CHECK: Relocations [
+
+# NORELAX-NEXT:   .rela.text {
+# NORELAX-NEXT:     R_RISCV_CALL_PLT
+# NORELAX-NEXT:   }
+
+# EMIT-RELOC: Section (5) .rela.data {
+# EMIT-RELOC-32:      0x0 R_RISCV_SET_ULEB128 G3 0x0
+# EMIT-RELOC-32-NEXT: 0x0 R_RISCV_SUB_ULEB128 G1 0x0
+# EMIT-RELOC-32-NEXT: 0x5 R_RISCV_SET_ULEB128 .L2 0x0
+# EMIT-RELOC-32-NEXT: 0x5 R_RISCV_SUB_ULEB128 .L1 0x0
+# EMIT-RELOC-32-NEXT: 0xA R_RISCV_SET_ULEB128 G2 0x0
+# EMIT-RELOC-32-NEXT: 0xA R_RISCV_SUB_ULEB128 G1 0x0
+
+# EMIT-RELOC-64:      0x0 R_RISCV_SET_ULEB128 G3 0x0
+# EMIT-RELOC-64-NEXT: 0x0 R_RISCV_SUB_ULEB128 G1 0x0
+# EMIT-RELOC-64-NEXT: 0xA R_RISCV_SET_ULEB128 .L2 0x0
+# EMIT-RELOC-64-NEXT: 0xA R_RISCV_SUB_ULEB128 .L1 0x0
+# EMIT-RELOC-64-NEXT: 0x14 R_RISCV_SET_ULEB128 G2 0x0
+# EMIT-RELOC-64-NEXT: 0x14 R_RISCV_SUB_ULEB128 G1 0x0
+# EMIT-RELOC: }
+# CHECK: ]
+
+.text
+.globl G3
+G3:
+nop