[wasm] Store function names in the wasm object

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/macro-assembler.h"
 #include "src/objects.h"
 #include "src/v8.h"
 
 #include "src/simulator.h"
 
@@ skipping 182 matching lines @@
     }
     if (modified) {
       Assembler::FlushICache(isolate_, code->instruction_start(),
                              code->instruction_size());
     }
   }
 };
 
 namespace {
 // Internal constants for the layout of the module object.
-const int kWasmModuleInternalFieldCount = 4;
+const int kWasmModuleInternalFieldCount = 5;
 const int kWasmModuleFunctionTable = 0;
 const int kWasmModuleCodeTable = 1;
 const int kWasmMemArrayBuffer = 2;
 const int kWasmGlobalsArrayBuffer = 3;
+const int kWasmFunctionNamesArray = 4;
 
 size_t AllocateGlobalsOffsets(std::vector<WasmGlobal>& globals) {
   uint32_t offset = 0;
   if (globals.size() == 0) return 0;
   for (WasmGlobal& global : globals) {
     byte size = WasmOpcodes::MemSize(global.type);
     offset = (offset + size - 1) & ~(size - 1);  // align
     global.offset = offset;
     offset += size;
   }
@@ skipping 21 matching lines @@
   }
   int table_size = static_cast<int>(module->function_table.size());
   Handle<FixedArray> fixed = isolate->factory()->NewFixedArray(2 * table_size);
   for (int i = 0; i < table_size; i++) {
     WasmFunction* function = &module->functions[module->function_table[i]];
     fixed->set(i, Smi::FromInt(function->sig_index));
   }
   return fixed;
 }
 
+// Build an array with all function names. If there are N functions in the
+// module, then the first (kIntSize * (N+1)) bytes are integer entries.
+// The first integer entry encodes the number of functions in the module.
+// The entries 1 to N contain offsets into the seconds part of this array.

[titzer, 2016/04/22 13:21:08]

s/seconds/second/

