[lld][RISCV][NFC] Simplify symbol value calculation in relax

[jobnoorman]

Summary

The valueDelta map was used to calculate the symbol value deltas from
the previous iteration. Since the symbol values themselves are also
updated every iteration, the following invariant holds:

sa[i].offset == sa[i].d->value + valueDelta[sa[i].d]

Note that sa[i].offset contains the original value of sa[i].d and is
never changed.

This means that the current way of updating symbol values can be
rewritten to not need the valueDelta map:

sa[i].d->value -= delta - valueDelta.find(sa[i].d)->second;
<=> (replace invariant)
sa[i].d->value -= delta - (sa[i].offset - sa[i].d->value);
<=>
sa[i].d->value = sa[i].d->value - (delta - (sa[i].offset - sa[i].d->value));
<=>
sa[i].d->value = sa[i].d->value - delta + sa[i].offset - sa[i].d->value;
<=>
sa[i].d->value = sa[i].offset - delta;

This patch implements this simplification. I believe this improves the
readability of the code as it took me quite some time to understand the
use of valueDelta. It might also have a slight performance benefit as
it removes one iteration over all relocations every relax iteration.

lld/ELF/Arch/RISCV.cpp

case R_RISCV_LO12_S:
     break;
   }
 }
 
 static bool relax(InputSection &sec) {
   const uint64_t secAddr = sec.getVA();
   auto &aux = *sec.relaxAux;
   bool changed = false;
-
-  // Get st_value delta for symbols relative to this section from the previous
-  // iteration.
-  DenseMap<const Defined *, uint64_t> valueDelta;
   ArrayRef<SymbolAnchor> sa = ArrayRef(aux.anchors);
   uint32_t delta = 0;
-  for (auto [i, r] : llvm::enumerate(sec.relocs())) {
-    for (; sa.size() && sa[0].offset <= r.offset; sa = sa.slice(1))
-      if (!sa[0].end)
-        valueDelta[sa[0].d] = delta;
-    delta = aux.relocDeltas[i];
-  }
-  for (const SymbolAnchor &sa : sa)
-    if (!sa.end)
-      valueDelta[sa.d] = delta;
-  sa = ArrayRef(aux.anchors);
-  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: {
for (auto [i, r] : llvm::enumerate(sec.relocs())) {
 
     // For all anchors whose offsets are <= r.offset, they are preceded by
     // the previous relocation whose `relocDeltas` value equals `delta`.
     // Decrease their st_value and update their st_size.
     for (; sa.size() && sa[0].offset <= r.offset; sa = sa.slice(1)) {
       if (sa[0].end)
         sa[0].d->size = sa[0].offset - delta - sa[0].d->value;
       else
-        sa[0].d->value -= delta - valueDelta.find(sa[0].d)->second;
+        sa[0].d->value = sa[0].offset - delta;
     }
     delta += remove;
     if (delta != cur) {
       cur = delta;
       changed = true;
     }
   }
 
   for (const SymbolAnchor &a : sa) {
     if (a.end)
       a.d->size = a.offset - delta - a.d->value;
     else
-      a.d->value -= delta - valueDelta.find(a.d)->second;
+      a.d->value = a.offset - delta;
   }
   // Inform assignAddresses that the size has changed.
   if (!isUInt<16>(delta))
     fatal("section size decrease is too large");
   sec.bytesDropped = delta;
   return changed;
 }