[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();
 
   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 110 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 OverlapsWith(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);

[titzer, 2016/11/28 10:40:11]

Seems a little weird to use AsmType* as the return type to indicate
success/fail. Is it ever used in another way?

[bradn, 2016/11/29 06:30:34]

Used so the FAIL macro can be shared throughout.
Not sure that's a great reason.

+  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 111 matching lines @@
 
   std::uintptr_t stack_limit_;
   bool stack_overflow_ = false;
   ZoneMap<AstNode*, AsmType*> 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_