[NFC] Move optimal-LEB emitting logic to a shared place (#7575)

This allows generating sections in side buffers, rather than just on the
main output buffer ("o"). This will help code annotations, where it is
useful to emit them to a side buffer, then copy them into the right
place (which is before the code section, but we must emit the code
first, to know the offsets for the annotations, so reordering is
unavoidable).

Author: kripken

src/wasm-binary.h

@@ -258,6 +258,52 @@ class BufferWithRandomAccess : public std::vector<uint8_t> {
     std::copy(begin(), end(), ret.begin());
     return ret;
   }
+
+  // Writes bytes in the maximum amount for a U32 LEB placeholder. Return the
+  // offset we wrote it at. The LEB can then be patched with the proper value
+  // later, when the size is known.
+  BinaryLocation writeU32LEBPlaceholder() {
+    BinaryLocation ret = size();
+    *this << int32_t(0);
+    *this << int8_t(0);
+    return ret;
+  }
+
+  // Given the location of a maximum-size LEB placeholder, as returned from
+  // writeU32LEBPlaceholder, use the current buffer size to figure out the size
+  // that should be written there, and emit an optimal-size LEB. Move contents
+  // backwards if we used fewer bytes, and return the number of bytes we moved.
+  // (Thus, if we return >0, we moved code backwards, and the caller may need to
+  // adjust things.)
+  BinaryLocation emitRetroactiveSectionSizeLEB(BinaryLocation start) {
+    // Do not include the LEB itself in the section size.
+    auto sectionSize = size() - start - MaxLEB32Bytes;
+    auto sizeFieldSize = writeAt(start, U32LEB(sectionSize));
+
+    // We can move things back if the actual LEB for the size doesn't use the
+    // maximum 5 bytes. In that case we need to adjust offsets after we move
+    // things backwards.
+    auto adjustmentForLEBShrinking = MaxLEB32Bytes - sizeFieldSize;
+    if (adjustmentForLEBShrinking) {
+      // We can save some room.
+      assert(sizeFieldSize < MaxLEB32Bytes);
+      std::move(&(*this)[start] + MaxLEB32Bytes,
+                &(*this)[start] + MaxLEB32Bytes + sectionSize,
+                &(*this)[start] + sizeFieldSize);
+      resize(size() - adjustmentForLEBShrinking);
+    }
+
+    return adjustmentForLEBShrinking;
+  }
+
+  void writeInlineString(std::string_view name) {
+    auto size = name.size();
+    auto data = name.data();
+    *this << U32LEB(size);
+    for (size_t i = 0; i < size; i++) {
+      *this << int8_t(data[i]);
+    }
+  }
 };
 
 namespace BinaryConsts {

src/wasm/wasm-binary.cpp

@@ -107,10 +107,7 @@ void WasmBinaryWriter::writeHeader() {
 }
 
 int32_t WasmBinaryWriter::writeU32LEBPlaceholder() {
-  int32_t ret = o.size();
-  o << int32_t(0);
-  o << int8_t(0);
-  return ret;
+  return o.writeU32LEBPlaceholder();
 }
 
 void WasmBinaryWriter::writeResizableLimits(
@@ -142,26 +139,12 @@ template<typename T> int32_t WasmBinaryWriter::startSection(T code) {
 }
 
 void WasmBinaryWriter::finishSection(int32_t start) {
-  // section size does not include the reserved bytes of the size field itself
-  int32_t size = o.size() - start - MaxLEB32Bytes;
-  auto sizeFieldSize = o.writeAt(start, U32LEB(size));
-  // We can move things back if the actual LEB for the size doesn't use the
-  // maximum 5 bytes. In that case we need to adjust offsets after we move
-  // things backwards.
-  auto adjustmentForLEBShrinking = MaxLEB32Bytes - sizeFieldSize;
-  if (adjustmentForLEBShrinking) {
-    // we can save some room, nice
-    assert(sizeFieldSize < MaxLEB32Bytes);
-    std::move(&o[start] + MaxLEB32Bytes,
-              &o[start] + MaxLEB32Bytes + size,
-              &o[start] + sizeFieldSize);
-    o.resize(o.size() - adjustmentForLEBShrinking);
-    if (sourceMap) {
-      for (auto i = sourceMapLocationsSizeAtSectionStart;
-           i < sourceMapLocations.size();
-           ++i) {
-        sourceMapLocations[i].first -= adjustmentForLEBShrinking;
-      }
+  auto adjustmentForLEBShrinking = o.emitRetroactiveSectionSizeLEB(start);
+  if (adjustmentForLEBShrinking && sourceMap) {
+    for (auto i = sourceMapLocationsSizeAtSectionStart;
+         i < sourceMapLocations.size();
+         ++i) {
+      sourceMapLocations[i].first -= adjustmentForLEBShrinking;
     }
   }
 
@@ -172,6 +155,10 @@ void WasmBinaryWriter::finishSection(int32_t start) {
     // The section type byte is right before the LEB for the size; we want
     // offsets that are relative to the body, which is after that section type
     // byte and the the size LEB.
+    //
+    // We can compute the size of the size field LEB by considering the original
+    // size of the maximal LEB, and the adjustment due to shrinking.
+    auto sizeFieldSize = MaxLEB32Bytes - adjustmentForLEBShrinking;
     auto body = start + sizeFieldSize;
     // Offsets are relative to the body of the code section: after the
     // section type byte and the size.
@@ -1538,8 +1525,7 @@ void WasmBinaryWriter::writeData(const char* data, size_t size) {
 }
 
 void WasmBinaryWriter::writeInlineString(std::string_view name) {
-  o << U32LEB(name.size());
-  writeData(name.data(), name.size());
+  o.writeInlineString(name);
 }
 
 static bool isHexDigit(char ch) {