[wasm] Introduce EmitVarInt and EmitWithVarInt

src/wasm/wasm-module-builder.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/objects-inl.h"
 #include "src/v8.h"
 #include "src/zone/zone-containers.h"
@@ skipping 44 matching lines @@
       body_(builder->zone()),
       name_(builder->zone()),
       exported_names_(builder->zone()),
       i32_temps_(builder->zone()),
       i64_temps_(builder->zone()),
       f32_temps_(builder->zone()),
       f64_temps_(builder->zone()),
       direct_calls_(builder->zone()),
       asm_offsets_(builder->zone(), 8) {}
 
+void WasmFunctionBuilder::EmitVarInt(int32_t val) {
+  byte buffer[5];
+  byte* ptr = buffer;
+  LEBHelper::write_i32v(&ptr, val);
+  DCHECK_GE(5, ptr - buffer);
+  body_.insert(body_.end(), buffer, ptr);
+}
+
 void WasmFunctionBuilder::EmitVarUint(uint32_t val) {
-  byte buffer[8];
+  byte buffer[5];
   byte* ptr = buffer;
   LEBHelper::write_u32v(&ptr, val);
-  for (byte* p = buffer; p < ptr; p++) {
-    body_.push_back(*p);
-  }
+  DCHECK_GE(5, ptr - buffer);
+  body_.insert(body_.end(), buffer, ptr);
 }
 
 void WasmFunctionBuilder::SetSignature(FunctionSig* sig) {
   DCHECK(!locals_.has_sig());
   locals_.set_sig(sig);
   signature_index_ = builder_->AddSignature(sig);
 }
 
 uint32_t WasmFunctionBuilder::AddLocal(ValueType type) {
   DCHECK(locals_.has_sig());
@@ skipping 27 matching lines @@
   body_.push_back(immediate);
 }
 
 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, int32_t immediate) {
+  body_.push_back(static_cast<byte>(opcode));
+  EmitVarInt(immediate);
+}
+
 void WasmFunctionBuilder::EmitWithVarUint(WasmOpcode opcode,
                                           uint32_t immediate) {
   body_.push_back(static_cast<byte>(opcode));
   EmitVarUint(immediate);
 }
 
 void WasmFunctionBuilder::EmitI32Const(int32_t value) {
-  if (-64 <= value && value <= 63) {
-    EmitWithU8(kExprI32Const, static_cast<byte>(value & 0x7F));
-  } else {
-    // TODO(titzer): variable-length signed and unsigned i32 constants.
-    byte code[] = {WASM_I32V_5(value)};
-    EmitCode(code, sizeof(code));
-  }
+  EmitWithVarInt(kExprI32Const, value);
 }
 
 void WasmFunctionBuilder::EmitDirectCallIndex(uint32_t index) {
   DirectCallIndex call;
   call.offset = body_.size();
   call.direct_index = index;
   direct_calls_.push_back(call);
   byte code[] = {U32V_5(0)};
   EmitCode(code, sizeof(code));
 }
@@ skipping 407 matching lines @@
   // Emit the offset table per function.
   for (auto function : functions_) {
     function->WriteAsmWasmOffsetTable(buffer);
   }
   // Append a 0 to indicate that this is an encoded table.
   buffer.write_u8(0);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8