Reland addition of init function for asm->wasm.

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"
 
 #include "src/wasm/asm-wasm-builder.h"
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
@@ skipping 28 matching lines @@
         in_function_(false),
         is_set_op_(false),
         marking_exported(false),
         builder_(new (zone) WasmModuleBuilder(zone)),
         current_function_builder_(NULL),
         literal_(literal),
         isolate_(isolate),
         zone_(zone),
         cache_(TypeCache::Get()),
         breakable_blocks_(zone),
-        block_size_(0) {
+        block_size_(0),
+        init_function_initialized(false),
+        init_function_index(0) {
     InitializeAstVisitor(isolate);
   }
 
   void Compile() { RECURSE(VisitFunctionLiteral(literal_)); }
 
   void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
   void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK(!in_function_);
     DCHECK(current_function_builder_ == NULL);
@@ skipping 12 matching lines @@
 
   void VisitStatements(ZoneList<Statement*>* stmts) {
     for (int i = 0; i < stmts->length(); ++i) {
       Statement* stmt = stmts->at(i);
       RECURSE(Visit(stmt));
       if (stmt->IsJump()) break;
     }
   }
 
   void VisitBlock(Block* stmt) {
-    if (in_function_) {
-      breakable_blocks_.push_back(
-          std::make_pair(stmt->AsBreakableStatement(), false));
-      current_function_builder_->Emit(kExprBlock);
-      uint32_t index = current_function_builder_->EmitEditableImmediate(0);
-      int prev_block_size = block_size_;
-      block_size_ = static_cast<byte>(stmt->statements()->length());
-      RECURSE(VisitStatements(stmt->statements()));
-      DCHECK(block_size_ >= 0);
-      current_function_builder_->EditImmediate(index, block_size_);
-      block_size_ = prev_block_size;
-      breakable_blocks_.pop_back();
-    } else {
-      RECURSE(VisitStatements(stmt->statements()));
+    if (stmt->statements()->length() == 1) {
+      ExpressionStatement* expr =
+          stmt->statements()->at(0)->AsExpressionStatement();
+      if (expr != NULL) {
+        if (expr->expression()->IsAssignment()) {
+          RECURSE(VisitExpressionStatement(expr));
+          return;
+        }
+      }
     }
+    DCHECK(in_function_);
+    breakable_blocks_.push_back(
+        std::make_pair(stmt->AsBreakableStatement(), false));
+    current_function_builder_->Emit(kExprBlock);
+    uint32_t index = current_function_builder_->EmitEditableImmediate(0);
+    int prev_block_size = block_size_;
+    block_size_ = static_cast<byte>(stmt->statements()->length());
+    RECURSE(VisitStatements(stmt->statements()));
+    DCHECK(block_size_ >= 0);
+    current_function_builder_->EditImmediate(index, block_size_);
+    block_size_ = prev_block_size;
+    breakable_blocks_.pop_back();
   }
 
   void VisitExpressionStatement(ExpressionStatement* stmt) {
     RECURSE(Visit(stmt->expression()));
   }
 
   void VisitEmptyStatement(EmptyStatement* stmt) {}
 
   void VisitEmptyParentheses(EmptyParentheses* paren) { UNREACHABLE(); }
 
@@ skipping 254 matching lines @@
   }
 
   void VisitArrayLiteral(ArrayLiteral* expr) {
     ZoneList<Expression*>* values = expr->values();
     for (int i = 0; i < values->length(); ++i) {
       Expression* value = values->at(i);
       RECURSE(Visit(value));
     }
   }
 
-  void VisitAssignment(Assignment* expr) {
-    if (in_function_) {
-      BinaryOperation* value_op = expr->value()->AsBinaryOperation();
-      if (value_op != NULL && MatchBinaryOperation(value_op) == kAsIs) {
-        VariableProxy* target_var = expr->target()->AsVariableProxy();
-        VariableProxy* effective_value_var =
-            GetLeft(value_op)->AsVariableProxy();
-        // TODO(aseemgarg): simplify block_size_ or replace with a kNop
-        if (target_var != NULL && effective_value_var != NULL &&
-            target_var->var() == effective_value_var->var()) {
-          block_size_--;
-          return;
-        }
-      }
-      is_set_op_ = true;
-      RECURSE(Visit(expr->target()));
-      DCHECK(!is_set_op_);
-      RECURSE(Visit(expr->value()));
+  void LoadInitFunction() {
+    if (!init_function_initialized) {
+      init_function_initialized = true;
+      unsigned char init[] = "__init__";
+      init_function_index = builder_->AddFunction(init, 8);
+      current_function_builder_ = builder_->FunctionAt(init_function_index);
+      current_function_builder_->ReturnType(kAstStmt);
+      current_function_builder_->Exported(1);
+      in_function_ = true;
+    } else {
+      current_function_builder_ = builder_->FunctionAt(init_function_index);
+      in_function_ = true;
     }
   }
 
+  void UnLoadInitFunction() {
+    in_function_ = false;
+    current_function_builder_ = NULL;
+  }
+
+  void VisitAssignment(Assignment* expr) {
+    bool in_init = false;
+    if (!in_function_) {
+      // TODO(bradnelson): Get rid of this.
+      if (TypeOf(expr->value()) == kAstStmt) {
+        return;
+      }
+      in_init = true;
+      LoadInitFunction();
+    }
+    BinaryOperation* value_op = expr->value()->AsBinaryOperation();
+    if (value_op != NULL && MatchBinaryOperation(value_op) == kAsIs) {
+      VariableProxy* target_var = expr->target()->AsVariableProxy();
+      VariableProxy* effective_value_var = GetLeft(value_op)->AsVariableProxy();
+      // TODO(aseemgarg): simplify block_size_ or replace with a kNop
+      if (target_var != NULL && effective_value_var != NULL &&
+          target_var->var() == effective_value_var->var()) {
+        block_size_--;
+        return;
+      }
+    }
+    is_set_op_ = true;
+    RECURSE(Visit(expr->target()));
+    DCHECK(!is_set_op_);
+    RECURSE(Visit(expr->value()));
+    if (in_init) {
+      UnLoadInitFunction();
+    }
+  }
+
   void VisitYield(Yield* expr) {
     RECURSE(Visit(expr->generator_object()));
     RECURSE(Visit(expr->expression()));
   }
 
   void VisitThrow(Throw* expr) { RECURSE(Visit(expr->exception())); }
 
   void VisitProperty(Property* expr) {
     Expression* obj = expr->obj();
     DCHECK(obj->bounds().lower == obj->bounds().upper);
@@ skipping 505 matching lines @@
   bool is_set_op_;
   bool marking_exported;
   WasmModuleBuilder* builder_;
   WasmFunctionBuilder* current_function_builder_;
   FunctionLiteral* literal_;
   Isolate* isolate_;
   Zone* zone_;
   TypeCache const& cache_;
   ZoneVector<std::pair<BreakableStatement*, bool>> breakable_blocks_;
   int block_size_;
+  bool init_function_initialized;
+  uint16_t init_function_index;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AsmWasmBuilderImpl);
 };
 
 AsmWasmBuilder::AsmWasmBuilder(Isolate* isolate, Zone* zone,
                                FunctionLiteral* literal)
     : isolate_(isolate), zone_(zone), literal_(literal) {}
 
 // 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.
 WasmModuleIndex* AsmWasmBuilder::Run() {
   AsmWasmBuilderImpl impl(isolate_, zone_, literal_);
   impl.Compile();
   WasmModuleWriter* writer = impl.builder_->Build(zone_);
   return writer->WriteTo(zone_);
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8