[wasm] Remove redundant intermediate data structures in encoder.cc.

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 72 matching lines @@
 
   void BuildForeignInitFunction() {
     foreign_init_function_index_ = builder_->AddFunction();
     FunctionSig::Builder b(zone(), 0, foreign_variables_.size());
     for (auto i = foreign_variables_.begin(); i != foreign_variables_.end();
          ++i) {
       b.AddParam(i->type);
     }
     current_function_builder_ =
         builder_->FunctionAt(foreign_init_function_index_);
-    current_function_builder_->Exported(1);
+    current_function_builder_->SetExported();
     std::string raw_name = "__foreign_init__";
     current_function_builder_->SetName(raw_name.data(),
                                        static_cast<int>(raw_name.size()));
     current_function_builder_->SetSignature(b.Build());
     for (size_t pos = 0; pos < foreign_variables_.size(); ++pos) {
       current_function_builder_->EmitGetLocal(static_cast<uint32_t>(pos));
       ForeignVariable* fv = &foreign_variables_[pos];
       uint32_t index = LookupOrInsertGlobal(fv->var, fv->type);
       current_function_builder_->EmitWithVarInt(kExprStoreGlobal, index);
     }
     current_function_builder_ = nullptr;
   }
 
   i::Handle<i::FixedArray> GetForeignArgs() {
     i::Handle<FixedArray> ret = isolate_->factory()->NewFixedArray(
         static_cast<int>(foreign_variables_.size()));
     for (size_t i = 0; i < foreign_variables_.size(); ++i) {
       ForeignVariable* fv = &foreign_variables_[i];
       ret->set(static_cast<int>(i), *fv->name);
     }
     return ret;
   }
 
-  void Compile() {
+  void Build() {
     InitializeInitFunction();
     RECURSE(VisitFunctionLiteral(literal_));
     BuildForeignInitFunction();
   }
 
   void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
   void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK_EQ(kModuleScope, scope_);
     DCHECK_NULL(current_function_builder_);
@@ skipping 472 matching lines @@
       DCHECK_EQ(kExportScope, scope_);
       VariableProxy* expr = prop->value()->AsVariableProxy();
       DCHECK_NOT_NULL(expr);
       Variable* var = expr->var();
       Literal* name = prop->key()->AsLiteral();
       DCHECK_NOT_NULL(name);
       DCHECK(name->IsPropertyName());
       const AstRawString* raw_name = name->AsRawPropertyName();
       if (var->is_function()) {
         uint32_t index = LookupOrInsertFunction(var);
-        builder_->FunctionAt(index)->Exported(1);
+        builder_->FunctionAt(index)->SetExported();
         builder_->FunctionAt(index)->SetName(
             reinterpret_cast<const char*>(raw_name->raw_data()),
             raw_name->length());
       }
     }
   }
 
   void VisitArrayLiteral(ArrayLiteral* expr) { UNREACHABLE(); }
 
   void LoadInitFunction() {
@@ skipping 1133 matching lines @@
 };
 
 AsmWasmBuilder::AsmWasmBuilder(Isolate* isolate, Zone* zone,
                                FunctionLiteral* literal, AsmTyper* typer)
     : isolate_(isolate), zone_(zone), literal_(literal), typer_(typer) {}
 
 // TODO(aseemgarg): probably should take zone (to write wasm to) as input so
 // that zone in constructor may be thrown away once wasm module is written.
 ZoneBuffer* AsmWasmBuilder::Run(i::Handle<i::FixedArray>* foreign_args) {
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_, typer_);
-  impl.Compile();
+  impl.Build();
   *foreign_args = impl.GetForeignArgs();
   ZoneBuffer* buffer = new (zone_) ZoneBuffer(zone_);
-  WasmModuleWriter* writer = impl.builder_->Build(zone_);
-  writer->WriteTo(*buffer);
+  impl.builder_->WriteTo(*buffer);
   return buffer;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8