[wasm] Store the function_index in the js-to-wasm wrapper instead of the export index

src/wasm/wasm-module.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 <memory>
 
 #include "src/base/atomic-utils.h"
 #include "src/code-stubs.h"
 
 #include "src/macro-assembler.h"
@@ skipping 1609 matching lines @@
           isolate_->factory()->NewJSObject(object_function, TENURED);
       Handle<String> exports_name =
           isolate_->factory()->InternalizeUtf8String("exports");
       JSObject::AddProperty(instance, exports_name, exports_object, READ_ONLY);
     }
 
     PropertyDescriptor desc;
     desc.set_writable(false);
 
     // Process each export in the export table.
-    int func_index = 0;
+    int export_index = 0;
     for (auto exp : module_->export_table) {
       Handle<String> name =
           ExtractStringFromModuleBytes(isolate_, compiled_module_,
                                        exp.name_offset, exp.name_length)
               .ToHandleChecked();
       switch (exp.kind) {
         case kExternalFunction: {
           // Wrap and export the code as a JSFunction.
           WasmFunction& function = module_->functions[exp.index];
-          int export_index =
-              static_cast<int>(module_->functions.size() + func_index);
+          int func_index =
+              static_cast<int>(module_->functions.size() + export_index);
           Handle<JSFunction> js_function = js_wrappers_[exp.index];
           if (js_function.is_null()) {
             // Wrap the exported code as a JSFunction.
             Handle<Code> export_code =
-                code_table->GetValueChecked<Code>(isolate_, export_index);
-            js_function =
-                WrapExportCodeAsJSFunction(isolate_, export_code, name,
-                                           function.sig, func_index, instance);
+                code_table->GetValueChecked<Code>(isolate_, func_index);
+            js_function = WrapExportCodeAsJSFunction(
+                isolate_, export_code, name, function.sig, function.func_index,
+                instance);
             js_wrappers_[exp.index] = js_function;
           }
           desc.set_value(js_function);
-          func_index++;
+          export_index++;
           break;
         }
         case kExternalTable: {
           // Export a table as a WebAssembly.Table object.
           TableInstance& table_instance = table_instances_[exp.index];
           WasmIndirectFunctionTable& table =
               module_->function_tables[exp.index];
           if (table_instance.table_object.is_null()) {
             table_instance.table_object = WasmJs::CreateWasmTableObject(
                 isolate_, table.min_size, table.has_max, table.max_size,
@@ skipping 568 matching lines @@
     CHECK_NOT_NULL(result.val);
     module = const_cast<WasmModule*>(result.val);
   }
 
   Handle<WasmModuleWrapper> module_wrapper =
       WasmModuleWrapper::New(isolate, module);
 
   compiled_module->set_module_wrapper(module_wrapper);
   DCHECK(WasmCompiledModule::IsWasmCompiledModule(*compiled_module));
 }