[wasm] Introduce Encoder::GetLocal and Encoder::SetLocal utilities.

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 492 matching lines @@
       default: { return false; }
     }
     byte code[] = {WASM_F64(value)};
     current_function_builder_->EmitCode(code, sizeof(code));
     return true;
   }
 
   void VisitVariableProxy(VariableProxy* expr) {
     if (in_function_) {
       Variable* var = expr->var();
+      LocalType var_type = TypeOf(expr);
       if (is_set_op_) {
+        is_set_op_ = false;
         if (var->IsContextSlot()) {
-          current_function_builder_->Emit(kExprStoreGlobal);
+          return current_function_builder_->EmitWithVarInt(
+              kExprStoreGlobal, LookupOrInsertGlobal(var, var_type));
         } else {
-          current_function_builder_->Emit(kExprSetLocal);
+          return current_function_builder_->EmitSetLocal(
+              LookupOrInsertLocal(var, var_type));
         }
-        is_set_op_ = false;
       } else {
         if (VisitStdlibConstant(var)) {
           return;
         }
         if (var->IsContextSlot()) {
-          current_function_builder_->Emit(kExprLoadGlobal);
+          return current_function_builder_->EmitWithVarInt(
+              kExprLoadGlobal, LookupOrInsertGlobal(var, var_type));
         } else {
-          current_function_builder_->Emit(kExprGetLocal);
+          return current_function_builder_->EmitGetLocal(
+              LookupOrInsertLocal(var, var_type));
         }
       }
-      LocalType var_type = TypeOf(expr);
-      DCHECK_NE(kAstStmt, var_type);
-      if (var->IsContextSlot()) {
-        AddLeb128(LookupOrInsertGlobal(var, var_type), false);
-      } else {
-        AddLeb128(LookupOrInsertLocal(var, var_type), true);
-      }
     }
   }
 
   void VisitLiteral(Literal* expr) {
     Handle<Object> value = expr->value();
     if (!in_function_ || !value->IsNumber()) {
       return;
     }
     Type* type = expr->bounds().upper;
     if (type->Is(cache_.kAsmSigned)) {
@@ skipping 833 matching lines @@
           break;
         }
         default:
           UNREACHABLE();
       }
       RECURSE(Visit(expr->left()));
       RECURSE(Visit(expr->right()));
     }
   }
 
-  void AddLeb128(uint32_t index, bool is_local) {
-    std::vector<uint8_t> index_vec = UnsignedLEB128From(index);
-    if (is_local) {
-      uint32_t pos_of_index[1] = {0};
-      current_function_builder_->EmitCode(
-          &index_vec[0], static_cast<uint32_t>(index_vec.size()), pos_of_index,
-          1);
-    } else {
-      current_function_builder_->EmitCode(
-          &index_vec[0], static_cast<uint32_t>(index_vec.size()));
-    }
-  }
-
   void VisitCompareOperation(CompareOperation* expr) {
     switch (expr->op()) {
       BINOP_CASE(Token::EQ, Eq, NON_SIGNED_BINOP, false);
       BINOP_CASE(Token::LT, Lt, SIGNED_BINOP, false);
       BINOP_CASE(Token::LTE, Le, SIGNED_BINOP, false);
       BINOP_CASE(Token::GT, Gt, SIGNED_BINOP, false);
       BINOP_CASE(Token::GTE, Ge, SIGNED_BINOP, false);
       default:
         UNREACHABLE();
     }
@@ skipping 197 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