Revert of [wasm] Update {i32,i64}.const to use signed leb128

src/wasm/asm-wasm-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/v8.h"
 
 // Required to get M_E etc. in MSVC.
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #endif
@@ skipping 219 matching lines @@
     if (!in_function_) {
       marking_exported = false;
     }
   }
 
   void VisitWithStatement(WithStatement* stmt) { UNREACHABLE(); }
 
   void SetLocalTo(uint16_t index, int value) {
     current_function_builder_->Emit(kExprSetLocal);
     AddLeb128(index, true);
-    // TODO(bradnelson): variable size
-    byte code[] = {WASM_I32V(value)};
+    byte code[] = {WASM_I32(value)};
     current_function_builder_->EmitCode(code, sizeof(code));
     block_size_++;
   }
 
   void CompileCase(CaseClause* clause, uint16_t fall_through,
                    VariableProxy* tag) {
     Literal* label = clause->label()->AsLiteral();
     DCHECK_NOT_NULL(label);
     block_size_++;
     current_function_builder_->Emit(kExprIf);
@@ skipping 207 matching lines @@
     }
   }
 
   void VisitLiteral(Literal* expr) {
     if (in_function_) {
       if (expr->raw_value()->IsNumber()) {
         LocalType type = TypeOf(expr);
         switch (type) {
           case kAstI32: {
             int val = static_cast<int>(expr->raw_value()->AsNumber());
-            // TODO(bradnelson): variable size
-            byte code[] = {WASM_I32V(val)};
+            byte code[] = {WASM_I32(val)};
             current_function_builder_->EmitCode(code, sizeof(code));
             break;
           }
           case kAstF32: {
             float val = static_cast<float>(expr->raw_value()->AsNumber());
             byte code[] = {WASM_F32(val)};
             current_function_builder_->EmitCode(code, sizeof(code));
             break;
           }
           case kAstF64: {
@@ skipping 256 matching lines @@
               return;
             }
           }
         } else {
           MaybeHandle<Object> maybe_nvalue =
               i::Object::ToInt32(isolate_, value);
           if (!maybe_nvalue.is_null()) {
             Handle<Object> nvalue = maybe_nvalue.ToHandleChecked();
             if (nvalue->IsNumber()) {
               int32_t val = static_cast<int32_t>(nvalue->Number());
-              // TODO(bradnelson): variable size
-              byte code[] = {WASM_I32V(val)};
+              byte code[] = {WASM_I32(val)};
               current_function_builder_->EmitCode(code, sizeof(code));
               return;
             }
           }
         }
       }
     }
     if (is_float) {
       byte code[] = {WASM_F64(std::numeric_limits<double>::quiet_NaN())};
       current_function_builder_->EmitCode(code, sizeof(code));
     } else {
-      byte code[] = {WASM_I32V_1(0)};
+      byte code[] = {WASM_I32(0)};
       current_function_builder_->EmitCode(code, sizeof(code));
     }
   }
 
   void VisitProperty(Property* expr) {
     Expression* obj = expr->obj();
     DCHECK_EQ(obj->bounds().lower, obj->bounds().upper);
     Type* type = obj->bounds().lower;
     MachineType mtype;
     int size;
@@ skipping 37 matching lines @@
       // Early versions of Emscripten emit HEAP8[HEAP32[..]|0] in
       // places that strictly should be HEAP8[HEAP32[..]>>0].
       RECURSE(Visit(expr->key()));
       return;
     } else {
       Literal* value = expr->key()->AsLiteral();
       if (value) {
         DCHECK(value->raw_value()->IsNumber());
         DCHECK_EQ(kAstI32, TypeOf(value));
         int val = static_cast<int>(value->raw_value()->AsNumber());
-        // TODO(bradnelson): variable size
-        byte code[] = {WASM_I32V(val * size)};
+        byte code[] = {WASM_I32(val * size)};
         current_function_builder_->EmitCode(code, sizeof(code));
         return;
       }
       BinaryOperation* binop = expr->key()->AsBinaryOperation();
       if (binop) {
         DCHECK_EQ(Token::SAR, binop->op());
         DCHECK(binop->right()->AsLiteral()->raw_value()->IsNumber());
         DCHECK(kAstI32 == TypeOf(binop->right()->AsLiteral()));
         DCHECK_EQ(size,
                   1 << static_cast<int>(
@@ skipping 224 matching lines @@
       case Call::KEYED_PROPERTY_CALL: {
         DCHECK(in_function_);
         Property* p = expr->expression()->AsProperty();
         DCHECK_NOT_NULL(p);
         VariableProxy* var = p->obj()->AsVariableProxy();
         DCHECK_NOT_NULL(var);
         FunctionTableIndices* indices = LookupFunctionTable(var->var());
         current_function_builder_->EmitWithU8(kExprCallIndirect,
                                               indices->signature_index);
         current_function_builder_->Emit(kExprI32Add);
-        // TODO(bradnelson): variable size
-        byte code[] = {WASM_I32V(indices->start_index)};
+        byte code[] = {WASM_I32(indices->start_index)};
         current_function_builder_->EmitCode(code, sizeof(code));
         RECURSE(Visit(p->key()));
         break;
       }
       default:
         UNREACHABLE();
     }
     VisitCallArgs(expr);
   }
 
@@ skipping 441 matching lines @@
 // that zone in constructor may be thrown away once wasm module is written.
 WasmModuleIndex* AsmWasmBuilder::Run() {
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_, foreign_, typer_);
   impl.Compile();
   WasmModuleWriter* writer = impl.builder_->Build(zone_);
   return writer->WriteTo(zone_);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8