[wasm] Replace WasmName by Vector<const char>

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 83 matching lines @@
 
   os << " code bytes: "
      << (function.code_end_offset - function.code_start_offset);
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const WasmFunctionName& pair) {
   os << "#" << pair.function_->func_index << ":";
   if (pair.function_->name_offset > 0) {
     if (pair.module_) {
-      WasmName name = pair.module_->GetName(pair.function_->name_offset,
-                                            pair.function_->name_length);
-      os.write(name.name, name.length);
+      Vector<const char> name = pair.module_->GetName(
+          pair.function_->name_offset, pair.function_->name_length);
+      os.write(name.start(), name.length());
     } else {
       os << "+" << pair.function_->func_index;
     }
   } else {
     os << "?";
   }
   return os;
 }
 
 // A helper class for compiling multiple wasm functions that offers
@@ skipping 209 matching lines @@
     : shared_isolate(nullptr),
       module_start(nullptr),
       module_end(nullptr),
       min_mem_pages(0),
       max_mem_pages(0),
       mem_export(false),
       mem_external(false),
       start_function_index(-1),
       origin(kWasmOrigin) {}
 
-static MaybeHandle<JSFunction> ReportFFIError(ErrorThrower& thrower,
-                                              const char* error, uint32_t index,
-                                              wasm::WasmName module_name,
-                                              wasm::WasmName function_name) {
-  if (function_name.name) {
+static MaybeHandle<JSFunction> ReportFFIError(
+    ErrorThrower& thrower, const char* error, uint32_t index,
+    Vector<const char> module_name, Vector<const char> function_name) {
+  if (function_name.start()) {
     thrower.Error("Import #%d module=\"%.*s\" function=\"%.*s\" error: %s",
-                  index, module_name.length, module_name.name,
-                  function_name.length, function_name.name, error);
+                  index, module_name.length(), module_name.start(),
+                  function_name.length(), function_name.start(), error);
   } else {
     thrower.Error("Import #%d module=\"%.*s\" error: %s", index,
-                  module_name.length, module_name.name, error);
+                  module_name.length(), module_name.start(), error);
   }
   thrower.Error("Import ");
   return MaybeHandle<JSFunction>();
 }
 
 static MaybeHandle<JSFunction> LookupFunction(
     ErrorThrower& thrower, Factory* factory, Handle<JSObject> ffi,
-    uint32_t index, wasm::WasmName module_name, wasm::WasmName function_name) {
+    uint32_t index, Vector<const char> module_name,
+    Vector<const char> function_name) {
   if (ffi.is_null()) {
     return ReportFFIError(thrower, "FFI is not an object", index, module_name,
                           function_name);
   }
 
   // Look up the module first.
-  Handle<String> name = factory->InternalizeUtf8String(
-      Vector<const char>(module_name.name, module_name.length));
+  Handle<String> name = factory->InternalizeUtf8String(module_name);
   MaybeHandle<Object> result = Object::GetProperty(ffi, name);
   if (result.is_null()) {
     return ReportFFIError(thrower, "module not found", index, module_name,
                           function_name);
   }
 
   Handle<Object> module = result.ToHandleChecked();
 
   if (!module->IsJSReceiver()) {
     return ReportFFIError(thrower, "module is not an object or function", index,
                           module_name, function_name);
   }
 
   Handle<Object> function;
-  if (function_name.name) {
+  if (function_name.start()) {
     // Look up the function in the module.
-    Handle<String> name = factory->InternalizeUtf8String(
-        Vector<const char>(function_name.name, function_name.length));
+    Handle<String> name = factory->InternalizeUtf8String(function_name);
     MaybeHandle<Object> result = Object::GetProperty(module, name);
     if (result.is_null()) {
       return ReportFFIError(thrower, "function not found", index, module_name,
                             function_name);
     }
     function = result.ToHandleChecked();
   } else {
     // No function specified. Use the "default export".
     function = module;
   }
@@ skipping 73 matching lines @@
   WasmLinker linker(isolate, functions.size());
   ModuleEnv module_env;
   module_env.module = this;
   module_env.instance = &instance;
   module_env.linker = &linker;
   module_env.origin = origin;
 
   if (import_table.size() > 0) {
     instance.import_code.reserve(import_table.size());
     for (const WasmImport& import : import_table) {
-      WasmName module_name =
+      Vector<const char> module_name =
           GetNameOrNull(import.module_name_offset, import.module_name_length);
-      WasmName function_name = GetNameOrNull(import.function_name_offset,
-                                             import.function_name_length);
+      Vector<const char> function_name = GetNameOrNull(
+          import.function_name_offset, import.function_name_length);
       MaybeHandle<JSFunction> function = LookupFunction(
           thrower, factory, ffi, index, module_name, function_name);
       if (function.is_null()) return MaybeHandle<JSObject>();
       Handle<Code> code = compiler::CompileWasmToJSWrapper(
           isolate, &module_env, function.ToHandleChecked(), import.sig,
           module_name, function_name);
       instance.import_code.push_back(code);
       index++;
     }
   }
 
   //-------------------------------------------------------------------------
   // Compile all functions in the module.
   //-------------------------------------------------------------------------
   {
     isolate->counters()->wasm_functions_per_module()->AddSample(
         static_cast<int>(functions.size()));
 
     // First pass: compile each function and initialize the code table.
     index = FLAG_skip_compiling_wasm_funcs;
     while (index < functions.size()) {
       const WasmFunction& func = functions[index];
       if (thrower.error()) break;
       DCHECK_EQ(index, func.func_index);
 
-      WasmName str = GetName(func.name_offset, func.name_length);
-      WasmName str_null = {nullptr, 0};
-      Handle<String> name = factory->InternalizeUtf8String(
-          Vector<const char>(str.name, str.length));
+      Vector<const char> str = GetName(func.name_offset, func.name_length);
+      Vector<const char> str_null = {nullptr, 0};
+      Handle<String> name = factory->InternalizeUtf8String(str);
       Handle<Code> code = Handle<Code>::null();
       Handle<JSFunction> function = Handle<JSFunction>::null();
       if (func.external) {
         // Lookup external function in FFI object.
         MaybeHandle<JSFunction> function =
             LookupFunction(thrower, factory, ffi, index, str, str_null);
         if (function.is_null()) return MaybeHandle<JSObject>();
         code = compiler::CompileWasmToJSWrapper(isolate, &module_env,
                                                 function.ToHandleChecked(),
                                                 func.sig, str, str_null);
       } else {
         // Compile the function.
         code =
             compiler::CompileWasmFunction(thrower, isolate, &module_env, func);
         if (code.is_null()) {
-          thrower.Error("Compilation of #%d:%.*s failed.", index, str.length,
-                        str.name);
+          thrower.Error("Compilation of #%d:%.*s failed.", index, str.length(),
+                        str.start());
           return MaybeHandle<JSObject>();
         }
         if (func.exported) {
           function = compiler::CompileJSToWasmWrapper(
               isolate, &module_env, name, code, instance.js_object, index);
         }
       }
       if (!code.is_null()) {
         // Install the code into the linker table.
         linker.Finish(index, code);
@@ skipping 22 matching lines @@
           isolate->native_context()->object_function(), isolate);
       Handle<JSObject> exports_object =
           factory->NewJSObject(object_function, TENURED);
       Handle<String> exports_name = factory->InternalizeUtf8String("exports");
       JSObject::AddProperty(instance.js_object, exports_name, exports_object,
                             READ_ONLY);
 
       // Compile wrappers and add them to the exports object.
       for (const WasmExport& exp : export_table) {
         if (thrower.error()) break;
-        WasmName str = GetName(exp.name_offset, exp.name_length);
-        Handle<String> name = factory->InternalizeUtf8String(
-            Vector<const char>(str.name, str.length));
+        Vector<const char> str = GetName(exp.name_offset, exp.name_length);
+        Handle<String> name = factory->InternalizeUtf8String(str);
         Handle<Code> code = linker.GetFunctionCode(exp.func_index);
         Handle<JSFunction> function = compiler::CompileJSToWasmWrapper(
             isolate, &module_env, name, code, instance.js_object,
             exp.func_index);
         JSObject::AddProperty(exports_object, name, function, READ_ONLY);
       }
 
       if (mem_export) {
         // Export the memory as a named property.
         Handle<String> name = factory->InternalizeUtf8String("memory");
@@ skipping 149 matching lines @@
   }
   if (result->IsHeapNumber()) {
     return static_cast<int32_t>(HeapNumber::cast(*result)->value());
   }
   thrower.Error("WASM.compileRun() failed: Return value should be number");
   return -1;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8