[wasm] Master CL for Binary 0xC changes.

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>
@@ skipping 55 matching lines @@
   };
 
   ~AsmTyper() = default;
   AsmTyper(Isolate* isolate, Zone* zone, Script* script, FunctionLiteral* root);
 
   bool Validate();
 
   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_; }
 
+  // Each FFI import has a usage-site signature associated with it.
+  struct FFIUseSignature {
+    Variable* var;
+    ZoneVector<AsmType*> arg_types_;
+    AsmType* return_type_;
+    FFIUseSignature(Variable* v, Zone* zone)
+        : var(v), arg_types_(zone), return_type_(nullptr) {}
+  };
+
+  const ZoneVector<FFIUseSignature>* FFIUseSignatures() {

[Mircea Trofin, 2016/09/19 16:16:24]

could this be const ZoneVector<FFIUseSignature>&, since it's a const.

Also, why is FFIUseSignature stored by value and not as a pointer? Seems odd,
esp. when compared to forward_definitions_, which is as a pointer.

+    return &ffi_use_signatures_;
+  }
+
  private:
   friend class v8::internal::wasm::AsmTyperHarnessBuilder;
 
   class VariableInfo : public ZoneObject {
    public:
     enum Mutability {
       kInvalidMutability,
       kLocal,
       kMutableGlobal,
       kImmutableGlobal,
@@ skipping 93 matching lines @@
   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);
+  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* ValidateGlobalDeclaration(Assignment* assign);
   // 6.2 ValidateExport
   AsmType* ExportType(VariableProxy* fun_export);
   AsmType* ValidateExport(ReturnStatement* exports);
@@ skipping 93 matching lines @@
 
   Isolate* isolate_;
   Zone* zone_;
   Script* script_;
   FunctionLiteral* root_;
   bool in_function_ = false;
 
   AsmType* return_type_ = nullptr;
 
   ZoneVector<VariableInfo*> forward_definitions_;
+  ZoneVector<FFIUseSignature> ffi_use_signatures_;
   ObjectTypeMap stdlib_types_;
   ObjectTypeMap stdlib_math_types_;
 
   // The ASM module name. This member is used to prevent globals from redefining
   // 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_;
   static const int kErrorMessageLimit = 100;
   AsmType* fround_type_;
   AsmType* ffi_type_;
   char error_message_[kErrorMessageLimit];
   StdlibSet stdlib_uses_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AsmTyper);
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // SRC_ASMJS_ASM_TYPER_H_