[LLD][ELF][RISCV] Linker relaxation support for R_RISCV_CALL

[s.egerton]

Summary

This patch adds linker relaxation support for RISC-V to LLD. It contains a framework for relocation relaxation as well as support for relaxing R_RISCV_CALL relocations. This can be optionally enabled using the LLD “-relax” flag also added in this patch.

This patch is very similar in nature to https://reviews.llvm.org/D77694. Large amounts of this code were already written when this patch was posted however able to make use of some of the code in there for parts not yet implemented. Thank you for this @jrtc27. In a future patch, I plan to use this to integrate R_RISCV_ALIGN support.

[jrtc27]

I'd argue more of the comments than those highlighted are also pointless. There's no point writing a comment spelling out what the next line of code clearly does. They should be reserved for overviews of what's going on, and the details of why the code is as it is. I'm also curious as to why you went for the optimisation relaxations rather than R_RISCV_ALIGN. Support for the latter is mandatory for correctness when using -mrelax, but the former is purely optional. Therefore, I would strongly argue that support for R_RISCV_ALIGN should be added before or in the same commit as any R_RISCV_RELAX optimisations, otherwise we're just shipping something that's knowingly broken.

lld/ELF/InputSection.cpp

144–145

Yeah, so, this gives rise to the painful O(n^2) binutils deletion approach. My patch avoids this by gathering up all deletions and performing them at once, giving O(nlogn) instead.

147

Again, fatal error.

158

This is unnecessary. makeMutableDataCopy already updates rawData.

162

Pointless comment.

163

Does not match the comment. Also wrong, as a relocation _at_ loc shouldn't be moved, given the existing relaxed relocation is modified rather than replaced.

164

Pointless comment.

198

// If another section is after this section, but I don't think this comment is necessary, it's just repeating (with a bug) what the code says.

lld/ELF/InputSection.h

199

1. This should be loc + sizeof(T) > getSize()
2. This should be a fatal error, not silently ignored

204

This is unnecessary. makeMutableDataCopy already updates rawData.

[MaskRay]

In D79105#2010687, @jrtc27 wrote:

I'd argue more of the comments than those highlighted are also pointless. There's no point writing a comment spelling out what the next line of code clearly does. They should be reserved for overviews of what's going on, and the details of why the code is as it is.

+1

I'm also curious as to why you went for the optimisation relaxations rather than R_RISCV_ALIGN. Support for the latter is mandatory for correctness when using -mrelax, but the former is purely optional.
Therefore, I would strongly argue that support for R_RISCV_ALIGN should be added before or in the same commit as any R_RISCV_RELAX optimisations, otherwise we're just shipping something that's knowingly broken.

+1. My thought is that we need a plan to support R_RISCV_ALIGN first (lld currently does not work with -mrelax code), then think about R_RISCV_RELAX.
However, there is also a backedge. Implementing R_RISCV_ALIGN (which does not require relocation scanning) requires a think about how it will affect R_RISCV_RELAX (which requires relocation scanning).

Implementing both is tricky due to the intertwined logic with scanRelocations and finalizeAddressDependentContent.

I feel that when https://reviews.llvm.org/D77694#1976922 was posted, the previous discussions were not incorporated.

Still, some comments on the code style part. It seems that the good practice in existing comments are simply ignored.

lld/ELF/Arch/RISCV.cpp

496

clang-format

509

Delete braces around simple statements

lld/test/ELF/riscv-relax-call-5.s

12

check prefixes are upper cased.

20

Use -NEXT: where applicable. This makes test updating easier.

49

Use ## for comments.

95

2 spaces are sufficient for indentation.

[s.egerton]

Thank you both for the valuable feedback, I will be working through addressing both of your suggestions.

The logic behind supporting R_RISCV_CALL before R_RISCV_ALIGN is that I hope to implement more optimisation relaxations and wanted to have one in place to act as a base. Additionally, I did not expect this to land before R_RISCV_ALIGN support is present.

Based on your comments about having both is tricky, it may be worth having the two working together in the same patch.

[s.egerton]

I've made some changes in response to your feedback. No R_RISCV_ALIGN support
added yet but it is work in progress.

[s.egerton]

As mentioned, I plan to add R_RISCV_ALIGN support in future along with the suggested changes to the test cases.

lld/ELF/InputSection.cpp

151

Missed this one, will remove this in the next revision.

[jrtc27]

lld/ELF/InputSection.cpp

175

So this is still quadratic (O(nm)).

192

Also quadratic.

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"

 namespace elf {
 
 namespace {
 
 class RISCV final : public TargetInfo {
 public:
   RISCV();
   uint32_t calcEFlags() const override;
+  bool inBranchRange(RelType type, uint64_t src, uint64_t dst) const override;
   void writeGotHeader(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, 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 relax(InputSection &inputSection, Relocation &rel,
+             std::vector<std::pair<const uint64_t, const uint64_t>>
+                 &bytesToDelete) const override;
+  void relaxSection(InputSection &inputSection) const override;
+  void
+  relaxRelocationCall(InputSection &inputSection, Relocation &rel,
+                      std::vector<std::pair<const uint64_t, const uint64_t>>
+                          &bytesToDelete) const;
 };
 
 } // end anonymous namespace
 
 const uint64_t dtpOffset = 0x800;
 
 enum Op {
   ADDI = 0x13,
   AUIPC = 0x17,
+  CJ = 0xa001,
+  CJAL = 0x2001,
+  JAL = 0x6F,
   JALR = 0x67,
   LD = 0x3003,
   LW = 0x2003,
   SRLI = 0x5013,
   SUB = 0x40000033,
 };
 
 enum Reg {
+  X_ZERO = 0,
   X_RA = 1,
   X_T0 = 5,
   X_T1 = 6,
   X_T2 = 7,
   X_T3 = 28,
 };
 
 static uint32_t hi20(uint32_t val) { return (val + 0x800) >> 12; }
 static uint32_t lo12(uint32_t val) { return val & 4095; }
 
+// 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) {
+  return (v & ((1ULL << (begin + 1)) - 1)) >> end;
+}
+
+static uint32_t encodeImmJType(const int32_t input) {
+  return (extractBits(input, 20, 20) << 31) |
+         (extractBits(input, 10, 1) << 21) |
+         (extractBits(input, 11, 11) << 20) |
+         (extractBits(input, 19, 12) << 12);
+}
+
+static uint16_t encodeImmCJType(const int16_t input) {
+  return (extractBits(input, 11, 11) << 12) | (extractBits(input, 4, 4) << 11) |
+         (extractBits(input, 9, 8) << 9) | (extractBits(input, 10, 10) << 8) |
+         (extractBits(input, 6, 6) << 7) | (extractBits(input, 7, 7) << 6) |
+         (extractBits(input, 3, 1) << 3) | (extractBits(input, 5, 5) << 2);
+}
+
+static uint16_t cjtype(uint16_t op, uint16_t offset) {
+  return op | encodeImmCJType(offset);
+}
 static uint32_t itype(uint32_t op, uint32_t rd, uint32_t rs1, uint32_t imm) {
   return op | (rd << 7) | (rs1 << 15) | (imm << 20);
 }
+static uint32_t jtype(uint8_t op, uint8_t rd, uint32_t imm) {
+  return op | (rd << 7) | encodeImmJType(imm);
+}
 static uint32_t rtype(uint32_t op, uint32_t rd, uint32_t rs1, uint32_t rs2) {
   return op | (rd << 7) | (rs1 << 15) | (rs2 << 20);
 }
 static uint32_t utype(uint32_t op, uint32_t rd, uint32_t imm) {
   return op | (rd << 7) | (imm << 12);
 }
 
 RISCV::RISCV() {
RelExpr RISCV::getRelExpr(const RelType type, const Symbol &s,
   case R_RISCV_TLS_GOT_HI20:
     config->hasStaticTlsModel = true;
     return R_GOT_PC;
   case R_RISCV_TPREL_HI20:
   case R_RISCV_TPREL_LO12_I:
   case R_RISCV_TPREL_LO12_S:
     return R_TLS;
   case R_RISCV_RELAX:
+    return R_ABS;
   case R_RISCV_TPREL_ADD:
     return R_NONE;
   case R_RISCV_ALIGN:
     // Not just a hint; always padded to the worst-case number of NOPs, so may
     // not currently be aligned, and without linker relaxation support we can't
     // delete NOPs to realign.
     errorOrWarn(getErrorLocation(loc) + "relocation R_RISCV_ALIGN requires "
                 "unimplemented linker relaxation; recompile with -mno-relax");
     return R_NONE;
   default:
     error(getErrorLocation(loc) + "unknown relocation (" + Twine(type) +
           ") against symbol " + toString(s));
     return R_NONE;
   }
 }
 
-// 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) {
-  return (v & ((1ULL << (begin + 1)) - 1)) >> end;
+void RISCV::relaxSection(InputSection &inputSection) const {
+  std::vector<std::pair<const uint64_t, const uint64_t>> bytesToDelete;
+  const auto end = std::end(inputSection.relocations);
+  for (auto it = std::begin(inputSection.relocations); it != end; ++it) {
+    // Check if each relocation is paired with an R_RISCV_RELAX before
+    // relaxation.
+    if (it + 1 == end || (it + 1)->type != R_RISCV_RELAX ||
+        it->offset != (it + 1)->offset)
+      continue;
+
+    relax(inputSection, *it, bytesToDelete);
+
+    // Skip over the R_RISCV_RELAX.
+    ++it;
+  }
+  inputSection.deleteBytes(bytesToDelete);
+}
+
+void RISCV::relax(InputSection &inputSection, Relocation &rel,
+                  std::vector<std::pair<const uint64_t, const uint64_t>>
+                      &bytesToDelete) const {
+  switch (rel.type) {
+  // auipc + jalr pair
+  case R_RISCV_CALL:
+  case R_RISCV_CALL_PLT: {
+    relaxRelocationCall(inputSection, rel, bytesToDelete);
+    return;
+  }
+  }
 }
 
 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);
