[wasm] Names of exported functions should be the stringified function 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/compiler/wasm-compiler.h"
 #include "src/debug/interface-types.h"
@@ skipping 1320 matching lines @@
     //--------------------------------------------------------------------------
     if (module_->start_function_index >= 0) {
       HandleScope scope(isolate_);
       int start_index = module_->start_function_index;
       Handle<Code> startup_code =
           code_table->GetValueChecked<Code>(isolate_, start_index);
       FunctionSig* sig = module_->functions[start_index].sig;
       Handle<Code> wrapper_code = compiler::CompileJSToWasmWrapper(
           isolate_, module_, startup_code, start_index);
       Handle<WasmExportedFunction> startup_fct = WasmExportedFunction::New(
-          isolate_, instance, factory->InternalizeUtf8String("start"),
-          wrapper_code, static_cast<int>(sig->parameter_count()), start_index);
+          isolate_, instance, MaybeHandle<String>(), start_index,
+          static_cast<int>(sig->parameter_count()), wrapper_code);
       RecordStats(isolate_, *startup_code);
       // Call the JS function.
       Handle<Object> undefined = factory->undefined_value();
       MaybeHandle<Object> retval =
           Execution::Call(isolate_, startup_fct, undefined, 0, nullptr);
 
       if (retval.is_null()) {
         DCHECK(isolate_->has_pending_exception());
         isolate_->OptionalRescheduleException(false);
         // It's unfortunate that the new instance is already linked in the
@@ skipping 400 matching lines @@
         case kExternalFunction: {
           // Wrap and export the code as a JSFunction.
           WasmFunction& function = module_->functions[exp.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_, func_index);
-            Handle<String> func_name = name;
+            MaybeHandle<String> func_name;
             if (module_->origin == kAsmJsOrigin) {
               // For modules arising from asm.js, honor the names section.
               func_name = ExtractStringFromModuleBytes(
                               isolate_, compiled_module_, function.name_offset,
                               function.name_length)
                               .ToHandleChecked();
             }
             js_function = WasmExportedFunction::New(
-                isolate_, instance, func_name, export_code,
-                static_cast<int>(function.sig->parameter_count()),
-                function.func_index);
+                isolate_, instance, func_name, function.func_index,
+                static_cast<int>(function.sig->parameter_count()), export_code);
             js_wrappers_[exp.index] = js_function;
           }
           desc.set_value(js_function);
           export_index++;
           break;
         }
         case kExternalTable: {
           // Export a table as a WebAssembly.Table object.
           TableInstance& table_instance = table_instances_[exp.index];
           WasmIndirectFunctionTable& table =
@@ skipping 129 matching lines @@
               // not exported but are in an exported table. This should be done
               // at module compile time and cached instead.
               WasmInstance temp_instance(module_);
               temp_instance.context = isolate_->native_context();
               temp_instance.mem_size = 0;
               temp_instance.mem_start = nullptr;
               temp_instance.globals_start = nullptr;
 
               Handle<Code> wrapper_code = compiler::CompileJSToWasmWrapper(
                   isolate_, module_, wasm_code, func_index);
-              Handle<String> func_name = isolate_->factory()->empty_string();
+              MaybeHandle<String> func_name;
               if (module_->origin == kAsmJsOrigin) {
                 // For modules arising from asm.js, honor the names section.
                 func_name = ExtractStringFromModuleBytes(
                                 isolate_, compiled_module_,
                                 function->name_offset, function->name_length)
                                 .ToHandleChecked();
               }
               Handle<WasmExportedFunction> js_function =
                   WasmExportedFunction::New(
-                      isolate_, instance, func_name, wrapper_code,
+                      isolate_, instance, func_name, func_index,
                       static_cast<int>(function->sig->parameter_count()),
-                      func_index);
+                      wrapper_code);
               js_wrappers_[func_index] = js_function;
             }
             table_instance.js_wrappers->set(table_index,
                                             *js_wrappers_[func_index]);
 
             UpdateDispatchTablesInternal(isolate_, all_dispatch_tables,
                                          table_index, function, wasm_code);
           }
         }
       }
@@ skipping 425 matching lines @@
 MaybeHandle<String> WasmCompiledModule::GetFunctionName(
     Handle<WasmCompiledModule> compiled_module, uint32_t func_index) {
   DCHECK_LT(func_index, compiled_module->module()->functions.size());
   WasmFunction& function = compiled_module->module()->functions[func_index];
   Isolate* isolate = compiled_module->GetIsolate();
   MaybeHandle<String> string = ExtractStringFromModuleBytes(
       isolate, compiled_module, function.name_offset, function.name_length);
   if (!string.is_null()) return string.ToHandleChecked();
   return {};
 }