+// After these N+1 integer entries, the second part begins, which holds a
+// concatenation of all function names. If a function is unnamed (not to be
+// confused with an empty name), then the corresponding integer entry contains
+// the negative distance to the next entry with a name. It points behind the
+// last integer entry if there are no more entries with names.
+// This allows to easily determine for each function the start of the next
+// function name, and hence the length of the function name.
+Handle<Object> BuildFunctionNamesArray(Isolate* isolate, WasmModule* module) {

[titzer, 2016/04/22 13:21:08]

Can we factor out the encoding and decoding logic for wasm names into a separate
file with its own unittests?

[Clemens Hammacher, 2016/04/22 14:38:40]

OK, will work on that on Monday and then update this CL.

+  uint64_t func_names_length = 0;
+  for (auto& func : module->functions) func_names_length += func.name_length;
+  int num_funcs_int = static_cast<int>(module->functions.size());
+  int current_offset = (num_funcs_int + 1) * kIntSize;
+  uint64_t total_array_length = current_offset + func_names_length;
+  int total_array_length_int = static_cast<int>(total_array_length);
+  // Check for overflow. Just skip function names if it happens.
+  if (total_array_length_int != total_array_length || num_funcs_int < 0 ||
+      num_funcs_int != module->functions.size())
+    return isolate->factory()->undefined_value();
+  Handle<ByteArray> func_names_arr =
+      isolate->factory()->NewByteArray(total_array_length_int, TENURED);
+  func_names_arr->set_int(0, num_funcs_int);
+  for (int func_index = 0; func_index != num_funcs_int; ++func_index) {

[titzer, 2016/04/22 13:21:08]

Would prefer a C++ foreach-loop with a separate index variable, if possible.

[Clemens Hammacher, 2016/04/22 14:38:40]

C++ foreach does not work, since we increase func_index further in the function
body. This allows us to only iterate the functions once.

+    WasmName name = module->GetNameOrNull(&module->functions[func_index]);
+    if (name.name == nullptr) {
+      // Find next function with a name, and store the negative distance to that
+      // function. On the way, we also set all the entries inbetween.
+      int next_func_with_name = func_index + 1;
+      while (
+          next_func_with_name != num_funcs_int &&
+          module->GetNameOrNull(&module->functions[next_func_with_name]).name ==
+              nullptr)
+        ++next_func_with_name;
+      for (; func_index < next_func_with_name; ++func_index)
+        func_names_arr->set_int(func_index + 1,
+                                func_index - next_func_with_name);
+      --func_index;
+    } else {
+      func_names_arr->set(current_offset,
+                          reinterpret_cast<const byte*>(name.name),
+                          name.length);
+      func_names_arr->set_int(func_index + 1, current_offset);
+      current_offset += name.length;
+    }
+  }
+  return func_names_arr;
+}
+
 Handle<JSArrayBuffer> NewArrayBuffer(Isolate* isolate, size_t size,
                                      byte** backing_store) {
   if (size > (WasmModule::kMaxMemPages * WasmModule::kPageSize)) {
     // TODO(titzer): lift restriction on maximum memory allocated here.
     *backing_store = nullptr;
     return Handle<JSArrayBuffer>::null();
   }
   void* memory =
       isolate->array_buffer_allocator()->Allocate(static_cast<int>(size));
   if (!memory) {
@@ skipping 149 matching lines @@
   HistogramTimerScope wasm_instantiate_module_time_scope(
       isolate->counters()->wasm_instantiate_module_time());
   this->shared_isolate = isolate;  // TODO(titzer): have a real shared isolate.
   ErrorThrower thrower(isolate, "WasmModule::Instantiate()");
   Factory* factory = isolate->factory();
 
   //-------------------------------------------------------------------------
   // Allocate the instance and its JS counterpart.
   //-------------------------------------------------------------------------
   Handle<Map> map = factory->NewMap(
-      JS_OBJECT_TYPE,
+      JS_WASM_TYPE,
       JSObject::kHeaderSize + kWasmModuleInternalFieldCount * kPointerSize);
   WasmModuleInstance instance(this);
   instance.context = isolate->native_context();
   instance.js_object = factory->NewJSObjectFromMap(map, TENURED);
   Handle<FixedArray> code_table =
       factory->NewFixedArray(static_cast<int>(functions.size()), TENURED);
   instance.js_object->SetInternalField(kWasmModuleCodeTable, *code_table);
 
   //-------------------------------------------------------------------------
   // Allocate and initialize the linear memory.
@@ skipping 146 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.
+  //-------------------------------------------------------------------------
+  {
+    Handle<Object> arr = BuildFunctionNamesArray(isolate, module_env.module);
+    instance.js_object->SetInternalField(kWasmFunctionNamesArray, *arr);
+  }
+
   // 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 = linker.GetFunctionCode(index);
     Handle<JSFunction> jsfunc = compiler::CompileJSToWasmWrapper(
         isolate, &module_env, name, code, instance.js_object, index);
 
     // Call the JS function.
@@ skipping 130 matching lines @@
   Handle<Object> result = retval.ToHandleChecked();
   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;
 }
+
+Handle<Object> GetWasmFunctionName(Handle<JSObject> wasm, uint32_t func_index) {
+  DCHECK(wasm->map()->instance_type() == JS_WASM_TYPE);
+  Handle<Object> func_names_arr_obj = handle(
+      wasm->GetInternalField(kWasmFunctionNamesArray), wasm->GetIsolate());
+  if (func_names_arr_obj->IsUndefined())
+    return func_names_arr_obj;  // Return undefined.
+  Handle<ByteArray> func_names_arr =
+      Handle<ByteArray>::cast(func_names_arr_obj);
+  uint32_t num_funcs = static_cast<uint32_t>(func_names_arr->get_int(0));
+  DCHECK(static_cast<int>(num_funcs) >= 0);
+  if (func_index >= num_funcs)
+    return wasm->GetIsolate()->factory()->undefined_value();
+  int offset = func_names_arr->get_int(func_index + 1);
+  if (offset < 0) return wasm->GetIsolate()->factory()->undefined_value();
+  int next_offset = func_index == num_funcs - 1
+                        ? func_names_arr->length()
+                        : func_names_arr->get_int(func_index + 2);
+  if (next_offset < 0) {
+    uint32_t next_func_index = func_index + 1 - next_offset;
+    next_offset = next_func_index == num_funcs
+                      ? func_names_arr->length()
+                      : func_names_arr->get_int(next_func_index + 1);
+  }
+  DCHECK(next_offset >= 0 && next_offset <= func_names_arr->length());
+  DCHECK(next_offset >= offset);
+  ScopedVector<byte> buffer(next_offset - offset);
+  func_names_arr->get(offset, buffer.start(), next_offset - offset);
+  MaybeHandle<Object> maybe_name =
+      wasm->GetIsolate()->factory()->NewStringFromUtf8(
+          Vector<const char>::cast(buffer));
+  if (maybe_name.is_null())
+    return wasm->GetIsolate()->factory()->undefined_value();
+  return maybe_name.ToHandleChecked();
+}
+
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8