case R_RISCV_RVC_BRANCH: {
 
     write16le(loc, insn);
     return;
   }
 
   case R_RISCV_RVC_JUMP: {
     checkInt(loc, static_cast<int64_t>(val) >> 1, 11, 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;
-    uint16_t imm3_1 = extractBits(val, 3, 1) << 3;
-    uint16_t imm5 = extractBits(val, 5, 5) << 2;
-    insn |= imm11 | imm4 | imm9_8 | imm10 | imm6 | imm7 | imm3_1 | imm5;
 
-    write16le(loc, insn);
+    write16le(loc, cjtype(read16le(loc) & 0xE003, val));
     return;
   }
 
   case R_RISCV_RVC_LUI: {
     int64_t imm = SignExtend64(val + 0x800, bits) >> 12;
     checkInt(loc, imm, 6, rel);
     if (imm == 0) { // `c.lui rd, 0` is illegal, convert to `c.li rd, 0`
       write16le(loc, (read16le(loc) & 0x0F83) | 0x4000);
     } else {
       uint16_t imm17 = extractBits(val + 0x800, 17, 17) << 12;
       uint16_t imm16_12 = extractBits(val + 0x800, 16, 12) << 2;
       write16le(loc, (read16le(loc) & 0xEF83) | imm17 | imm16_12);
     }
     return;
   }
 
   case R_RISCV_JAL: {
     checkInt(loc, static_cast<int64_t>(val) >> 1, 20, rel);
     checkAlignment(loc, val, 2, rel);
 
-    uint32_t insn = read32le(loc) & 0xFFF;
-    uint32_t imm20 = extractBits(val, 20, 20) << 31;
-    uint32_t imm10_1 = extractBits(val, 10, 1) << 21;
-    uint32_t imm11 = extractBits(val, 11, 11) << 20;
-    uint32_t imm19_12 = extractBits(val, 19, 12) << 12;
-    insn |= imm20 | imm10_1 | imm11 | imm19_12;
+    const auto insn = read32le(loc);
+    const uint8_t opcode = extractBits(insn, 6, 0);
+    const uint8_t reg = extractBits(insn, 11, 7);
 
-    write32le(loc, insn);
+    write32le(loc, jtype(opcode, reg, val));
     return;
   }
 
   case R_RISCV_BRANCH: {
     checkInt(loc, static_cast<int64_t>(val) >> 1, 12, rel);
     checkAlignment(loc, val, 2, rel);
 
     uint32_t insn = read32le(loc) & 0x1FFF07F;
case R_RISCV_TLS_DTPREL32:
     break;
   case R_RISCV_TLS_DTPREL64:
     write64le(loc, val - dtpOffset);
     break;
 
   case R_RISCV_RELAX:
     return; // Ignored (for now)
 
   default:
     llvm_unreachable("unknown relocation");
   }
 }
 
 TargetInfo *getRISCVTargetInfo() {
   static RISCV target;
   return &target;
 }
 
+enum RISCVImmediateSize { IType = 12, JType = 21, UType = 21, CJType = 11 };
+
+bool RISCV::inBranchRange(RelType type, uint64_t src, uint64_t dst) const {
+  // Compute the number of bits that are available to store the branch range
+  const uint8_t range = [&type]() -> uint8_t {
+    switch (type) {
+    case R_RISCV_RVC_JUMP:
+      return RISCVImmediateSize::CJType;
+    case R_RISCV_JAL:
+      return RISCVImmediateSize::JType;
+    default:
+      llvm_unreachable(
+          "unknown relocation type, cannot calculate inBranchBrange");
+    }
+  }();
+
+  // Convert the range from number of bits it can be stored in to an explicit
+  // maximum distance away in bits
+  const uint64_t distance = 1 << range;
+
+  bool withinUpperRange = true;
+  bool withinLowerRange = true;
+
+  // If src + distance doesn't cause an integer overflow then check if
+  // it's within the upper range.
+  if (distance < std::numeric_limits<uint64_t>::max() - src)
+    withinUpperRange = dst <= src + distance;
+
+  // If src - distance doesn't cause an integer underflow then check if
+  // it's within the lower range.
+  if (src >= distance)
+    withinLowerRange = dst >= src - distance;
+
+  return withinUpperRange && withinLowerRange;
+}
+
+void RISCV::relaxRelocationCall(
+    InputSection &inputSection, Relocation &rel,
+    std::vector<std::pair<const uint64_t, const uint64_t>> &bytesToDelete)
+    const {
+  // The address to be jumped to.
+  const uint64_t targetLoc = rel.sym->getVA();
+  // The address we are jumping from.
+  const uint64_t loc = inputSection.getVA() + rel.offset;
+
+  const auto jalr = inputSection.data()[rel.offset + 4];
+  const uint8_t rd = extractBits(jalr, 11, 7);
+
+  // C.JAL is RV32 only but C.J is not.
+  const bool RVC_enabled = (config->eflags & EF_RISCV_RVC) &&
+                           (rd == 0 || (!config->is64 && rd == X_RA));
+
+  // Convert to C.J or C.JAL.
+  if (RVC_enabled && inBranchRange(R_RISCV_RVC_JUMP, loc, targetLoc)) {
+    const uint16_t compressedInsn = rd == 0 ? CJ : CJAL;
+
+    // Write over the auipc instruction
+    inputSection.edit(rel.offset, cjtype(compressedInsn, 0));
+    bytesToDelete.emplace_back(rel.offset + 2, 6);
+    rel.type = R_RISCV_RVC_JUMP;
+
+  // Convert to JAL.
+  } else if (inBranchRange(R_RISCV_JAL, loc, targetLoc)) {
+    // Write over the auipc instruction
+    inputSection.edit(rel.offset, jtype(JAL, X_RA, 0));
+    bytesToDelete.emplace_back(rel.offset + 4, 4);
+    rel.type = R_RISCV_JAL;
+
+  // Convert to x0 offset JALR.
+  // As this is zero offset, the exact address goes into
+  // the immediate, meaning as long as it fits we don't
+  // need to check if inBranchRange.
+  } else if (isInt<RISCVImmediateSize::IType>(targetLoc)) {
+    // Write over the auipc instruction
+    inputSection.edit(rel.offset, itype(JALR, X_RA, X_ZERO, 0));
+    bytesToDelete.emplace_back(rel.offset + 4, 4);
+    rel.type = R_RISCV_LO12_I;
+    rel.expr = R_ABS; // This is x0 offset, no longer PC relative.
+  }
+  return;
+}
 } // namespace elf
 } // namespace lld

