[Wasm] Convert many of the fixed-size values to LEB128.

src/wasm/encoder.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/signature.h"
 
 #include "src/handles.h"
 #include "src/v8.h"
 #include "src/zone-containers.h"
 
@@ skipping 37 matching lines @@
     byte out = static_cast<byte>(val & 0x7f);
     if (next) {
       *((*b)++) = 0x80 | out;
       val = next;
     } else {
       *((*b)++) = out;
       break;
     }
   }
 }
+
+size_t SizeOfVarInt(size_t value) {
+  size_t size = 0;
+  do {
+    size++;
+    value = value >> 7;
+  } while (value > 0);
+  return size;
+}
+
 }  // namespace
 
 
 struct WasmFunctionBuilder::Type {
   bool param_;
   LocalType type_;
 };
 
 
 WasmFunctionBuilder::WasmFunctionBuilder(Zone* zone)
@@ skipping 46 matching lines @@
 void WasmFunctionBuilder::Emit(WasmOpcode opcode) {
   body_.push_back(static_cast<byte>(opcode));
 }
 
 
 void WasmFunctionBuilder::EmitWithU8(WasmOpcode opcode, const byte immediate) {
   body_.push_back(static_cast<byte>(opcode));
   body_.push_back(immediate);
 }
 
+void WasmFunctionBuilder::EmitWithVarInt(WasmOpcode opcode,
+                                         uint32_t immediate) {
+  body_.push_back(static_cast<byte>(opcode));
+  size_t immediate_size = SizeOfVarInt(immediate);
+  body_.insert(body_.end(), immediate_size, 0);
+  byte* p = &body_[body_.size() - immediate_size];
+  EmitVarInt(&p, immediate);
+}
 
