[lld][RISCV] Handle relaxation reductions of more than 65536 bytes

[mcgrathr]

Summary

In a real-world case with functions that have many, many
R_RISCV_CALL_PLT relocations due to asan and ubsan
instrumentation, all these can be relaxed by an instruction and
the net result is more than 65536 bytes of reduction in the
output .text section that totals about 1.2MiB in final size.

This changes InputSection to use a 32-bit field for bytesDropped.
The RISCV relaxation keeps track in a 64-bit field and detects
32-bit overflow as it previously detected 16-bit overflow. It
doesn't seem likely that 32-bit overflow will arise, but it's not
inconceivable and it's cheap enough to detect it.

This unfortunately increases the size of InputSection on 64-bit
hosts by a word, but that seems hard to avoid.

[jrtc27]

Current code models are such that you can’t have more than 2 GiB of code, so 32-bit seems fine I think?

[MaskRay]

IIRC @luismarques mentions that with LTO we may see a bytesDropped overflow. OK, I don't object to the idea that we pay some memory overhead to make this work.

In D150722#4347763, @jrtc27 wrote:

Current code models are such that you can’t have more than 2 GiB of code, so 32-bit seems fine I think?

The fatal("section size decrease is too large: " + Twine(delta)); is definitely useless for regular code. uint64_t delta = 0; may catch some people's linker stress tests...

lld/ELF/Arch/RISCV.cpp

static void relaxHi20Lo12(const InputSection &sec, size_t i, uint64_t loc,
   }
 }
 
 static bool relax(InputSection &sec) {
   const uint64_t secAddr = sec.getVA();
   auto &aux = *sec.relaxAux;
   bool changed = false;
   ArrayRef<SymbolAnchor> sa = ArrayRef(aux.anchors);
-  uint32_t delta = 0;
+  uint64_t delta = 0;
 
   std::fill_n(aux.relocTypes.get(), sec.relocs().size(), R_RISCV_NONE);
   aux.writes.clear();
   for (auto [i, r] : llvm::enumerate(sec.relocs())) {
     const uint64_t loc = secAddr + r.offset - delta;
     uint32_t &cur = aux.relocDeltas[i], remove = 0;
     switch (r.type) {
     case R_RISCV_ALIGN: {
static bool relax(InputSection &sec) {
 
   for (const SymbolAnchor &a : sa) {
     if (a.end)
       a.d->size = a.offset - delta - a.d->value;
     else
       a.d->value = a.offset - delta;
   }
   // Inform assignAddresses that the size has changed.
-  if (!isUInt<16>(delta))
-    fatal("section size decrease is too large");
+  if (!isUInt<32>(delta))
+    fatal("section size decrease is too large: " + Twine(delta));
   sec.bytesDropped = delta;
   return changed;
 }
 
 // When relaxing just R_RISCV_ALIGN, relocDeltas is usually changed only once in
 // the absence of a linker script. For call and load/store R_RISCV_RELAX, code
 // shrinkage may reduce displacement and make more relocations eligible for
 // relaxation. Code shrinkage may increase displacement to a call/load/store

lld/ELF/InputSection.h

public:
 
   template <class ELFT> ObjFile<ELFT> *getFile() const {
     return cast_or_null<ObjFile<ELFT>>(file);
   }
 
   // Used by --optimize-bb-jumps and RISC-V linker relaxation temporarily to
   // indicate the number of bytes which is not counted in the size. This should
   // be reset to zero after uses.
-  uint16_t bytesDropped = 0;
+  uint32_t bytesDropped = 0;
 
   mutable bool compressed = false;
 
   // Whether the section needs to be padded with a NOP filler due to
   // deleteFallThruJmpInsn.
   bool nopFiller = false;
 
   void drop_back(unsigned num) {

 
 private:
   template <class ELFT, class RelTy>
   void copyRelocations(uint8_t *buf, llvm::ArrayRef<RelTy> rels);
 
   template <class ELFT> void copyShtGroup(uint8_t *buf);
 };
 
-static_assert(sizeof(InputSection) <= 152, "InputSection is too big");
+static_assert(sizeof(InputSection) <= 160, "InputSection is too big");
 
 class SyntheticSection : public InputSection {
 public:
   SyntheticSection(uint64_t flags, uint32_t type, uint32_t addralign,
                    StringRef name)
       : InputSection(nullptr, flags, type, addralign, {}, name,
                      InputSectionBase::Synthetic) {}