lld/ELF/Config.h

struct Configuration {
   bool oFormatBinary;
   bool omagic;
   bool optimizeBBJumps;
   bool optRemarksWithHotness;
   bool picThunk;
   bool pie;
   bool printGcSections;
   bool printIcfSections;
+  bool relax;
   bool relocatable;
   bool relrPackDynRelocs;
   bool saveTemps;
   llvm::Optional<uint32_t> shuffleSectionSeed;
   bool singleRoRx;
   bool shared;
   bool isStatic = false;
   bool sysvHash = false;

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->printIcfSections =
       args.hasFlag(OPT_print_icf_sections, OPT_no_print_icf_sections, false);
   config->printGcSections =
       args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
   config->printArchiveStats = args.getLastArgValue(OPT_print_archive_stats);
   config->printSymbolOrder =
       args.getLastArgValue(OPT_print_symbol_order);
   config->rpath = getRpath(args);
+  config->relax = args.hasArg(OPT_relax);
   config->relocatable = args.hasArg(OPT_relocatable);
   config->saveTemps = args.hasArg(OPT_save_temps);
   if (args.hasArg(OPT_shuffle_sections))
     config->shuffleSectionSeed = args::getInteger(args, OPT_shuffle_sections, 0);
   config->searchPaths = args::getStrings(args, OPT_library_path);
   config->sectionStartMap = getSectionStartMap(args);
   config->shared = args.hasArg(OPT_shared);
   config->singleRoRx = !args.hasFlag(OPT_rosegment, OPT_no_rosegment, true);

lld/ELF/InputSection.h

public:
   }
 
   ArrayRef<uint8_t> data() const {
     if (uncompressedSize >= 0)
       uncompress();
     return rawData;
   }
 
+  MutableArrayRef<uint8_t> mutableData() const {
+    if (!copiedData)
+      makeMutableDataCopy();
+    return llvm::makeMutableArrayRef(const_cast<uint8_t *>(rawData.data()),
+                                     rawData.size());
+  }
+
   uint64_t getOffsetInFile() const;
 
   // Input sections are part of an output section. Special sections
   // like .eh_frame and merge sections are first combined into a
   // synthetic section that is then added to an output section. In all
   // cases this points one level up.
   SectionBase *parent = nullptr;
 
public:
   }
 
   // InputSections that are dependent on us (reverse dependency for GC)
   llvm::TinyPtrVector<InputSection *> dependentSections;
 
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const;
 
+  // Edits the rawData, by writing newData over the existing data, at the
+  // position given by loc.
+  template <typename T> void edit(uint64_t loc, T newData) const {
+    if (loc + sizeof(T) > getSize())
+      llvm_unreachable("Cannot edit - out of range\n");
+    auto mutData = mutableData();
+    memcpy(&mutData[loc], &newData, sizeof(T));
+  }
+
+  void
+  deleteBytes(const std::vector<std::pair<const uint64_t, const uint64_t>>
+                  &ranges);
+
   InputSection *getLinkOrderDep() const;
 
   // Get the function symbol that encloses this offset from within the
   // section.
   template <class ELFT>
   Defined *getEnclosingFunction(uint64_t offset);
 
   // Returns a source location string. Used to construct an error message.
protected:
 
   mutable ArrayRef<uint8_t> rawData;
 
   // This field stores the uncompressed size of the compressed data in rawData,
   // or -1 if rawData is not compressed (either because the section wasn't
   // compressed in the first place, or because we ended up uncompressing it).
   // Since the feature is not used often, this is usually -1.
   mutable int64_t uncompressedSize = -1;
