[wasm] Extra LEB utilities to leb-helper.h

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"
 
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/encoder.h"
+#include "src/wasm/leb-helper.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-module.h"
 #include "src/wasm/wasm-opcodes.h"
 
 #include "src/v8memory.h"
 
 #if DEBUG
 #define TRACE(...)                                    \
   do {                                                \
     if (FLAG_trace_wasm_encoder) PrintF(__VA_ARGS__); \
@@ skipping 20 matching lines @@
   WriteUnalignedUInt16(*b, x);
   *b += 2;
 }
 
 
 void EmitUint32(byte** b, uint32_t x) {
   WriteUnalignedUInt32(*b, x);
   *b += 4;
 }
 
+void EmitVarInt(byte** b, size_t val) {
+  LEBHelper::write_u32v(b, static_cast<uint32_t>(val));
+}
+
 // Sections all start with a size, but it's unknown at the start.
 // We generate a large varint which we then fixup later when the size is known.
 //
 // TODO(jfb) Not strictly necessary since sizes are calculated ahead of time.
 const size_t padded_varint = 5;
 
-void EmitVarInt(byte** b, size_t val) {
-  while (true) {
-    size_t next = val >> 7;
-    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;
-}
-
 void FixupSection(byte* start, byte* end) {
-  // Same as EmitVarInt, but fixed-width with zeroes in the MSBs.
+  // Same as LEBHelper::write_u32v, but fixed-width with zeroes in the MSBs.
   size_t val = end - start - padded_varint;
   TRACE("  fixup %u\n", (unsigned)val);
   for (size_t pos = 0; pos != padded_varint; ++pos) {
     size_t next = val >> 7;
     byte out = static_cast<byte>(val & 0x7f);
     if (pos != padded_varint - 1) {
       *(start++) = 0x80 | out;
       val = next;
     } else {
       *(start++) = out;
@@ skipping 25 matching lines @@
 
 WasmFunctionBuilder::WasmFunctionBuilder(Zone* zone)
     : return_type_(kAstI32),
       locals_(zone),
       exported_(0),
       external_(0),
       body_(zone),
       local_indices_(zone),
       name_(zone) {}
 
+void WasmFunctionBuilder::EmitVarInt(uint32_t val) {
+  byte buffer[8];
+  byte* ptr = buffer;
+  LEBHelper::write_u32v(&ptr, val);
+  for (byte* p = buffer; p < ptr; p++) {
+    body_.push_back(*p);
+  }
+}
 
 uint16_t WasmFunctionBuilder::AddParam(LocalType type) {
   return AddVar(type, true);
 }
 
 
 uint16_t WasmFunctionBuilder::AddLocal(LocalType type) {
   return AddVar(type, false);
 }
 
@@ skipping 47 matching lines @@
 void WasmFunctionBuilder::EmitWithU8U8(WasmOpcode opcode, const byte imm1,
                                        const byte imm2) {
   body_.push_back(static_cast<byte>(opcode));
   body_.push_back(imm1);
   body_.push_back(imm2);
 }
 
 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);
+  EmitVarInt(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));
+  uint32_t immediate_size =
+      static_cast<uint32_t>(LEBHelper::sizeof_u32v(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);
 
     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);
+  v8::internal::wasm::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();
   if (name_length > 0) {
     for (int i = 0; i < name_length; i++) {
       name_.push_back(*(name + i));
     }
   }
 }
 
 
 WasmFunctionEncoder* WasmFunctionBuilder::Build(Zone* zone,
                                                 WasmModuleBuilder* mb) const {
   WasmFunctionEncoder* e =
       new (zone) WasmFunctionEncoder(zone, return_type_, exported_, external_);
   uint16_t* var_index = zone->NewArray<uint16_t>(locals_.size());
   IndexVars(e, var_index);
   if (body_.size() > 0) {
     // TODO(titzer): iterate over local indexes, not the bytes.
     const byte* start = &body_[0];
-    const byte* end = start + body_.size();
     size_t local_index = 0;
     for (size_t i = 0; i < body_.size();) {
       if (local_index < local_indices_.size() &&
           i == local_indices_[local_index]) {
-        int length = 0;
-        uint32_t index;
-        ReadUnsignedLEB128Operand(start + i, end, &length, &index);
+        // Read the old index.
+        uint32_t index = 0;
+        uint8_t b = 0;
+        uint32_t shift = 0;
+        while ((b = start[i++]) >= 0x80) {
+          index |= (b & 0x7F) << shift;
+          shift += 7;
+        }
+        index |= b << shift;
+
+        // Write the new index.
         uint16_t new_index = var_index[index];
-        const std::vector<uint8_t>& index_vec = UnsignedLEB128From(new_index);
-        for (size_t j = 0; j < index_vec.size(); j++) {
-          e->body_.push_back(index_vec.at(j));
+        while (new_index >= 0x80) {
+          e->body_.push_back(new_index | 0x80);
+          new_index >>= 7;
         }
-        i += length;
+        e->body_.push_back(new_index);
+
         local_index++;
       } else {
         e->body_.push_back(*(start + i));
         i++;
       }
     }
   }
   FunctionSig::Builder sig(zone, return_type_ == kAstStmt ? 0 : 1,
                            e->params_.size());
   if (return_type_ != kAstStmt) {
@@ skipping 61 matching lines @@
       external_(external),
       body_(zone),
       name_(zone) {}
 
 
 uint32_t WasmFunctionEncoder::HeaderSize() const {
   uint32_t size = 3;
   if (!external_) size += 2;
   if (HasName()) {
     uint32_t name_size = NameSize();
-    size += static_cast<uint32_t>(SizeOfVarInt(name_size)) + name_size;
+    size +=
+        static_cast<uint32_t>(LEBHelper::sizeof_u32v(name_size)) + name_size;
   }
   return size;
 }
 
 
 uint32_t WasmFunctionEncoder::BodySize(void) const {
   // TODO(titzer): embed a LocalDeclEncoder in the WasmFunctionEncoder
   LocalDeclEncoder local_decl;
   local_decl.AddLocals(local_i32_count_, kAstI32);
   local_decl.AddLocals(local_i64_count_, kAstI64);
@@ skipping 183 matching lines @@
   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;
   }
 
   void AddSection(WasmSection::Code code, size_t other_size) {
-    Add(padded_varint + SizeOfVarInt(WasmSection::getNameLength(code)) +
+    Add(padded_varint +
+            LEBHelper::sizeof_u32v(WasmSection::getNameLength(code)) +
             WasmSection::getNameLength(code),
         0);
-    if (other_size) Add(SizeOfVarInt(other_size), 0);
+    if (other_size) Add(LEBHelper::sizeof_u32v(other_size), 0);
   }
 };
 
 WasmModuleIndex* WasmModuleWriter::WriteTo(Zone* zone) const {
   Sizes sizes = {0, 0};
 
   sizes.Add(2 * sizeof(uint32_t), 0);  // header
 
   sizes.AddSection(WasmSection::Code::Memory, 0);
   sizes.Add(kDeclMemorySize, 0);
   TRACE("Size after memory: %u, %u\n", (unsigned)sizes.header_size,
         (unsigned)sizes.body_size);
 
   if (globals_.size() > 0) {
     sizes.AddSection(WasmSection::Code::Globals, globals_.size());
     /* These globals never have names, so are always 3 bytes. */
     sizes.Add(3 * globals_.size(), 0);
     TRACE("Size after globals: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (signatures_.size() > 0) {
     sizes.AddSection(WasmSection::Code::Signatures, signatures_.size());
     for (auto sig : signatures_) {
-      sizes.Add(
-          1 + SizeOfVarInt(sig->parameter_count()) + sig->parameter_count(), 0);
+      sizes.Add(1 + LEBHelper::sizeof_u32v(sig->parameter_count()) +
+                    sig->parameter_count(),
+                0);
     }
     TRACE("Size after signatures: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (functions_.size() > 0) {
     sizes.AddSection(WasmSection::Code::Functions, functions_.size());
     for (auto function : functions_) {
       sizes.Add(function->HeaderSize() + function->BodySize(),
                 function->NameSize());
     }
     TRACE("Size after functions: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (start_function_index_ >= 0) {
     sizes.AddSection(WasmSection::Code::StartFunction, 0);
-    sizes.Add(SizeOfVarInt(start_function_index_), 0);
+    sizes.Add(LEBHelper::sizeof_u32v(start_function_index_), 0);
     TRACE("Size after start: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (data_segments_.size() > 0) {
     sizes.AddSection(WasmSection::Code::DataSegments, data_segments_.size());
     for (auto segment : data_segments_) {
       sizes.Add(segment->HeaderSize(), segment->BodySize());
     }
     TRACE("Size after data segments: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
 
   if (indirect_functions_.size() > 0) {
     sizes.AddSection(WasmSection::Code::FunctionTable,
                      indirect_functions_.size());
     for (auto function_index : indirect_functions_) {
-      sizes.Add(SizeOfVarInt(function_index), 0);
+      sizes.Add(LEBHelper::sizeof_u32v(function_index), 0);
     }
     TRACE("Size after indirect functions: %u, %u\n",
           (unsigned)sizes.header_size, (unsigned)sizes.body_size);
   }
 
   if (sizes.body_size > 0) {
     sizes.AddSection(WasmSection::Code::End, 0);
     TRACE("Size after end: %u, %u\n", (unsigned)sizes.header_size,
           (unsigned)sizes.body_size);
   }
@@ skipping 90 matching lines @@
     FixupSection(section, header);
   }
 
   if (sizes.body_size > 0) {
     byte* section = EmitSection(WasmSection::Code::End, &header);
     FixupSection(section, header);
   }
 
   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