Inline applyRelocations into writeTo.

[ruiu]

Summary

writeTo is memcpy() and applyRelocations(), but the former part is
too small that it doesn't make much sense to split it into two.

[sbc100]

This doesn't seem strictly better to me. Seems like it only increases the complexity and the indentations of the code, and while decreasing re-usability. Is there a specific benefit? Shouldn't we prefer shorter and less nested functions?

[ruiu]

The patch to remove OutRelocation also contained this change, so this change was submitted as part of that. I do prefer shorter functions, but in this case it feels to me that writeTo does too less. That's probably a personal preference though.

lld/wasm/InputChunks.cpp

if (Section.Relocations.empty())
     return;
   size_t Start = getInputSectionOffset();
   size_t Size = getSize();
   for (const WasmRelocation &R : Section.Relocations)
     if (R.Offset >= Start && R.Offset < Start + Size)
       Relocations.push_back(R);
 }
 
-static void applyRelocation(uint8_t *Buf, const OutputRelocation &Reloc) {
+// Copy this input chunk to an mmap'ed output file.
+void InputChunk::writeTo(uint8_t *Buf) const {
+  // Copy contents
+  memcpy(Buf + getOutputOffset(), data().data(), data().size());
+
+  // Apply relocations
+  DEBUG(dbgs() << "applyRelocations: count=" << OutRelocations.size() << "\n");
+
+  for (const OutputRelocation &Reloc : OutRelocations) {
     DEBUG(dbgs() << "write reloc: type=" << Reloc.Reloc.Type
                  << " index=" << Reloc.Reloc.Index << " value=" << Reloc.Value
                  << " offset=" << Reloc.Reloc.Offset << "\n");
 
-  Buf += Reloc.Reloc.Offset;
+    uint8_t *Loc = Buf + Reloc.Reloc.Offset;
 
     switch (Reloc.Reloc.Type) {
     case R_WEBASSEMBLY_TYPE_INDEX_LEB:
     case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
     case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
       // Additional check to verify that the existing value that the location
       // matches our expectations.
-    if (decodeULEB128(Buf) != Reloc.Reloc.Index) {
-      DEBUG(dbgs() << "existing value: " << decodeULEB128(Buf) << "\n");
-      assert(decodeULEB128(Buf) == Reloc.Reloc.Index);
+      if (decodeULEB128(Loc) != Reloc.Reloc.Index) {
+        DEBUG(dbgs() << "existing value: " << decodeULEB128(Loc) << "\n");
+        assert(decodeULEB128(Loc) == Reloc.Reloc.Index);
       }
       LLVM_FALLTHROUGH;
     case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-    encodeULEB128(Reloc.Value, Buf, 5);
+      encodeULEB128(Reloc.Value, Loc, 5);
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-    encodeSLEB128(static_cast<int32_t>(Reloc.Value), Buf, 5);
+      encodeSLEB128(static_cast<int32_t>(Reloc.Value), Loc, 5);
       break;
     case R_WEBASSEMBLY_TABLE_INDEX_I32:
     case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    write32le(Buf, Reloc.Value);
+      write32le(Loc, Reloc.Value);
       break;
     default:
       llvm_unreachable("unknown relocation type");
     }
   }
-
-// Copy this input chunk to an mmap'ed output file.
-void InputChunk::writeTo(uint8_t *Buf) const {
-  // Copy contents
-  memcpy(Buf + getOutputOffset(), data().data(), data().size());
-
-  // Apply relocations
-  if (OutRelocations.empty())
-    return;
-  DEBUG(dbgs() << "applyRelocations: count=" << OutRelocations.size() << "\n");
-  for (const OutputRelocation &Reloc : OutRelocations)
-    applyRelocation(Buf, Reloc);
 }
 
 // Populate OutRelocations based on the input relocations and offset within the
 // output section.  Calculates the updated index and offset for each relocation
 // as well as the value to write out in the final binary.
 void InputChunk::calcRelocations() {
   if (Relocations.empty())
     return;