+
+  void makeMutableDataCopy() const;
+
+  // This field stores whether we have made a mutable copy of the data, either
+  // because we have uncompressed it or because during relaxation we have had
+  // to rewrite the contents.
+  mutable bool copiedData = false;
 };
 
 // SectionPiece represents a piece of splittable section contents.
 // We allocate a lot of these and binary search on them. This means that they
 // have to be as compact as possible, which is why we don't store the size (can
 // be found by looking at the next one).
 struct SectionPiece {
   SectionPiece(size_t off, uint32_t hash, bool live)

lld/ELF/InputSection.cpp

 
 size_t InputSectionBase::getSize() const {
   if (auto *s = dyn_cast<SyntheticSection>(this))
     return s->getSize();
   if (uncompressedSize >= 0)
     return uncompressedSize;
   return rawData.size() - bytesDropped;
 }
 
+void InputSectionBase::deleteBytes(
+    const std::vector<std::pair<const uint64_t, const uint64_t>> &ranges) {
+  uint64_t totalBytesDeleted = 0;
+  const auto mutData = mutableData();
+  uint8_t *buf = mutData.data();
+  const auto size = getSize();
+  // for (const auto &range : ranges) {
+  const auto end = std::end(ranges);
+  for (auto it = std::begin(ranges); it != end; ++it) {
+    const auto loc = it->first;
+    const auto numberOfBytes = it->second;
+
+    // Don't try and delete bytes that are out of bounds.
+    if (loc + numberOfBytes > getSize())
+      llvm_unreachable(loc + " Cannot delete - out of range\n");
+
+    // Remove the bytes from rawData.
+    const auto destinationAddress = buf + loc - totalBytesDeleted;
+    const auto sourceAddress = buf + loc + numberOfBytes;
+    const auto nextOffset = it + 1 == end ? size : (it + 1)->first;
+    memmove(destinationAddress, sourceAddress,
+            nextOffset - loc - numberOfBytes);
+    totalBytesDeleted += numberOfBytes;
+  }
+  rawData = makeArrayRef(buf, getSize() - totalBytesDeleted);
+
+  // Adjust all relocations in this section.
+  for (Relocation &relocation : relocations) {
+    uint64_t distanceToMove = 0;
+    // Count up the total distance to shift each relocation before shifting.
+    for (const auto &range : ranges) {
+      if (range.first < relocation.offset)
+        distanceToMove += range.second;
+    }
+    relocation.offset -= distanceToMove;
+  }
+
+  // Adjust symbols in this section.
+  // for (const auto &symbol : file->getSymbols()) {
+  for (const auto &symbol : in.symTab->getSymbols()) {
+    auto *definedSymbol = dyn_cast<Defined>(symbol.sym);
+    if (!definedSymbol || definedSymbol->section != this)
+      continue;
+
+    const auto symbolStart = definedSymbol->value;
+    const auto symbolEnd = symbolStart + definedSymbol->size;
+
+    for (const auto &range : ranges) {
+      const auto loc = range.first;
+      const auto numberOfBytes = range.second;
+      if (symbolStart <= loc && loc < symbolEnd)
+        definedSymbol->size -= numberOfBytes;
+
+      if (symbolStart >= loc + numberOfBytes)
+        definedSymbol->value -= numberOfBytes;
+    }
+  }
+
+  auto outputSection = getOutputSection();
+
+  // Close the gaps between sections by adjusting their addresses.
+  for (const auto otherSection : outputSections) {
+    if (otherSection->addr > outputSection->addr)
+      otherSection->addr -= totalBytesDeleted;
+  }
+
+  outputSection->size -= totalBytesDeleted;
+}
+
 void InputSectionBase::uncompress() const {
   size_t size = uncompressedSize;
   char *uncompressedBuf;
   {
     static std::mutex mu;
     std::lock_guard<std::mutex> lock(mu);
     uncompressedBuf = bAlloc.Allocate<char>(size);
   }
if (partition != other->partition) {
     for (InputSection *isec : dependentSections)
       isec->partition = 1;
   }
 
   other->repl = repl;
   other->markDead();
 }
 
+void InputSectionBase::makeMutableDataCopy() const {
+  static std::mutex mu;
+  std::lock_guard<std::mutex> lock(mu);
+
+  ArrayRef<uint8_t> oldRef = data();
+  // In case the above just uncompressed
+  if (copiedData)
+    return;
+
+  size_t size = oldRef.size();
+  uint8_t *newData = bAlloc.Allocate<uint8_t>(size);
+  memcpy(newData, oldRef.data(), size);
+  rawData = makeArrayRef(newData, size);
+}
+
 template <class ELFT>
 EhInputSection::EhInputSection(ObjFile<ELFT> &f,
                                const typename ELFT::Shdr &header,
                                StringRef name)
     : InputSectionBase(f, header, name, InputSectionBase::EHFrame) {}
 
 SyntheticSection *EhInputSection::getParent() const {
   return cast_or_null<SyntheticSection>(parent);

lld/ELF/Options.td

 defm reproduce: Eq<"reproduce", "Write a tar file containing input files and command line options to reproduce link">;
 
 defm rosegment: B<"rosegment",
   "Put read-only non-executable sections in their own segment (default)",
   "Do not put read-only non-executable sections in their own segment">;
 
 defm rpath: Eq<"rpath", "Add a DT_RUNPATH to the output">;
 
+def relax: F<"relax">, HelpText<"Enable linker relaxation">;
+
 def relocatable: F<"relocatable">, HelpText<"Create relocatable object file">;
 
 defm retain_symbols_file:
   Eq<"retain-symbols-file", "Retain only the symbols listed in the file">,
   MetaVarName<"<file>">;
 
 defm script: Eq<"script", "Read linker script">;
 

lld/ELF/Target.h

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 applyJumpInstrMod(uint8_t *loc, JumpModType type,
                                  JumpModType val) const {}
 
+  virtual void relaxSection(InputSection &inputSection) const {
+    return;
+  };
+
+  virtual void
+  relax(InputSection &inputSection, Relocation &rel,
+        std::vector<std::pair<const uint64_t, const uint64_t>>
+            &bytesToDelete) const {
+    return;
+  };
+
   virtual ~TargetInfo();
 
   // This deletes a jump insn at the end of the section if it is a fall thru to
   // the next section.  Further, if there is a conditional jump and a direct
   // jump consecutively, it tries to flip the conditional jump to convert the
   // direct jump into a fall thru and delete it.  Returns true if a jump
   // instruction can be deleted.
   virtual bool deleteFallThruJmpInsn(InputSection &is, InputFile *file,

lld/ELF/Writer.cpp

private:
 
   std::vector<PhdrEntry *> createPhdrs(Partition &part);
   void addPhdrForSection(Partition &part, unsigned shType, unsigned pType,
                          unsigned pFlags);
   void assignFileOffsets();
   void assignFileOffsetsBinary();
   void setPhdrs(Partition &part);
   void checkSections();
+  void relaxSections();
   void fixSectionAlignments();
   void openFile();
   void writeTrapInstr();
   void writeHeader();
   void writeSections();
   void writeSectionsBinary();
   void writeBuildId();
 
if (script->hasSectionsCommand)
     script->allocateHeaders(mainPart->phdrs);
 
   // Remove empty PT_LOAD to avoid causing the dynamic linker to try to mmap a
   // 0 sized region. This has to be done late since only after assignAddresses
   // we know the size of the sections.
   for (Partition &part : partitions)
     removeEmptyPTLoad(part.phdrs);
 
+  if (config->relax)
+    relaxSections();
+
   if (!config->oFormatBinary)
     assignFileOffsets();
   else
     assignFileOffsetsBinary();
 
   for (Partition &part : partitions)
     setPhdrs(part);
 
template <class ELFT> void Writer<ELFT>::checkSections() {
   // script with AT().
   std::vector<SectionOffset> lmas;
   for (OutputSection *sec : outputSections)
     if (sec->size > 0 && (sec->flags & SHF_ALLOC) && !(sec->flags & SHF_TLS))
       lmas.push_back({sec, sec->getLMA()});
   checkOverlap("load address", lmas, false);
 }
 
+template <class ELFT> void Writer<ELFT>::relaxSections() {
+  for (InputSectionBase *inputSection : inputSections) {
+    target->relaxSection(cast<InputSection>(*inputSection));
+  }
+}
+
 // The entry point address is chosen in the following ways.
 //
 // 1. the '-e' entry command-line option;
 // 2. the ENTRY(symbol) command in a linker control script;
 // 3. the value of the symbol _start, if present;
 // 4. the number represented by the entry symbol, if it is a number;
 // 5. the address of the first byte of the .text section, if present;
 // 6. the address 0.

lld/test/ELF/riscv-relax-call-2.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o --defsym foo=8 -relax -o %t.rv32
+# RUN: ld.lld %t.rv64.o --defsym foo=8 -relax -o %t.rv64
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+# 32: 110b4: ef e0 5e f5   jal     -69804 <foo>
+# 32: 110b8: ef e0 1e f5   jal     -69808 <foo>
+# 32: 110bc: ef e0 de f4   jal     -69812 <foo>
+
+# 64: 11120: ef e0 9e ee   jal     -69912 <foo>
+# 64: 11124: ef e0 5e ee   jal     -69916 <foo>
+# 64: 11128: ef e0 1e ee   jal     -69920 <foo>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 000110b4    12 NOTYPE  GLOBAL DEFAULT     1 _start
+# Symbols32:     2: 00000008     0 NOTYPE  GLOBAL DEFAULT   ABS foo
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# Symbols64:     1: 0000000000011120    12 NOTYPE  GLOBAL DEFAULT     1 _start
+# Symbols64:     2: 0000000000000008     0 NOTYPE  GLOBAL DEFAULT   ABS foo
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 00000c 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 0000c0 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 0000c8 000030 10      5   1  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 0000f8 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 000122 00000c 00      0   0  1
+
+#Sections64: Section Headers:
+#Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+#Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+#Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 00000c 00  AX  0   0  4
+#Sections64:   [ 2] .comment          PROGBITS        0000000000000000 00012c 000008 01  MS  0   0  1
+#Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 000138 000048 18      5   1  8
+#Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 000180 00002a 00      0   0  1
+#Sections64:   [ 5] .strtab           STRTAB          0000000000000000 0001aa 00000c 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x0000c 0x0000c R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000120 0x0000000000011120 0x0000000000011120 0x00000c 0x00000c R E 0x1000
+
+.global _start
+_start:
+    call    foo
+    call    foo
+    call    foo
+    .size _start, . - _start

lld/test/ELF/riscv-relax-call-3.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o -relax -o %t.rv32
+# RUN: ld.lld %t.rv64.o -relax -o %t.rv64
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+# This tests jumping over another relocation that will later be relaxed.
+
+# 32: 000110b4 <_start>:
+# 32:    110b4: ef 00 80 00                   jal     8 <bar>
+
+# 32: 000110b8 <foo>:
+# 32:    110b8: ef f0 df ff                   jal     -4 <_start>
+
+# 32: 000110bc <bar>:
+# 32:    110bc: ef f0 9f ff                   jal     -8 <_start>
+
+
+# 64: 0000000000011120 <_start>:
+# 64:    11120: ef 00 80 00                   jal     8 <bar>
+
+# 64: 0000000000011124 <foo>:
+# 64:    11124: ef f0 df ff                   jal     -4 <_start>
+
+# 64: 0000000000011128 <bar>:
+# 64:    11128: ef f0 9f ff                   jal     -8 <_start>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 000110bc     4 NOTYPE  LOCAL  DEFAULT     1 bar
+# Symbols32:     2: 000110b8     4 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols32:     3: 000110b4     4 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# Symbols64:     1: 0000000000011128     4 NOTYPE  LOCAL  DEFAULT     1 bar
+# Symbols64:     2: 0000000000011124     4 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols64:     3: 0000000000011120     4 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 00000c 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 0000c0 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 0000c8 000040 10      5   3  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 000108 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 000132 000010 00      0   0  1
+
+# Sections64: Section Headers:
+# Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 00000c 00  AX  0   0  4
+# Sections64:   [ 2] .comment          PROGBITS        0000000000000000 00012c 000008 01  MS  0   0  1
+# Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 000138 000060 18      5   3  8
+# Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 000198 00002a 00      0   0  1
+# Sections64:   [ 5] .strtab           STRTAB          0000000000000000 0001c2 000010 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x0000c 0x0000c R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000120 0x0000000000011120 0x0000000000011120 0x00000c 0x00000c R E 0x1000
+
+
+.global _start
+_start:
+    call    bar
+    .size _start, . - _start
+
+foo:
+    call    _start
+    .size foo, . - foo
+
+bar:
+    call    _start
+    .size bar, . - bar

lld/test/ELF/riscv-relax-call-4.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o -relax -o %t.rv32
+# RUN: ld.lld %t.rv64.o -relax -o %t.rv64
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+# This tests many succesive calls to the same location that will all be relaxed
+
+# 32: 000110b4 <_start>:
+# 32:    110b4: ef 00 80 01                   jal     24 <foo>
+# 32:    110b8: ef 00 40 01                   jal     20 <foo>
+# 32:    110bc: ef 00 00 01                   jal     16 <foo>
+# 32:    110c0: ef 00 c0 00                   jal     12 <foo>
+# 32:    110c4: ef 00 80 00                   jal     8 <foo>
+# 32:    110c8: ef 00 40 00                   jal     4 <foo>
+
+# 32: 000110cc <foo>:
+# 32:    110cc: ef f0 9f fe                   jal     -24 <_start>
+
+# 64: 0000000000011120 <_start>:
+# 64:    11120: ef 00 80 01                   jal     24 <foo>
+# 64:    11124: ef 00 40 01                   jal     20 <foo>
+# 64:    11128: ef 00 00 01                   jal     16 <foo>
+# 64:    1112c: ef 00 c0 00                   jal     12 <foo>
+# 64:    11130: ef 00 80 00                   jal     8 <foo>
+# 64:    11134: ef 00 40 00                   jal     4 <foo>
+
+# 64: 0000000000011138 <foo>:
+# 64:    11138: ef f0 9f fe                   jal     -24 <_start>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 000110cc     4 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols32:     2: 000110b4    24 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# Symbols64:     1: 0000000000011138     4 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols64:     2: 0000000000011120    24 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 00001c 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 0000d0 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 0000d8 000030 10      5   2  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 000108 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 000132 00000c 00      0   0  1
+
+# Sections64: Section Headers:
+# Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 00001c 00  AX  0   0  4
+# Sections64:   [ 2] .comment          PROGBITS        0000000000000000 00013c 000008 01  MS  0   0  1
+# Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 000148 000048 18      5   2  8
+# Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 000190 00002a 00      0   0  1
+# Sections64:   [ 5] .strtab           STRTAB          0000000000000000 0001ba 00000c 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x0001c 0x0001c R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000120 0x0000000000011120 0x0000000000011120 0x00001c 0x00001c R E 0x1000
+
+.global _start
+_start:
+    call    foo
+    call    foo
+    call    foo
+    call    foo
+    call    foo
+    call    foo
+    .size _start, . - _start
+
+foo:
+    call    _start
+    .size foo, . - foo

lld/test/ELF/riscv-relax-call-5.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o -relax -o %t.rv32
+# RUN: ld.lld %t.rv64.o -relax -o %t.rv64
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+# 32: 000110b4 <_start>:
+# 32: 110b4: ef 00 00 00                   jal     0 <_start>
+# 32: 110b8: ef 00 80 00                   jal     8 <foo>
+# 32: 110bc: ef 00 00 01                   jal     16 <bar>
+
+# 32: 000110c0 <foo>:
+# 32: 110c0: ef f0 5f ff                   jal     -12 <_start>
+# 32: 110c4: ef f0 df ff                   jal     -4 <foo>
+# 32: 110c8: ef 00 40 00                   jal     4 <bar>
+
+# 32: 000110cc <bar>:
+# 32: 110cc: ef f0 9f fe                   jal     -24 <_start>
+# 32: 110d0: ef f0 1f ff                   jal     -16 <foo>
+# 32: 110d4: ef f0 9f ff                   jal     -8 <bar>
+
+# 64: 0000000000011120 <_start>:
+# 64:    11120: ef 00 00 00                   jal     0 <_start>
+# 64:    11124: ef 00 80 00                   jal     8 <foo>
+# 64:    11128: ef 00 00 01                   jal     16 <bar>
+
+# 64: 000000000001112c <foo>:
+# 64:    1112c: ef f0 5f ff                   jal     -12 <_start>
+# 64:    11130: ef f0 df ff                   jal     -4 <foo>
+# 64:    11134: ef 00 40 00                   jal     4 <bar>
+
+# 64: 0000000000011138 <bar>:
+# 64:    11138: ef f0 9f fe                   jal     -24 <_start>
+# 64:    1113c: ef f0 1f ff                   jal     -16 <foo>
+# 64:    11140: ef f0 9f ff                   jal     -8 <bar>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 000110cc    12 NOTYPE  LOCAL  DEFAULT     1 bar
+# Symbols32:     2: 000110c0    12 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols32:     3: 000110b4    12 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# Symbols64:     1: 0000000000011138    12 NOTYPE  LOCAL  DEFAULT     1 bar
+# Symbols64:     2: 000000000001112c    12 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols64:     3: 0000000000011120    12 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 000024 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 0000d8 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 0000e0 000040 10      5   3  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 000120 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 00014a 000010 00      0   0  1
+
+# Sections64: Section Headers:
+# Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 000024 00  AX  0   0  4
+# Sections64:   [ 2] .comment          PROGBITS        0000000000000000 000144 000008 01  MS  0   0  1
+# Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 000150 000060 18      5   3  8
+# Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 0001b0 00002a 00      0   0  1
+# Sections64:   [ 5] .strtab           STRTAB          0000000000000000 0001da 000010 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x00024 0x00024 R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000120 0x0000000000011120 0x0000000000011120 0x000024 0x000024 R E 0x1000
+
+# This tests many successive calls to the same location that will all be relaxed
+
+.global _start
+_start:
+    call    _start
+    call    foo
+    call    bar
+    .size _start, . - _start
+
+foo:
+    call    _start
+    call    foo
+    call    bar
+    .size foo, . - foo
+
+bar:
+    call    _start
+    call    foo
+    call    bar
+    .size bar, . - bar

lld/test/ELF/riscv-relax-call-6.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o --defsym foo=8 -relax -o %t.rv32
+# RUN: ld.lld %t.rv64.o --defsym foo=8 -relax -o %t.rv64
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+# 32: 000110b4 <_start>:
+# 32:    110b4: ef e0 5e f5                   jal     -69804 <foo>
+# 32:    110b8: 13 00 00 00                   nop
+# 32:    110bc: 13 00 00 00                   nop
+# 32:    110c0: 13 00 00 00                   nop
+# 32:    110c4: ef 00 00 04                   jal     64 <bar>
+# 32:    110c8: 13 00 00 00                   nop
+# 32:    110cc: 13 00 00 00                   nop
+# 32:    110d0: 13 00 00 00                   nop
+# 32:    110d4: ef 00 00 03                   jal     48 <bar>
+# 32:    110d8: 13 00 00 00                   nop
+# 32:    110dc: 13 00 00 00                   nop
+# 32:    110e0: 13 00 00 00                   nop
+# 32:    110e4: ef 00 00 02                   jal     32 <bar>
+# 32:    110e8: 13 00 00 00                   nop
+# 32:    110ec: 13 00 00 00                   nop
+# 32:    110f0: 13 00 00 00                   nop
+# 32:    110f4: ef 00 00 01                   jal     16 <bar>
+# 32:    110f8: 13 00 00 00                   nop
+# 32:    110fc: 13 00 00 00                   nop
+# 32:    11100: 13 00 00 00                   nop
+
+# 32: 00011104 <bar>:
+# 32:    11104: 13 00 00 00                   nop
+# 32:    11108: 13 00 00 00                   nop
+# 32:    1110c: 13 00 00 00                   nop
+# 32:    11110: ef e0 9e ef                   jal     -69896 <foo>
+# 32:    11114: 13 00 00 00                   nop
+# 32:    11118: 13 00 00 00                   nop
+# 32:    1111c: 13 00 00 00                   nop
+# 32:    11120: ef e0 9e ee                   jal     -69912 <foo>
+# 32:    11124: 13 00 00 00                   nop
+# 32:    11128: 13 00 00 00                   nop
+# 32:    1112c: 13 00 00 00                   nop
+# 32:    11130: ef e0 9e ed                   jal     -69928 <foo>
+# 32:    11134: 13 00 00 00                   nop
+# 32:    11138: 13 00 00 00                   nop
+# 32:    1113c: 13 00 00 00                   nop
+# 32:    11140: ef e0 9e ec                   jal     -69944 <foo>
+# 32:    11144: 13 00 00 00                   nop
+# 32:    11148: 13 00 00 00                   nop
+# 32:    1114c: 13 00 00 00                   nop
+
+# 64: 0000000000011120 <_start>:
+# 64:    11120: ef e0 9e ee                   jal     -69912 <foo>
+# 64:    11124: 13 00 00 00                   nop
+# 64:    11128: 13 00 00 00                   nop
+# 64:    1112c: 13 00 00 00                   nop
+# 64:    11130: ef 00 00 04                   jal     64 <bar>
+# 64:    11134: 13 00 00 00                   nop
+# 64:    11138: 13 00 00 00                   nop
+# 64:    1113c: 13 00 00 00                   nop
+# 64:    11140: ef 00 00 03                   jal     48 <bar>
+# 64:    11144: 13 00 00 00                   nop
+# 64:    11148: 13 00 00 00                   nop
+# 64:    1114c: 13 00 00 00                   nop
+# 64:    11150: ef 00 00 02                   jal     32 <bar>
+# 64:    11154: 13 00 00 00                   nop
+# 64:    11158: 13 00 00 00                   nop
+# 64:    1115c: 13 00 00 00                   nop
+# 64:    11160: ef 00 00 01                   jal     16 <bar>
+# 64:    11164: 13 00 00 00                   nop
+# 64:    11168: 13 00 00 00                   nop
+# 64:    1116c: 13 00 00 00                   nop
+
+# 64: 0000000000011170 <bar>:
+# 64:    11170: 13 00 00 00                   nop
+# 64:    11174: 13 00 00 00                   nop
+# 64:    11178: 13 00 00 00                   nop
+# 64:    1117c: ef e0 de e8                   jal     -70004 <foo>
+# 64:    11180: 13 00 00 00                   nop
+# 64:    11184: 13 00 00 00                   nop
+# 64:    11188: 13 00 00 00                   nop
+# 64:    1118c: ef e0 de e7                   jal     -70020 <foo>
+# 64:    11190: 13 00 00 00                   nop
+# 64:    11194: 13 00 00 00                   nop
+# 64:    11198: 13 00 00 00                   nop
+# 64:    1119c: ef e0 de e6                   jal     -70036 <foo>
+# 64:    111a0: 13 00 00 00                   nop
+# 64:    111a4: 13 00 00 00                   nop
+# 64:    111a8: 13 00 00 00                   nop
+# 64:    111ac: ef e0 de e5                   jal     -70052 <foo>
+# 64:    111b0: 13 00 00 00                   nop
+# 64:    111b4: 13 00 00 00                   nop
+# 64:    111b8: 13 00 00 00                   nop
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 00011104    76 NOTYPE  LOCAL  DEFAULT     1 bar
+# Symbols32:     2: 000110b4    80 NOTYPE  GLOBAL DEFAULT     1 _start
+# Symbols32:     3: 00000008     0 NOTYPE  GLOBAL DEFAULT   ABS foo
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# Symbols64:     1: 0000000000011170    76 NOTYPE  LOCAL  DEFAULT     1 bar
+# Symbols64:     2: 0000000000011120    80 NOTYPE  GLOBAL DEFAULT     1 _start
+# Symbols64:     3: 0000000000000008     0 NOTYPE  GLOBAL DEFAULT   ABS foo
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 00009c 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 000150 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 000158 000040 10      5   2  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 000198 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 0001c2 000010 00      0   0  1
+
+# Sections64: Section Headers:
+# Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 00009c 00  AX  0   0  4
+# Sections64:   [ 2] .comment          PROGBITS        0000000000000000 0001bc 000008 01  MS  0   0  1
+# Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 0001c8 000060 18      5   2  8
+# Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 000228 00002a 00      0   0  1
+# Sections64:   [ 5] .strtab           STRTAB          0000000000000000 000252 000010 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x0009c 0x0009c R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000120 0x0000000000011120 0x0000000000011120 0x00009c 0x00009c R E 0x1000
+
+.global _start
+_start:
+    call    foo
+    nop
+    nop
+    nop
+    call    bar
+    nop
+    nop
+    nop
+    call    bar
+    nop
+    nop
+    nop
+    call    bar
+    nop
+    nop
+    nop
+    call    bar
+    nop
+    nop
+    nop
+    .size _start, . - _start
+
+bar:
+    nop
+    nop
+    nop
+    call    foo
+    nop
+    nop
+    nop
+    call    foo
+    nop
+    nop
+    nop
+    call    foo
+    nop
+    nop
+    nop
+    call    foo
+    nop
+    nop
+    nop
+    .size bar, . - bar

lld/test/ELF/riscv-relax-call-multiple-sections.yaml

+# REQUIRES: riscv
+
+# RUN: yaml2obj %s -o %t.rv32.o
+
+# RUN: ld.lld %t.rv32.o -relax -o %t.rv32
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+
+# This tests relaxing calls to versioned symbols using the .symver directive.
+
+# 32: 000110b4 <_start>:
+# 32:    110b4: ef 00 40 00                   jal     4 <foo>
+
+# 32: Disassembly of section .other:
+
+# 32: 000110b8 <foo>:
+# 32:    110b8: ef f0 df ff                   jal     -4 <_start>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 000110b4     4 NOTYPE  GLOBAL DEFAULT     1 _start
+# Symbols32:     2: 000110b8     4 NOTYPE  GLOBAL DEFAULT     2 foo
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 000004 00  AX  0   0  4
+# Sections32:   [ 2] .other            PROGBITS        000110b8 0000b8 000004 00  AX  0   0  1
+# Sections32:   [ 3] .comment          PROGBITS        00000000 0000bc 000008 01  MS  0   0  1
+# Sections32:   [ 4] .symtab           SYMTAB          00000000 0000c4 000030 10      6   1  4
+# Sections32:   [ 5] .shstrtab         STRTAB          00000000 0000f4 000031 00      0   0  1
+# Sections32:   [ 6] .strtab           STRTAB          00000000 000125 00000c 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x00008 0x00008 R E 0x1000
+
+# Used to test relaxation function calls (R_RISCV_CALL) that jump into a
+# different section.
+
+--- !ELF
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_RISCV
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         '97000000E7800000'
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    EntSize:         0x000000000000000C
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000000
+        Symbol:          foo
+        Type:            R_RISCV_CALL
+      - Offset:          0x0000000000000000
+        Type:            R_RISCV_RELAX
+  - Name:            .other
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x0000000000000008
+    AddressAlign:    0x0000000000000000
+    Content:         '97000000E7800000'
+  - Name:            .rela.other
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    EntSize:         0x000000000000000C
+    Info:            .other
+    Relocations:
+      - Offset:          0x0000000000000000
+        Symbol:          _start
+        Type:            R_RISCV_CALL
+      - Offset:          0x0000000000000000
+        Type:            R_RISCV_RELAX
+Symbols:
+  - Name:            _start
+    Section:         .text
+    Binding:         STB_GLOBAL
+    Size:            0x0000000000000008
+  - Name:            foo
+    Section:         .other
+    Binding:         STB_GLOBAL
+    Size:            0x0000000000000008
+...

lld/test/ELF/riscv-relax-call-symbol-versions.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o -relax -o %t.rv32
+# RUN: ld.lld %t.rv64.o -relax -o %t.rv64
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+# This tests relaxing calls to versioned symbols using the .symver directive.
+
+# 32: 000110b4 <_start>:
+# 32:    110b4: ef 00 80 00                   jal     8 <foo@VER1>
+# 32:    110b8: ef 00 c0 00                   jal     12 <sym>
+
+# 32: 000110bc <foo@VER1>:
+# 32:    110bc: ef 00 00 00                   jal     0 <foo@VER1>
+# 32:    110c0: ef 00 40 00                   jal     4 <sym>
+
+# 32: 000110c4 <sym>:
+# 32:    110c4: ef f0 9f ff                   jal     -8 <foo@VER1>
+# 32:    110c8: ef f0 df ff                   jal     -4 <sym>
+
+# 64: 0000000000011120 <_start>:
+# 64:    11120: ef 00 80 00                   jal     8 <foo@VER1>
+# 64:    11124: ef 00 c0 00                   jal     12 <sym>
+
+# 64: 0000000000011128 <foo@VER1>:
+# 64:    11128: ef 00 00 00                   jal     0 <foo@VER1>
+# 64:    1112c: ef 00 40 00                   jal     4 <sym>
+
+# 64: 0000000000011130 <sym>:
+# 64:    11130: ef f0 9f ff                   jal     -8 <foo@VER1>
+# 64:    11134: ef f0 df ff                   jal     -4 <sym>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 000110bc     8 NOTYPE  LOCAL  DEFAULT    1 bar
+# Symbols32:     2: 000110bc     8 NOTYPE  LOCAL  DEFAULT    1 foo@VER1
+# Symbols32:     3: 000110c4     8 NOTYPE  LOCAL  DEFAULT    1 foo@VER2
+# Symbols32:     4: 000110c4     8 NOTYPE  LOCAL  DEFAULT    1 sym
+# Symbols32:     5: 000110b4     8 NOTYPE  GLOBAL DEFAULT    1 _start
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# Symbols64:     1: 0000000000011128     8 NOTYPE  LOCAL  DEFAULT    1 bar
+# Symbols64:     2: 0000000000011128     8 NOTYPE  LOCAL  DEFAULT    1 foo@VER1
+# Symbols64:     3: 0000000000011130     8 NOTYPE  LOCAL  DEFAULT    1 foo@VER2
+# Symbols64:     4: 0000000000011130     8 NOTYPE  LOCAL  DEFAULT    1 sym
+# Symbols64:     5: 0000000000011120     8 NOTYPE  GLOBAL DEFAULT    1 _start
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 000018 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 0000cc 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 0000d4 000060 10      5   5  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 000134 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 00015e 000022 00      0   0  1
+
+# Sections64: Section Headers:
+# Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 000018 00  AX  0   0  4
+# Sections64:   [ 2] .comment          PROGBITS        0000000000000000 000138 000008 01  MS  0   0  1
+# Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 000140 000090 18      5   5  8
+# Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 0001d0 00002a 00      0   0  1
+# Sections64:   [ 5] .strtab           STRTAB          0000000000000000 0001fa 000022 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x00018 0x00018 R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000120 0x0000000000011120 0x0000000000011120 0x000018 0x000018 R E 0x1000
+
+.global _start
+_start:
+    call    foo@VER1
+    call    foo@VER2
+    .size _start, . - _start
+
+bar:
+    call    foo@VER1
+    call    foo@VER2
+    .size bar, . - bar
+    .symver bar, foo@VER1
+
+sym:
+    call    foo@VER1
+    call    foo@VER2
+    .size sym, . - sym
+    .symver sym, foo@VER2

lld/test/ELF/riscv-relax-call-wrapped-symbols.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o -relax -o %t.rv32 --wrap foo
+# RUN: ld.lld %t.rv64.o -relax -o %t.rv64 --wrap foo
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+# This tests relaxing relocations jumping between wrapped symbols.
+
+# 32: 000110b4 <_start>:
+# 32:    110b4: ef 00 c0 00                   jal     12 <foo>
+# 32:    110b8: ef 00 40 01                   jal     20 <__wrap_foo>
+# 32:    110bc: ef 00 c0 01                   jal     28 <__real_foo>
+
+# 32: 000110c0 <foo>:
+# 32:    110c0: ef 00 00 00                   jal     0 <foo>
+# 32:    110c4: ef 00 80 00                   jal     8 <__wrap_foo>
+# 32:    110c8: ef 00 00 01                   jal     16 <__real_foo>
+
+# 32: 000110cc <__wrap_foo>:
+# 32:    110cc: ef f0 5f ff                   jal     -12 <foo>
+# 32:    110d0: ef f0 df ff                   jal     -4 <__wrap_foo>
+# 32:    110d4: ef 00 40 00                   jal     4 <__real_foo>
+
+# 32: 000110d8 <__real_foo>:
+# 32:    110d8: ef f0 9f fe                   jal     -24 <foo>
+# 32:    110dc: ef f0 1f ff                   jal     -16 <__wrap_foo>
+# 32:    110e0: ef f0 9f ff                   jal     -8 <__real_foo>
+
+
+# 64: 0000000000011120 <_start>:
+# 64:    11120: ef 00 c0 00                   jal     12 <foo>
+# 64:    11124: ef 00 40 01                   jal     20 <__wrap_foo>
+# 64:    11128: ef 00 c0 01                   jal     28 <__real_foo>
+
+# 64: 000000000001112c <foo>:
+# 64:    1112c: ef 00 00 00                   jal     0 <foo>
+# 64:    11130: ef 00 80 00                   jal     8 <__wrap_foo>
+# 64:    11134: ef 00 00 01                   jal     16 <__real_foo>
+
+# 64: 0000000000011138 <__wrap_foo>:
+# 64:    11138: ef f0 5f ff                   jal     -12 <foo>
+# 64:    1113c: ef f0 df ff                   jal     -4 <__wrap_foo>
+# 64:    11140: ef 00 40 00                   jal     4 <__real_foo>
+
+# 64: 0000000000011144 <__real_foo>:
+# 64:    11144: ef f0 9f fe                   jal     -24 <foo>
+# 64:    11148: ef f0 1f ff                   jal     -16 <__wrap_foo>
+# 64:    1114c: ef f0 9f ff                   jal     -8 <__real_foo>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis       Ndx Name
+# Symbols32:     1: 000110d8    12 NOTYPE  LOCAL  DEFAULT     1 __real_foo
+# Symbols32:     2: 000110cc    12 NOTYPE  LOCAL  DEFAULT     1 __wrap_foo
+# Symbols32:     3: 000110c0    12 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols32:     4: 000110b4    12 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis       Ndx Name
+# Symbols64:     1: 0000000000011144    12 NOTYPE  LOCAL  DEFAULT     1 __real_foo
+# Symbols64:     2: 0000000000011138    12 NOTYPE  LOCAL  DEFAULT     1 __wrap_foo
+# Symbols64:     3: 000000000001112c    12 NOTYPE  LOCAL  DEFAULT     1 foo
+# Symbols64:     4: 0000000000011120    12 NOTYPE  GLOBAL DEFAULT     1 _start
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 000030 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 0000e4 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 0000ec 000050 10      5   4  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 00013c 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 000166 000022 00      0   0  1
+
+# Sections64: Section Headers:
+# Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 000030 00  AX  0   0  4
+# Sections64:   [ 2] .comment          PROGBITS        0000000000000000 000150 000008 01  MS  0   0  1
+# Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 000158 000078 18      5   4  8
+# Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 0001d0 00002a 00      0   0  1
+# Sections64:   [ 5] .strtab           STRTAB          0000000000000000 0001fa 000022 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x00030 0x00030 R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000120 0x0000000000011120 0x0000000000011120 0x000030 0x000030 R E 0x1000
+
+.global _start
+_start:
+    call    foo
+    call    __wrap_foo
+    call    __real_foo
+    .size _start, . - _start
+
+foo:
+    call    foo
+    call    __wrap_foo
+    call    __real_foo
+    .size foo, . - foo
+
+__wrap_foo:
+    call    foo
+    call    __wrap_foo
+    call    __real_foo
+    .size __wrap_foo, . - __wrap_foo
+
+__real_foo:
+    call    foo
+    call    __wrap_foo
+    call    __real_foo
+    .size __real_foo, . - __real_foo

lld/test/ELF/riscv-relax-call.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=riscv64-unknown-elf -mattr=+relax %s -o %t.rv64.o
+
+# RUN: ld.lld %t.rv32.o --defsym foo=8 -relax -o %t.rv32
+# RUN: ld.lld %t.rv64.o --defsym foo=8 -relax -o %t.rv64
+
+# RUN: llvm-objdump -d %t.rv32         | FileCheck --check-prefix=32 %s
+# RUN: llvm-objdump -d %t.rv64         | FileCheck --check-prefix=64 %s
+# RUN: llvm-readelf --symbols %t.rv32  | FileCheck --check-prefix=Symbols32 %s
+# RUN: llvm-readelf --symbols %t.rv64  | FileCheck --check-prefix=Symbols64 %s
+# RUN: llvm-readelf --sections %t.rv32 | FileCheck --check-prefix=Sections32 %s
+# RUN: llvm-readelf --sections %t.rv64 | FileCheck --check-prefix=Sections64 %s
+# RUN: llvm-readelf --segments %t.rv32 | FileCheck --check-prefix=Segments32 %s
+# RUN: llvm-readelf --segments %t.rv64 | FileCheck --check-prefix=Segments64 %s
+
+
+# 32: 000110b4 <_start>:
+# 32:    110b4: ef e0 5e f5                   jal     -69804 <foo>
+# 32:    110b8: ef 00 00 01                   jal     16 <bar>
+# 32:    110bc: ef 00 c0 00                   jal     12 <bar>
+# 32:    110c0: ef 00 80 00                   jal     8 <bar>
+# 32:    110c4: ef 00 40 00                   jal     4 <bar>
+
+# 32: 000110c8 <bar>:
+# 32:    110c8: ef e0 1e f4                   jal     -69824 <foo>
+# 32:    110cc: ef e0 de f3                   jal     -69828 <foo>
+# 32:    110d0: ef e0 9e f3                   jal     -69832 <foo>
+# 32:    110d4: ef e0 5e f3                   jal     -69836 <foo>
+
+# 64: 0000000000011120 <_start>:
+# 64:    11120: ef e0 9e ee                   jal     -69912 <foo>
+# 64:    11124: ef 00 00 01                   jal     16 <bar>
+# 64:    11128: ef 00 c0 00                   jal     12 <bar>
+# 64:    1112c: ef 00 80 00                   jal     8 <bar>
+# 64:    11130: ef 00 40 00                   jal     4 <bar>
+
+# 64: 0000000000011134 <bar>:
+# 64:    11134: ef e0 5e ed                   jal     -69932 <foo>
+# 64:    11138: ef e0 1e ed                   jal     -69936 <foo>
+# 64:    1113c: ef e0 de ec                   jal     -69940 <foo>
+# 64:    11140: ef e0 9e ec                   jal     -69944 <foo>
+
+# Check the symbols have been adjusted correctly
+
+# Symbols32:   Num:    Value  Size Type    Bind   Vis      Ndx Name
+# Symbols32:     1: 000110c8    16 NOTYPE  LOCAL  DEFAULT    1 bar
+# Symbols32:     2: 000110b4    20 NOTYPE  GLOBAL DEFAULT    1 _start
+
+# Symbols64:   Num:    Value          Size Type    Bind   Vis      Ndx Name
+# Symbols64:     1: 0000000000011134    16 NOTYPE  LOCAL  DEFAULT    1 bar
+# Symbols64:     2: 0000000000011120    20 NOTYPE  GLOBAL DEFAULT    1 _start
+
+# Check the sections have been adjusted correctly
+
+# Sections32: Section Headers:
+# Sections32:   [Nr] Name              Type            Address  Off    Size   ES Flg Lk Inf Al
+# Sections32:   [ 0]                   NULL            00000000 000000 000000 00      0   0  0
+# Sections32:   [ 1] .text             PROGBITS        000110b4 0000b4 000024 00  AX  0   0  4
+# Sections32:   [ 2] .comment          PROGBITS        00000000 0000d8 000008 01  MS  0   0  1
+# Sections32:   [ 3] .symtab           SYMTAB          00000000 0000e0 000040 10      5   2  4
+# Sections32:   [ 4] .shstrtab         STRTAB          00000000 000120 00002a 00      0   0  1
+# Sections32:   [ 5] .strtab           STRTAB          00000000 00014a 000010 00      0   0  1
+
+# Sections64: Section Headers:
+# Sections64:   [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# Sections64:   [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0
+# Sections64:   [ 1] .text             PROGBITS        0000000000011120 000120 000024 00  AX  0   0  4
+# Sections64:   [ 2] .comment          PROGBITS        0000000000000000 000144 000008 01  MS  0   0  1
+# Sections64:   [ 3] .symtab           SYMTAB          0000000000000000 000150 000060 18      5   2  8
+# Sections64:   [ 4] .shstrtab         STRTAB          0000000000000000 0001b0 00002a 00      0   0  1
+# Sections64:   [ 5] .strtab           STRTAB          0000000000000000 0001da 000010 00      0   0  1
+
+# Check the segments have been adjusted correctly
+
+# Segments32: Program Headers:
+# Segments32:   Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+# Segments32:   LOAD           0x0000b4 0x000110b4 0x000110b4 0x00024 0x00024 R E 0x1000
+
+# Segments64: Program Headers:
+# Segments64:   Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
+# Segments64:   LOAD           0x000000 0x0000000000010000 0x0000000000010000 0x000120 0x000120 R   0x1000
+
+.global _start
+_start:
+    call    foo
+    call    bar
+    call    bar
+    call    bar
+    call    bar
+    .size _start, . - _start
+
+bar:
+    call    foo
+    call    foo
+    call    foo
+    call    foo
+    .size bar, . - bar