[wasm] Master CL for Binary 0xC changes.

src/asmjs/asm-typer.cc

Index: src/asmjs/asm-typer.cc
diff --git a/src/asmjs/asm-typer.cc b/src/asmjs/asm-typer.cc
index 20b8d96053d31477ff81d9e9e54a8daa035706e1..a98c18b5328d4ae12dc5746130b9a56afeffdfa2 100644
--- a/src/asmjs/asm-typer.cc
+++ b/src/asmjs/asm-typer.cc
@@ -128,6 +128,7 @@ AsmTyper::AsmTyper(Isolate* isolate, Zone* zone, Script* script,
       script_(script),
       root_(root),
       forward_definitions_(zone),
+      ffi_use_signatures_(zone),
       stdlib_types_(zone),
       stdlib_math_types_(zone),
       module_info_(VariableInfo::ForSpecialSymbol(zone_, kModule)),
@@ -329,8 +330,8 @@ AsmTyper::VariableInfo* AsmTyper::ImportLookup(Property* import) {
   return i->second;
 }
 
-AsmTyper::VariableInfo* AsmTyper::Lookup(Variable* variable) {
-  ZoneHashMap* scope = in_function_ ? &local_scope_ : &global_scope_;
+AsmTyper::VariableInfo* AsmTyper::Lookup(Variable* variable) const {
+  const ZoneHashMap* scope = in_function_ ? &local_scope_ : &global_scope_;
   ZoneHashMap::Entry* entry =
       scope->Lookup(variable, ComputePointerHash(variable));
   if (entry == nullptr && in_function_) {
@@ -423,6 +424,8 @@ AsmType* AsmTyper::TypeOf(AstNode* node) const {
   return AsmType::None();
 }
 
+AsmType* AsmTyper::TypeOf(Variable* v) const { return Lookup(v)->type(); }
+
 AsmTyper::StandardMember AsmTyper::VariableAsStandardMember(Variable* var) {
   auto* var_info = Lookup(var);
   if (var_info == nullptr) {
@@ -2306,9 +2309,20 @@ AsmType* AsmTyper::ValidateCall(AsmType* return_type, Call* call) {
       FAIL(call, "Calling something that's not a function.");
     }
 
-    if (callee_type->AsFFIType() != nullptr &&
-        return_type == AsmType::Float()) {
-      FAIL(call, "Foreign functions can't return float.");
+    if (callee_type->AsFFIType() != nullptr) {
+      if (return_type == AsmType::Float()) {
+        FAIL(call, "Foreign functions can't return float.");
+      }
+      // Record FFI use signature, since the asm->wasm translator must know
+      // all uses up-front.

[bradnelson, 2016/09/23 11:36:00]

This will break my unlanded change to do validation + conversion without keeping
the whole ast in memory. :-(

Had feeling mixing the imports and others would be a pain (requires knowing how
big something is up front).

Options include:
* Fixup each function after generation once we know how many imports.
  - touches everything a second time
  - indices are variant length so could grow (would have to emit fixed length
ones)
* Presuppose all have no more than N arguments and guess signature at
declaration time
  - could be wrong, then what

It seems this would also be a huge hassle for anyone else doing a code
generator. It forces things to be two pass, unless you know all imports and
signatures up front (or are willing to re-write indices for calls at the end).
Did we want to revisit with partners?

As this change is so large it either needs to land now or never, I'd rather sort
it out myself than see this not go in very soon.

I'll probably yank this out and change the encoder to do fixed sized indices and
fixups.

[titzer, 2016/09/23 12:07:30]

Yeah, I know. This was the most annoyingly intrusive part of this change.

I also considered the patching approach, and agree that that is probably what we
should do in the future. I did it this way because that was the shorter path to
get it to work. We can do the patching in a followup.

Also note that a foreign function can be called with multiple different
signatures, so I am not sure that we can just assume a single one up front.

[bradn, 2016/09/23 15:18:43]

Yeah, only thought it work cause 4am.
Though I suppose we could use the tables plumbing to punch them in later. Yeck.

+      ffi_use_signatures_.emplace_back(
+          FFIUseSignature(call_var_proxy->var(), zone_));
+      FFIUseSignature* sig = &ffi_use_signatures_.back();
+      sig->return_type_ = return_type;
+      sig->arg_types_.reserve(args.size());
+      for (size_t i = 0; i < args.size(); ++i) {
+        sig->arg_types_.emplace_back(args[i]);
+      }
     }
 
     if (!callee_type->CanBeInvokedWith(return_type, args)) {