[wasm] asm.js - Parse and convert asm.js to wasm a function at a time.

src/asmjs/asm-typer.cc

 // Copyright 2016 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/asmjs/asm-typer.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <string>
@@ skipping 73 matching lines @@
       context_stack_.emplace_back(
           Context(current_statement->AsBlock()->statements()));
       continue;
     }
 
     return current_statement;
   }
 }
 
 // ----------------------------------------------------------------------------
+// Implementation of AsmTyper::SourceLayoutTracker
+
+bool AsmTyper::SourceLayoutTracker::IsValid() const {
+  const Section* kAllSections[] = {&use_asm_, &globals_, &functions_, &tables_,
+                                   &exports_};
+  for (size_t ii = 0; ii < arraysize(kAllSections); ++ii) {
+    const auto& curr_section = *kAllSections[ii];
+    for (size_t jj = ii + 1; jj < arraysize(kAllSections); ++jj) {
+      if (curr_section.OverlapsWith(*kAllSections[jj])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void AsmTyper::SourceLayoutTracker::Section::AddNewElement(
+    const AstNode& node) {
+  const int node_pos = node.position();
+  if (start_ == kNoSourcePosition) {
+    start_ = node_pos;
+  } else {
+    start_ = std::max(start_, node_pos);
+  }
+  if (end_ == kNoSourcePosition) {
+    end_ = node_pos;
+  } else {
+    end_ = std::max(end_, node_pos);
+  }
+}
+
+bool AsmTyper::SourceLayoutTracker::Section::OverlapsWith(
+    const Section& other) const {
+  if (start_ == kNoSourcePosition) {
+    DCHECK_EQ(end_, kNoSourcePosition);
+    return false;
+  }
+  if (other.start_ == kNoSourcePosition) {
+    DCHECK_EQ(other.end_, kNoSourcePosition);
+    return false;
+  }
+  return other.start_ < end_ || other.end_ < start_;
+}
+
+// ----------------------------------------------------------------------------
 // Implementation of AsmTyper::VariableInfo
 
 AsmTyper::VariableInfo* AsmTyper::VariableInfo::ForSpecialSymbol(
     Zone* zone, StandardMember standard_member) {
   DCHECK(standard_member == kStdlib || standard_member == kFFI ||
          standard_member == kHeap || standard_member == kModule);
   auto* new_var_info = new (zone) VariableInfo(AsmType::None());
   new_var_info->standard_member_ = standard_member;
   new_var_info->mutability_ = kImmutableGlobal;
   return new_var_info;
@@ skipping 28 matching lines @@
       stdlib_types_(zone),
       stdlib_math_types_(zone),
       module_info_(VariableInfo::ForSpecialSymbol(zone_, kModule)),
       global_scope_(ZoneHashMap::kDefaultHashMapCapacity,
                     ZoneAllocationPolicy(zone)),
       local_scope_(ZoneHashMap::kDefaultHashMapCapacity,
                    ZoneAllocationPolicy(zone)),
       stack_limit_(isolate->stack_guard()->real_climit()),
       node_types_(zone_),
       fround_type_(AsmType::FroundType(zone_)),
-      ffi_type_(AsmType::FFIType(zone_)) {
+      ffi_type_(AsmType::FFIType(zone_)),
+      function_pointer_tables_(zone_) {
   InitializeStdlib();
 }
 
 namespace {
 bool ValidAsmIdentifier(Handle<String> name) {
   static const char* kInvalidAsmNames[] = {"eval", "arguments"};
 
   for (size_t ii = 0; ii < arraysize(kInvalidAsmNames); ++ii) {
     if (strcmp(name->ToCString().get(), kInvalidAsmNames[ii]) == 0) {
       return false;
@@ skipping 274 matching lines @@
 AsmTyper::StandardMember AsmTyper::VariableAsStandardMember(Variable* var) {
   auto* var_info = Lookup(var);
   if (var_info == nullptr) {
     return kNone;
   }
   StandardMember member = var_info->standard_member();
   return member;
 }
 
 bool AsmTyper::Validate() {
-  if (!AsmType::None()->IsExactly(ValidateModule(root_))) {
+  return ValidatePhase1of2() &&
+         !AsmType::None()->IsExactly(ValidateModuleFunctions(root_)) &&
+         ValidatePhase2of2();
+}
+
+bool AsmTyper::ValidatePhase1of2() {
+  if (!AsmType::None()->IsExactly(ValidateModulePhase1of2(root_))) {
     return true;
   }
   return false;
+}
+
+bool AsmTyper::ValidateInnerFunction(FunctionDeclaration* fun_decl) {
+  if (!AsmType::None()->IsExactly(ValidateModuleFunction(fun_decl))) {
+    return true;
+  }
+  return false;
+}
+
+bool AsmTyper::ValidatePhase2of2() {
+  if (!AsmType::None()->IsExactly(ValidateModulePhase2of2(root_))) {
+    return true;
+  }
+  return false;
 }
 
 namespace {
 bool IsUseAsmDirective(Statement* first_statement) {
   ExpressionStatement* use_asm = first_statement->AsExpressionStatement();
   if (use_asm == nullptr) {
     return false;
   }
 
   Literal* use_asm_literal = use_asm->expression()->AsLiteral();
@@ skipping 19 matching lines @@
   if (assign->op() != Token::INIT) {
     // Done with initializers.
     return nullptr;
   }
   return assign;
 }
 
 }  // namespace
 
 // 6.1 ValidateModule
-namespace {
-// SourceLayoutTracker keeps track of the start and end positions of each
-// section in the asm.js source. The sections should not overlap, otherwise the
-// asm.js source is invalid.
-class SourceLayoutTracker {
- public:
-  SourceLayoutTracker() = default;
-
-  bool IsValid() const {
-    const Section* kAllSections[] = {&use_asm_, &globals_, &functions_,
-                                     &tables_, &exports_};
-    for (size_t ii = 0; ii < arraysize(kAllSections); ++ii) {
-      const auto& curr_section = *kAllSections[ii];
-      for (size_t jj = ii + 1; jj < arraysize(kAllSections); ++jj) {
-        if (curr_section.OverlapsWith(*kAllSections[jj])) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-
-  void AddUseAsm(const AstNode& node) { use_asm_.AddNewElement(node); }
-
-  void AddGlobal(const AstNode& node) { globals_.AddNewElement(node); }
-
-  void AddFunction(const AstNode& node) { functions_.AddNewElement(node); }
-
-  void AddTable(const AstNode& node) { tables_.AddNewElement(node); }
-
-  void AddExport(const AstNode& node) { exports_.AddNewElement(node); }
-
- private:
-  class Section {
-   public:
-    Section() = default;
-    Section(const Section&) = default;
-    Section& operator=(const Section&) = default;
-
-    void AddNewElement(const AstNode& node) {
-      const int node_pos = node.position();
-      if (start_ == kNoSourcePosition) {
-        start_ = node_pos;
-      } else {
-        start_ = std::max(start_, node_pos);
-      }
-      if (end_ == kNoSourcePosition) {
-        end_ = node_pos;
-      } else {
-        end_ = std::max(end_, node_pos);
-      }
-    }
-
-    bool OverlapsWith(const Section& other) const {
-      if (start_ == kNoSourcePosition) {
-        DCHECK_EQ(end_, kNoSourcePosition);
-        return false;
-      }
-      if (other.start_ == kNoSourcePosition) {
-        DCHECK_EQ(other.end_, kNoSourcePosition);
-        return false;
-      }
-      return other.start_ < end_ || other.end_ < start_;
-    }
-
-   private:
-    int start_ = kNoSourcePosition;
-    int end_ = kNoSourcePosition;
-  };
-
-  Section use_asm_;
-  Section globals_;
-  Section functions_;
-  Section tables_;
-  Section exports_;
-
-  DISALLOW_COPY_AND_ASSIGN(SourceLayoutTracker);
-};
-}  // namespace
-
-AsmType* AsmTyper::ValidateModule(FunctionLiteral* fun) {
-  SourceLayoutTracker source_layout;
-
+AsmType* AsmTyper::ValidateModulePhase1of2(FunctionLiteral* fun) {
   DeclarationScope* scope = fun->scope();
   if (!scope->is_function_scope()) FAIL(fun, "Not at function scope.");
   if (!ValidAsmIdentifier(fun->name()))
     FAIL(fun, "Invalid asm.js identifier in module name.");
   module_name_ = fun->name();
 
   // Allowed parameters: Stdlib, FFI, Mem
   static const uint32_t MaxModuleParameters = 3;
   if (scope->num_parameters() > MaxModuleParameters) {
     FAIL(fun, "asm.js modules may not have more than three parameters.");
@@ skipping 14 matching lines @@
     }
 
     auto* param_info = VariableInfo::ForSpecialSymbol(
         zone_, kModuleParamInfo[ii].standard_member);
 
     if (!AddGlobal(param, param_info)) {
       FAIL(fun, "Redeclared identifier in module parameter.");
     }
   }
 
-  ZoneVector<Assignment*> function_pointer_tables(zone_);
   FlattenedStatements iter(zone_, fun->body());
   auto* use_asm_directive = iter.Next();
   if (use_asm_directive == nullptr) {
     FAIL(fun, "Missing \"use asm\".");
   }
   // Check for extra assignment inserted by the parser when in this form:
   // (function Module(a, b, c) {... })
   ExpressionStatement* estatement = use_asm_directive->AsExpressionStatement();
   if (estatement != nullptr) {
     Assignment* assignment = estatement->expression()->AsAssignment();
     if (assignment != nullptr && assignment->target()->IsVariableProxy() &&
         assignment->target()
             ->AsVariableProxy()
             ->var()
             ->is_sloppy_function_name()) {
       use_asm_directive = iter.Next();
     }
   }
   if (!IsUseAsmDirective(use_asm_directive)) {
     FAIL(fun, "Missing \"use asm\".");
   }
-  source_layout.AddUseAsm(*use_asm_directive);
-  ReturnStatement* module_return = nullptr;
+  source_layout_.AddUseAsm(*use_asm_directive);
+  module_return_ = nullptr;
 
   // *VIOLATION* The spec states that globals should be followed by function
   // declarations, which should be followed by function pointer tables, followed
   // by the module export (return) statement. Our AST might be rearraged by the
   // parser, so we can't rely on it being in source code order.
   while (Statement* current = iter.Next()) {
     if (auto* assign = ExtractInitializerExpression(current)) {
       if (assign->value()->IsArrayLiteral()) {
         // Save function tables for later validation.
-        function_pointer_tables.push_back(assign);
+        function_pointer_tables_.push_back(assign);
       } else {
         RECURSE(ValidateGlobalDeclaration(assign));
-        source_layout.AddGlobal(*assign);
+        source_layout_.AddGlobal(*assign);
       }
       continue;
     }
 
     if (auto* current_as_return = current->AsReturnStatement()) {
-      if (module_return != nullptr) {
+      if (module_return_ != nullptr) {
         FAIL(fun, "Multiple export statements.");
       }
-      module_return = current_as_return;
-      source_layout.AddExport(*module_return);
+      module_return_ = current_as_return;
+      source_layout_.AddExport(*module_return_);
       continue;
     }
 
     FAIL(current, "Invalid top-level statement in asm.js module.");
   }
 
+  return AsmType::Int();  // Any type that is not AsmType::None();
+}
+
+AsmType* AsmTyper::ValidateModuleFunction(FunctionDeclaration* fun_decl) {
+  RECURSE(ValidateFunction(fun_decl));
+  source_layout_.AddFunction(*fun_decl);
+
+  return AsmType::Int();  // Any type that is not AsmType::None();
+}
+
+AsmType* AsmTyper::ValidateModuleFunctions(FunctionLiteral* fun) {
+  DeclarationScope* scope = fun->scope();
   ZoneList<Declaration*>* decls = scope->declarations();
 
   for (int ii = 0; ii < decls->length(); ++ii) {
     Declaration* decl = decls->at(ii);
 
     if (FunctionDeclaration* fun_decl = decl->AsFunctionDeclaration()) {
-      RECURSE(ValidateFunction(fun_decl));
-      source_layout.AddFunction(*fun_decl);
+      RECURSE(ValidateModuleFunction(fun_decl));
       continue;
     }
   }
 
-  for (auto* function_table : function_pointer_tables) {
+  return AsmType::Int();  // Any type that is not AsmType::None();
+}
+
+AsmType* AsmTyper::ValidateModulePhase2of2(FunctionLiteral* fun) {
+  for (auto* function_table : function_pointer_tables_) {
     RECURSE(ValidateFunctionTable(function_table));
-    source_layout.AddTable(*function_table);
+    source_layout_.AddTable(*function_table);
   }
 
+  DeclarationScope* scope = fun->scope();
+  ZoneList<Declaration*>* decls = scope->declarations();
   for (int ii = 0; ii < decls->length(); ++ii) {
     Declaration* decl = decls->at(ii);
 
     if (decl->IsFunctionDeclaration()) {
       continue;
     }
 
     VariableDeclaration* var_decl = decl->AsVariableDeclaration();
     if (var_decl == nullptr) {
       FAIL(decl, "Invalid asm.js declaration.");
     }
 
     auto* var_proxy = var_decl->proxy();
     if (var_proxy == nullptr) {
       FAIL(decl, "Invalid asm.js declaration.");
     }
 
     if (Lookup(var_proxy->var()) == nullptr) {
       FAIL(decl, "Global variable missing initializer in asm.js module.");
     }
   }
 
   // 6.2 ValidateExport
-  if (module_return == nullptr) {
+  if (module_return_ == nullptr) {
     FAIL(fun, "Missing asm.js module export.");
   }
 
   for (auto* forward_def : forward_definitions_) {
     if (forward_def->missing_definition()) {
       FAIL(forward_def->first_forward_use(),
            "Missing definition for forward declared identifier.");
     }
   }
 
-  RECURSE(ValidateExport(module_return));
+  RECURSE(ValidateExport(module_return_));
 
-  if (!source_layout.IsValid()) {
+  if (!source_layout_.IsValid()) {
     FAIL(fun, "Invalid asm.js source code layout.");
   }
 
   return AsmType::Int();  // Any type that is not AsmType::None();
 }
 
 namespace {
 bool IsDoubleAnnotation(BinaryOperation* binop) {
   // *VIOLATION* The parser replaces uses of +x with x*1.0.
   if (binop->op() != Token::MUL) {
@@ skipping 135 matching lines @@
   }
   SetTypeOf(assign, target_info->type());
   SetTypeOf(target, target_info->type());
   return target_info->type();
 }
 
 // 6.2 ValidateExport
 AsmType* AsmTyper::ExportType(VariableProxy* fun_export) {
   auto* fun_info = Lookup(fun_export->var());
   if (fun_info == nullptr) {
+    UNREACHABLE();
     FAIL(fun_export, "Undefined identifier in asm.js module export.");
   }
 
   if (fun_info->standard_member() != kNone) {
     FAIL(fun_export, "Module cannot export standard library functions.");
   }
 
   auto* type = fun_info->type();
   if (type->AsFFIType() != nullptr) {
     FAIL(fun_export, "Module cannot export foreign functions.");
@@ skipping 1914 matching lines @@
     return true;
   }
 
   *error_message = typer.error_message();
   return false;
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8