[wasm] Refactor function name table and lookup

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 "src/base/atomic-utils.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/v8.h"
 
@@ skipping 816 matching lines @@
       if (mem_export) {
         // Export the memory as a named property.
         Handle<String> name = factory->InternalizeUtf8String("memory");
         JSObject::AddProperty(exports_object, name, instance.mem_buffer,
                               READ_ONLY);
       }
     }
   }
 
   //-------------------------------------------------------------------------
-  // Attach an array with function names and an array with offsets into that
-  // first array.
+  // Attach the function name table.
   //-------------------------------------------------------------------------
-  {
-    Handle<Object> arr = BuildFunctionNamesTable(isolate, module_env.module);
-    instance.js_object->SetInternalField(kWasmFunctionNamesArray, *arr);
-  }
+  Handle<ByteArray> function_name_table =
+      BuildFunctionNamesTable(isolate, module_env.module);
+  instance.js_object->SetInternalField(kWasmFunctionNamesArray,
+                                       *function_name_table);
 
   code_stats.Report();
 
   // Run the start function if one was specified.
   if (this->start_function_index >= 0) {
     HandleScope scope(isolate);
     uint32_t index = static_cast<uint32_t>(this->start_function_index);
     Handle<String> name = isolate->factory()->NewStringFromStaticChars("start");
     Handle<Code> code = instance.function_code[index];
     Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
@@ skipping 122 matching lines @@
   if (result->IsSmi()) {
     return Smi::cast(*result)->value();
   }
   if (result->IsHeapNumber()) {
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 
-MaybeHandle<String> GetWasmFunctionName(Handle<JSObject> wasm,
-                                        uint32_t func_index) {
-  DCHECK(IsWasmObject(wasm));
-  Object* func_names_arr_obj = wasm->GetInternalField(kWasmFunctionNamesArray);
-  Isolate* isolate = wasm->GetIsolate();
-  if (func_names_arr_obj->IsUndefined(isolate)) return Handle<String>::null();
-  return GetWasmFunctionNameFromTable(
-      handle(ByteArray::cast(func_names_arr_obj), isolate), func_index);
+Handle<Object> GetWasmFunctionNameOrNull(Isolate* isolate, Handle<Object> wasm,
+                                         uint32_t func_index) {
+  if (!wasm->IsUndefined()) {
+    Handle<ByteArray> func_names_arr_obj(
+        ByteArray::cast(Handle<JSObject>::cast(wasm)->GetInternalField(
+            kWasmFunctionNamesArray)),
+        isolate);
+    // TODO(clemens): Extract this from the module bytes; skip whole function
+    // name table.
+    Handle<Object> name;
+    if (GetWasmFunctionNameFromTable(func_names_arr_obj, func_index)
+            .ToHandle(&name)) {
+      return name;
+    }
+  }
+  return isolate->factory()->null_value();
+}
+
+Handle<String> GetWasmFunctionName(Isolate* isolate, Handle<Object> wasm,
+                                   uint32_t func_index) {
+  Handle<Object> name_or_null =
+      GetWasmFunctionNameOrNull(isolate, wasm, func_index);
+  if (!name_or_null->IsNull()) return Handle<String>::cast(name_or_null);
+  return isolate->factory()->NewStringFromStaticChars("<WASM UNNAMED>");
 }
 
 bool IsWasmObject(Handle<JSObject> object) {
   // TODO(clemensh): Check wasm byte header once we store a copy of the bytes.
   return object->GetInternalFieldCount() == kWasmModuleInternalFieldCount &&
          object->GetInternalField(kWasmModuleCodeTable)->IsFixedArray() &&
          object->GetInternalField(kWasmMemArrayBuffer)->IsJSArrayBuffer() &&
-         (object->GetInternalField(kWasmFunctionNamesArray)->IsByteArray() ||
-          object->GetInternalField(kWasmFunctionNamesArray)
-              ->IsUndefined(object->GetIsolate()));
+         object->GetInternalField(kWasmFunctionNamesArray)->IsByteArray();
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8