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

src/asmjs/asm-typer.h

 // 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.
 
 #ifndef SRC_ASMJS_ASM_TYPER_H_
 #define SRC_ASMJS_ASM_TYPER_H_
 
 #include <cstdint>
 #include <string>
 #include <unordered_set>
 
 #include "src/allocation.h"
 #include "src/asmjs/asm-types.h"
 #include "src/ast/ast-type-bounds.h"
 #include "src/ast/ast-types.h"
 #include "src/ast/ast.h"
 #include "src/effects.h"
 #include "src/type-info.h"
 #include "src/zone/zone-containers.h"
 #include "src/zone/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 class AsmType;
 class AsmTyperHarnessBuilder;
+class SourceLayoutTracker;
 
 class AsmTyper final {
  public:
   enum StandardMember {
     kHeap = -4,
     kFFI = -3,
     kStdlib = -2,
     kModule = -1,
     kNone = 0,
     kInfinity,
@@ skipping 24 matching lines @@
     kMathLOG10E,
     kMathPI,
     kMathSQRT1_2,
     kMathSQRT2,
   };
 
   ~AsmTyper() = default;
   AsmTyper(Isolate* isolate, Zone* zone, Script* script, FunctionLiteral* root);
 
   bool Validate();
+  // Do asm.js validation in phases (to interleave with conversion to wasm).
+  bool ValidateBeforeFunctionsPhase();
+  bool ValidateInnerFunction(FunctionDeclaration* decl);
+  bool ValidateAfterFunctionsPhase();
+  void ClearFunctionNodeTypes();
 
   const char* error_message() const { return error_message_; }
 
   AsmType* TypeOf(AstNode* node) const;
   AsmType* TypeOf(Variable* v) const;
   StandardMember VariableAsStandardMember(Variable* var);
 
   typedef std::unordered_set<StandardMember, std::hash<int> > StdlibSet;
 
   StdlibSet StdlibUses() const { return stdlib_uses_; }
@@ skipping 41 matching lines @@
     bool IsGlobal() const {
       return mutability_ == kImmutableGlobal || mutability_ == kConstGlobal ||
              mutability_ == kMutableGlobal;
     }
 
     bool IsStdlib() const { return standard_member_ == kStdlib; }
     bool IsFFI() const { return standard_member_ == kFFI; }
     bool IsHeap() const { return standard_member_ == kHeap; }
 
     void MarkDefined() { missing_definition_ = false; }
-    void FirstForwardUseIs(VariableProxy* var);
+    void SetFirstForwardUse(int source_location);
 
     StandardMember standard_member() const { return standard_member_; }
     void set_standard_member(StandardMember standard_member) {
       standard_member_ = standard_member;
     }
 
     AsmType* type() const { return type_; }
     void set_type(AsmType* type) { type_ = type; }
 
     Mutability mutability() const { return mutability_; }
     void set_mutability(Mutability mutability) { mutability_ = mutability; }
 
     bool missing_definition() const { return missing_definition_; }
 
-    VariableProxy* first_forward_use() const { return first_forward_use_; }
+    int source_location() const { return source_location_; }
 
     static VariableInfo* ForSpecialSymbol(Zone* zone,
                                           StandardMember standard_member);
 
    private:
     AsmType* type_;
     StandardMember standard_member_ = kNone;
     Mutability mutability_ = kInvalidMutability;
     // missing_definition_ is set to true for forward definition - i.e., use
     // before definition.
     bool missing_definition_ = false;
-    // first_forward_use_ holds the AST node that first referenced this
+    // source_location_ holds the line number that first referenced this
     // VariableInfo. Used for error messages.
-    VariableProxy* first_forward_use_ = nullptr;
+    // TODO(bradnelson): When merged with console change, this should
+    // become a source location.
+    int source_location_ = -1;
   };
 
   // RAII-style manager for the in_function_ member variable.
   struct FunctionScope {
     explicit FunctionScope(AsmTyper* typer) : typer_(typer) {
       DCHECK(!typer_->in_function_);
       typer_->in_function_ = true;
       typer_->local_scope_.Clear();
       typer_->return_type_ = AsmType::None();
     }
@@ skipping 19 matching lines @@
       explicit Context(ZoneList<Statement*>* s) : statements_(s) {}
       ZoneList<Statement*>* statements_;
       int next_index_ = 0;
     };
 
     ZoneVector<Context> context_stack_;
 
     DISALLOW_IMPLICIT_CONSTRUCTORS(FlattenedStatements);
   };
 