-uint32_t WasmFunctionBuilder::EmitEditableImmediate(const byte immediate) {
-  body_.push_back(immediate);
+uint32_t WasmFunctionBuilder::EmitEditableVarIntImmediate() {
+  // Guess that the immediate will be 1 byte. If it is more, we'll have to
+  // shift everything down.
+  body_.push_back(0);
   return static_cast<uint32_t>(body_.size()) - 1;
 }
 
+void WasmFunctionBuilder::EditVarIntImmediate(uint32_t offset,
+                                              const uint32_t immediate) {
+  uint32_t immediate_size = static_cast<uint32_t>(SizeOfVarInt(immediate));
+  // In EmitEditableVarIntImmediate, we guessed that we'd only need one byte.
+  // If we need more, shift everything down to make room for the larger
+  // immediate.
+  if (immediate_size > 1) {
+    uint32_t diff = immediate_size - 1;
+    body_.insert(body_.begin() + offset, diff, 0);
 
-void WasmFunctionBuilder::EditImmediate(uint32_t offset, const byte immediate) {
-  DCHECK(offset < body_.size());
-  body_[offset] = immediate;
+    for (size_t i = 0; i < local_indices_.size(); ++i) {
+      if (local_indices_[i] >= offset) {
+        local_indices_[i] += diff;
+      }
+    }
+  }
+  DCHECK(offset + immediate_size <= body_.size());
+  byte* p = &body_[offset];
+  EmitVarInt(&p, immediate);
 }
 
 
 void WasmFunctionBuilder::Exported(uint8_t flag) { exported_ = flag; }
 
 
 void WasmFunctionBuilder::External(uint8_t flag) { external_ = flag; }
 
 void WasmFunctionBuilder::SetName(const unsigned char* name, int name_length) {
   name_.clear();
@@ skipping 295 matching lines @@
 }
 
 
 WasmModuleWriter::WasmModuleWriter(Zone* zone)
     : functions_(zone),
       data_segments_(zone),
       signatures_(zone),
       indirect_functions_(zone),
       globals_(zone) {}
 
-size_t SizeOfVarInt(size_t value) {
-  size_t size = 0;
-  do {
-    size++;
-    value = value >> 7;
-  } while (value > 0);
-  return size;
-}
-
 struct Sizes {
   size_t header_size;
   size_t body_size;
 
   size_t total() { return header_size + body_size; }
 
   void Add(size_t header, size_t body) {
     header_size += header;
     body_size += body;
   }
@@ skipping 10 matching lines @@
 WasmModuleIndex* WasmModuleWriter::WriteTo(Zone* zone) const {
   Sizes sizes = {0, 0};
 
   sizes.Add(2 * sizeof(uint32_t), 0);  // header
 
   sizes.Add(1, 0);
   sizes.Add(kDeclMemorySize, 0);
 
   sizes.AddSection(signatures_.size());
   for (auto sig : signatures_) {
-    sizes.Add(2 + sig->parameter_count(), 0);
+    sizes.Add(1 + SizeOfVarInt(sig->parameter_count()) + sig->parameter_count(),
+              0);
   }
 
   sizes.AddSection(globals_.size());
   if (globals_.size() > 0) {
     sizes.Add(kDeclGlobalSize * globals_.size(), 0);
   }
 
   sizes.AddSection(functions_.size());
   for (auto function : functions_) {
     sizes.Add(function->HeaderSize() + function->BodySize(),
               function->NameSize());
   }
 
   if (start_function_index_ >= 0) {
     sizes.Add(1, 0);
     sizes.Add(SizeOfVarInt(start_function_index_), 0);
   }
 
   sizes.AddSection(data_segments_.size());
   for (auto segment : data_segments_) {
     sizes.Add(segment->HeaderSize(), segment->BodySize());
   }
 
   sizes.AddSection(indirect_functions_.size());
-  sizes.Add(2 * static_cast<uint32_t>(indirect_functions_.size()), 0);
+  for (auto function_index : indirect_functions_) {
+    sizes.Add(SizeOfVarInt(function_index), 0);
+  }
 
   if (sizes.body_size > 0) sizes.Add(1, 0);
 
   ZoneVector<uint8_t> buffer_vector(sizes.total(), zone);
   byte* buffer = &buffer_vector[0];
   byte* header = buffer;
   byte* body = buffer + sizes.header_size;
 
   // -- emit magic -------------------------------------------------------------
   EmitUint32(&header, kWasmMagic);
   EmitUint32(&header, kWasmVersion);
 
   // -- emit memory declaration ------------------------------------------------
   EmitUint8(&header, kDeclMemory);
-  EmitUint8(&header, 16);  // min memory size
-  EmitUint8(&header, 16);  // max memory size
-  EmitUint8(&header, 0);   // memory export
+  EmitVarInt(&header, 16);  // min memory size
+  EmitVarInt(&header, 16);  // max memory size
+  EmitUint8(&header, 0);    // memory export
 
   // -- emit globals -----------------------------------------------------------
   if (globals_.size() > 0) {
     EmitUint8(&header, kDeclGlobals);
     EmitVarInt(&header, globals_.size());
 
     for (auto global : globals_) {
       EmitUint32(&header, 0);
       EmitUint8(&header, WasmOpcodes::MemTypeCodeFor(global.first));
       EmitUint8(&header, global.second);
     }
   }
 
   // -- emit signatures --------------------------------------------------------
   if (signatures_.size() > 0) {
     EmitUint8(&header, kDeclSignatures);
     EmitVarInt(&header, signatures_.size());
 
     for (FunctionSig* sig : signatures_) {
-      EmitUint8(&header, static_cast<byte>(sig->parameter_count()));
+      EmitVarInt(&header, sig->parameter_count());
       if (sig->return_count() > 0) {
         EmitUint8(&header, WasmOpcodes::LocalTypeCodeFor(sig->GetReturn()));
       } else {
         EmitUint8(&header, kLocalVoid);
       }
       for (size_t j = 0; j < sig->parameter_count(); j++) {
         EmitUint8(&header, WasmOpcodes::LocalTypeCodeFor(sig->GetParam(j)));
       }
     }
   }
@@ skipping 23 matching lines @@
       segment->Serialize(buffer, &header, &body);
     }
   }
 
   // -- emit function table ----------------------------------------------------
   if (indirect_functions_.size() > 0) {
     EmitUint8(&header, kDeclFunctionTable);
     EmitVarInt(&header, indirect_functions_.size());
 
     for (auto index : indirect_functions_) {
-      EmitUint16(&header, index);
+      EmitVarInt(&header, index);
     }
   }
 
   if (sizes.body_size > 0) EmitUint8(&header, kDeclEnd);
 
   return new (zone) WasmModuleIndex(buffer, buffer + sizes.total());
 }
 
 
 std::vector<uint8_t> UnsignedLEB128From(uint32_t result) {
   std::vector<uint8_t> output;
   uint8_t next = 0;
   int shift = 0;
   do {
     next = static_cast<uint8_t>(result >> shift);
     if (((result >> shift) & 0xFFFFFF80) != 0) {
       next = next | 0x80;
     }
     output.push_back(next);
     shift += 7;
   } while ((next & 0x80) != 0);
   return output;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8