Use preexisting SharedFunctionInfos in the asm-wasm builder

src/asmjs/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
 #include <math.h>
 
 #include "src/asmjs/asm-types.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/asmjs/switch-logic.h"
 
 #include "src/wasm/wasm-macro-gen.h"
 #include "src/wasm/wasm-opcodes.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/codegen.h"
+#include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/isolate.h"
 #include "src/parsing/parse-info.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 #define RECURSE(call)               \
   do {                              \
     DCHECK(!HasStackOverflow());    \
     call;                           \
     if (HasStackOverflow()) return; \
   } while (false)
 
 enum AsmScope { kModuleScope, kInitScope, kFuncScope, kExportScope };
 enum ValueFate { kDrop, kLeaveOnStack };
 
 struct ForeignVariable {
   Handle<Name> name;
   Variable* var;
   LocalType type;
 };
 
 class AsmWasmBuilderImpl final : public AstVisitor<AsmWasmBuilderImpl> {
  public:
-  AsmWasmBuilderImpl(Isolate* isolate, Zone* zone,
+  AsmWasmBuilderImpl(Isolate* isolate, Zone* zone, CompilationInfo* info,
                      AstValueFactory* ast_value_factory, Handle<Script> script,
                      FunctionLiteral* literal, AsmTyper* typer)
       : local_variables_(ZoneHashMap::kDefaultHashMapCapacity,
                          ZoneAllocationPolicy(zone)),
         functions_(ZoneHashMap::kDefaultHashMapCapacity,
                    ZoneAllocationPolicy(zone)),
         global_variables_(ZoneHashMap::kDefaultHashMapCapacity,
                           ZoneAllocationPolicy(zone)),
         scope_(kModuleScope),
         builder_(new (zone) WasmModuleBuilder(zone)),
         current_function_builder_(nullptr),
         literal_(literal),
         isolate_(isolate),
         zone_(zone),
+        info_(info),
         ast_value_factory_(ast_value_factory),
         script_(script),
         typer_(typer),
         typer_failed_(false),
         breakable_blocks_(zone),
         foreign_variables_(zone),
         init_function_(nullptr),
         foreign_init_function_(nullptr),
         function_tables_(ZoneHashMap::kDefaultHashMapCapacity,
                          ZoneAllocationPolicy(zone)),
@@ skipping 55 matching lines @@
 
   void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
   void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK_EQ(kModuleScope, scope_);
     DCHECK_NULL(current_function_builder_);
     FunctionLiteral* old_func = decl->fun();
     Zone zone(isolate_->allocator(), ZONE_NAME);
     DeclarationScope* new_func_scope = nullptr;
     if (decl->fun()->body() == nullptr) {
-      // TODO(bradnelson): Refactor parser so we don't need a
-      // SharedFunctionInfo to parse a single function,
-      // or squirrel away the SharedFunctionInfo to use later.
-      Handle<SharedFunctionInfo> shared =
-          isolate_->factory()->NewSharedFunctionInfoForLiteral(decl->fun(),
-                                                               script_);
+      // TODO(titzer/bradnelson): Reuse SharedFunctionInfos used here when
+      // compiling the wasm module.
+      Handle<SharedFunctionInfo> shared = Compiler::GetSharedFunctionInfo(
+          decl->fun(), script_, info_, LazyCompilationMode::kAlways);
       shared->set_is_toplevel(false);
       ParseInfo info(&zone, script_);
       info.set_shared_info(shared);
       info.set_toplevel(false);
       info.set_language_mode(decl->fun()->scope()->language_mode());
       info.set_allow_lazy_parsing(false);
       info.set_function_literal_id(shared->function_literal_id());
       info.set_ast_value_factory(ast_value_factory_);
       info.set_ast_value_factory_owned(false);
       // Create fresh function scope to use to parse the function in.
@@ skipping 1776 matching lines @@
 
   ZoneHashMap local_variables_;
   ZoneHashMap functions_;
   ZoneHashMap global_variables_;
   AsmScope scope_;
   WasmModuleBuilder* builder_;
   WasmFunctionBuilder* current_function_builder_;
   FunctionLiteral* literal_;
   Isolate* isolate_;
   Zone* zone_;
+  CompilationInfo* info_;
   AstValueFactory* ast_value_factory_;
   Handle<Script> script_;
   AsmTyper* typer_;
   bool typer_failed_;
   ZoneVector<std::pair<BreakableStatement*, bool>> breakable_blocks_;
   ZoneVector<ForeignVariable> foreign_variables_;
   WasmFunctionBuilder* init_function_;
   WasmFunctionBuilder* foreign_init_function_;
   uint32_t next_table_index_;
   ZoneHashMap function_tables_;
   ImportedFunctionTable imported_function_table_;
   // Remember the parent node for reporting the correct location for ToNumber
   // conversions after calls.
   BinaryOperation* parent_binop_;
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AsmWasmBuilderImpl);
 };
 
-AsmWasmBuilder::AsmWasmBuilder(Isolate* isolate, Zone* zone,
-                               AstValueFactory* ast_value_factory,
-                               Handle<Script> script, FunctionLiteral* literal)
-    : isolate_(isolate),
-      zone_(zone),
-      ast_value_factory_(ast_value_factory),
-      script_(script),
-      literal_(literal),
-      typer_(isolate, zone, script, literal) {}
+AsmWasmBuilder::AsmWasmBuilder(CompilationInfo* info)
+    : info_(info),
+      typer_(info->isolate(), info->zone(), info->script(), info->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.
 AsmWasmBuilder::Result AsmWasmBuilder::Run(Handle<FixedArray>* foreign_args) {
-  AsmWasmBuilderImpl impl(isolate_, zone_, ast_value_factory_, script_,
-                          literal_, &typer_);
+  Zone* zone = info_->zone();
+  AsmWasmBuilderImpl impl(info_->isolate(), zone, info_,
+                          info_->parse_info()->ast_value_factory(),
+                          info_->script(), info_->literal(), &typer_);
   bool success = impl.Build();
   *foreign_args = impl.GetForeignArgs();
-  ZoneBuffer* module_buffer = new (zone_) ZoneBuffer(zone_);
+  ZoneBuffer* module_buffer = new (zone) ZoneBuffer(zone);
   impl.builder_->WriteTo(*module_buffer);
-  ZoneBuffer* asm_offsets_buffer = new (zone_) ZoneBuffer(zone_);
+  ZoneBuffer* asm_offsets_buffer = new (zone) ZoneBuffer(zone);
   impl.builder_->WriteAsmJsOffsetTable(*asm_offsets_buffer);
   return {module_buffer, asm_offsets_buffer, success};
 }
 
 const char* AsmWasmBuilder::foreign_init_name = "__foreign_init__";
 const char* AsmWasmBuilder::single_function_name = "__single_function__";
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8