+  class SourceLayoutTracker {
+   public:
+    SourceLayoutTracker() = default;
+    bool IsValid() const;
+    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);
+      bool IsPrecededBy(const Section& other) const;
+
+     private:
+      int start_ = kNoSourcePosition;
+      int end_ = kNoSourcePosition;
+    };
+
+    Section use_asm_;
+    Section globals_;
+    Section functions_;
+    Section tables_;
+    Section exports_;
+
+    DISALLOW_COPY_AND_ASSIGN(SourceLayoutTracker);
+  };
+
   using ObjectTypeMap = ZoneMap<std::string, VariableInfo*>;
   void InitializeStdlib();
   void SetTypeOf(AstNode* node, AsmType* type);
 
   void AddForwardReference(VariableProxy* proxy, VariableInfo* info);
   bool AddGlobal(Variable* global, VariableInfo* info);
   bool AddLocal(Variable* global, VariableInfo* info);
   // Used for 5.5 GlobalVariableTypeAnnotations
   VariableInfo* ImportLookup(Property* expr);
   // 3.3 Environment Lookup
   // NOTE: In the spec, the lookup function's prototype is
   //
   //   Lookup(Delta, Gamma, x)
   //
   // Delta is the global_scope_ member, and Gamma, local_scope_.
   VariableInfo* Lookup(Variable* variable) const;
 
   // All of the ValidateXXX methods below return AsmType::None() in case of
   // validation failure.
 
   // 6.1 ValidateModule
-  AsmType* ValidateModule(FunctionLiteral* fun);
+  AsmType* ValidateModuleBeforeFunctionsPhase(FunctionLiteral* fun);
+  AsmType* ValidateModuleFunction(FunctionDeclaration* fun_decl);
+  AsmType* ValidateModuleFunctions(FunctionLiteral* fun);
+  AsmType* ValidateModuleAfterFunctionsPhase(FunctionLiteral* fun);
   AsmType* ValidateGlobalDeclaration(Assignment* assign);
   // 6.2 ValidateExport
   AsmType* ExportType(VariableProxy* fun_export);
   AsmType* ValidateExport(ReturnStatement* exports);
   // 6.3 ValidateFunctionTable
   AsmType* ValidateFunctionTable(Assignment* assign);
   // 6.4 ValidateFunction
   AsmType* ValidateFunction(FunctionDeclaration* fun_decl);
   // 6.5 ValidateStatement
   AsmType* ValidateStatement(Statement* statement);
@@ skipping 104 matching lines @@
   // the module name.
   VariableInfo* module_info_;
   Handle<String> module_name_;
 
   // 3 Environments
   ZoneHashMap global_scope_;  // 3.1 Global environment
   ZoneHashMap local_scope_;   // 3.2 Variable environment
 
   std::uintptr_t stack_limit_;
   bool stack_overflow_ = false;
-  ZoneMap<AstNode*, AsmType*> node_types_;
+  ZoneMap<AstNode*, AsmType*> module_node_types_;
+  ZoneMap<AstNode*, AsmType*> function_node_types_;
   static const int kErrorMessageLimit = 128;
   AsmType* fround_type_;
   AsmType* ffi_type_;
   char error_message_[kErrorMessageLimit];
   StdlibSet stdlib_uses_;
 
+  SourceLayoutTracker source_layout_;
+  ReturnStatement* module_return_;
+  ZoneVector<Assignment*> function_pointer_tables_;
+
   DISALLOW_IMPLICIT_CONSTRUCTORS(AsmTyper);
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // SRC_ASMJS_ASM_TYPER_H_