[wasm] [asm.js] Track direct function indices and fixup.

src/asmjs/asm-wasm-builder.cc

 // Copyright 2015 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/v8.h"
 
 // Required to get M_E etc. in MSVC.
 #if defined(_WIN32)
 #define _USE_MATH_DEFINES
 #endif
@@ skipping 90 matching lines @@
   i::Handle<i::FixedArray> GetForeignArgs() {
     i::Handle<FixedArray> ret = isolate_->factory()->NewFixedArray(
         static_cast<int>(foreign_variables_.size()));
     for (size_t i = 0; i < foreign_variables_.size(); ++i) {
       ForeignVariable* fv = &foreign_variables_[i];
       ret->set(static_cast<int>(i), *fv->name);
     }
     return ret;
   }
 
-  void BuildImports() {
-    for (const AsmTyper::FFIUseSignature& ffi : typer_->FFIUseSignatures()) {
-      size_t ret_count = ffi.return_type_ == AsmType::Void() ? 0 : 1;
-      FunctionSig::Builder b(zone_, ret_count, ffi.arg_types_.size());
-      for (AsmType* arg : ffi.arg_types_) b.AddParam(TypeFrom(arg));
-      if (ffi.return_type_ != AsmType::Void()) {
-        b.AddReturn(TypeFrom(ffi.return_type_));
-      }
-      imported_function_table_.AddFunction(ffi.var, b.Build());
-    }
-  }
-
   void Build() {
-    BuildImports();
     InitializeInitFunction();
     RECURSE(VisitFunctionLiteral(literal_));
     BuildForeignInitFunction();
   }
 
   void VisitVariableDeclaration(VariableDeclaration* decl) {}
 
   void VisitFunctionDeclaration(FunctionDeclaration* decl) {
     DCHECK_EQ(kModuleScope, scope_);
     DCHECK_NULL(current_function_builder_);
@@ skipping 591 matching lines @@
     ZoneHashMap::Entry* entry =
         function_tables_.Lookup(v, ComputePointerHash(v));
     DCHECK_NOT_NULL(entry);
     return reinterpret_cast<FunctionTableIndices*>(entry->value);
   }
 
   class ImportedFunctionTable {
    private:
     class ImportedFunctionIndices : public ZoneObject {
      public:
-      bool has_name_;
+      const char* name_;
+      int name_length_;
       WasmModuleBuilder::SignatureMap signature_to_index_;
 
-      explicit ImportedFunctionIndices(Zone* zone)
-          : has_name_(false), signature_to_index_(zone) {}
+      ImportedFunctionIndices(const char* name, int name_length, Zone* zone)
+          : name_(name), name_length_(name_length), signature_to_index_(zone) {}
     };
     ZoneHashMap table_;
     AsmWasmBuilderImpl* builder_;
 
    public:
     explicit ImportedFunctionTable(AsmWasmBuilderImpl* builder)
         : table_(ZoneHashMap::kDefaultHashMapCapacity,
                  ZoneAllocationPolicy(builder->zone())),
           builder_(builder) {}
 
-    // Set the imported name of a variable. Must happen after all signatures
-    // (and thus import indices) are added for a given variable.
-    void SetImportName(Variable* v, const char* name, int name_length) {
-      auto indices = GetEntry(v);
-      if (indices) {
-        for (auto entry : indices->signature_to_index_) {
-          uint32_t index = entry.second;
-          builder_->builder_->SetImportName(index, name, name_length);
-        }
-        indices->has_name_ = true;
-      }
+    void AddImport(Variable* v, const char* name, int name_length) {
+      ImportedFunctionIndices* indices = new (builder_->zone())
+          ImportedFunctionIndices(name, name_length, builder_->zone());
+      auto* entry = table_.LookupOrInsert(
+          v, ComputePointerHash(v), ZoneAllocationPolicy(builder_->zone()));
+      entry->value = indices;
     }
 
-    // Get a function's index. Does not insert new entries.
-    uint32_t GetFunctionIndex(Variable* v, FunctionSig* sig) {
-      auto indices = GetEntry(v);
-      DCHECK_NOT_NULL(indices);
-      auto pos = indices->signature_to_index_.find(sig);
-      DCHECK(pos != indices->signature_to_index_.end());
-      return pos->second;
-    }
-
-    // Add a function and register it as an import with the builder.
-    void AddFunction(Variable* v, FunctionSig* sig) {
-      auto entry = table_.LookupOrInsert(
-          v, ComputePointerHash(v), ZoneAllocationPolicy(builder_->zone()));
-      if (entry->value == nullptr) {
-        entry->value =
-            new (builder_->zone()) ImportedFunctionIndices(builder_->zone());
+    // Get a function's index (or allocate if new).
+    uint32_t LookupOrInsertImport(Variable* v, FunctionSig* sig) {
+      ZoneHashMap::Entry* entry = table_.Lookup(v, ComputePointerHash(v));
+      DCHECK_NOT_NULL(entry);
+      ImportedFunctionIndices* indices =
+          reinterpret_cast<ImportedFunctionIndices*>(entry->value);
+      WasmModuleBuilder::SignatureMap::iterator pos =
+          indices->signature_to_index_.find(sig);
+      if (pos != indices->signature_to_index_.end()) {
+        return pos->second;
+      } else {
+        uint32_t index = builder_->builder_->AddImport(
+            indices->name_, indices->name_length_, sig);
+        indices->signature_to_index_[sig] = index;
+        return index;
       }
-      auto indices = reinterpret_cast<ImportedFunctionIndices*>(entry->value);
-      DCHECK(!indices->has_name_);
-      auto pos = indices->signature_to_index_.find(sig);
-      if (pos == indices->signature_to_index_.end()) {
-        // A new import. Name is not known up front.
-        uint32_t index = builder_->builder_->AddImport(nullptr, 0, sig);
-        indices->signature_to_index_[sig] = index;
-      }
-    }
-
-    ImportedFunctionIndices* GetEntry(Variable* v) {
-      auto entry = table_.Lookup(v, ComputePointerHash(v));
-      if (entry == nullptr) return nullptr;
-      return reinterpret_cast<ImportedFunctionIndices*>(entry->value);
     }
   };
 
   void EmitAssignmentLhs(Expression* target, MachineType* mtype) {
     // Match the left hand side of the assignment.
     VariableProxy* target_var = target->AsVariableProxy();
     if (target_var != nullptr) {
       // Left hand side is a local or a global variable, no code on LHS.
       return;
     }
@@ skipping 130 matching lines @@
       }
       Property* prop = expr->value()->AsProperty();
       if (prop != nullptr) {
         VariableProxy* vp = prop->obj()->AsVariableProxy();
         if (vp != nullptr && vp->var()->IsParameter() &&
             vp->var()->index() == 1) {
           VariableProxy* target = expr->target()->AsVariableProxy();
           if (typer_->TypeOf(target)->AsFFIType() != nullptr) {
             const AstRawString* name =
                 prop->key()->AsLiteral()->AsRawPropertyName();
-            imported_function_table_.SetImportName(
+            imported_function_table_.AddImport(
                 target->var(), reinterpret_cast<const char*>(name->raw_data()),
                 name->length());
           }
         }
         // Property values in module scope don't emit code, so return.
         return;
       }
       ArrayLiteral* funcs = expr->value()->AsArrayLiteral();
       if (funcs != nullptr &&
           typer_->TypeOf(funcs)
@@ skipping 430 matching lines @@
           FunctionSig::Builder sig(zone(), return_type == kAstStmt ? 0 : 1,
                                    args->length());
           if (return_type != kAstStmt) {
             sig.AddReturn(return_type);
           } else {
             returns_value = false;
           }
           for (int i = 0; i < args->length(); ++i) {
             sig.AddParam(TypeOf(args->at(i)));
           }
-          uint32_t index =
-              imported_function_table_.GetFunctionIndex(vp->var(), sig.Build());
+          uint32_t index = imported_function_table_.LookupOrInsertImport(
+              vp->var(), sig.Build());
           VisitCallArgs(expr);
           current_function_builder_->Emit(kExprCallFunction);
           current_function_builder_->EmitVarInt(index);
         } else {
           WasmFunctionBuilder* function = LookupOrInsertFunction(vp->var());
           VisitCallArgs(expr);
           current_function_builder_->Emit(kExprCallFunction);
-          current_function_builder_->EmitVarInt(function->func_index());
+          current_function_builder_->EmitDirectCallIndex(
+              function->func_index());
           returns_value = function->signature()->return_count() > 0;
         }
         break;
       }
       case Call::KEYED_PROPERTY_CALL: {
         DCHECK_EQ(kFuncScope, scope_);
         Property* p = expr->expression()->AsProperty();
         DCHECK_NOT_NULL(p);
         VariableProxy* var = p->obj()->AsVariableProxy();
         DCHECK_NOT_NULL(var);
@@ skipping 498 matching lines @@
   impl.builder_->WriteTo(*buffer);
   return buffer;
 }
 
 const char* AsmWasmBuilder::foreign_init_name = "__foreign_init__";
 const char* AsmWasmBuilder::single_function_name = "__single_function__";
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8