[wasm] Replace WasmName by Vector<const char>

src/compiler/wasm-compiler.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/compiler/wasm-compiler.h"
 
 #include "src/isolate-inl.h"
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/base/platform/platform.h"
@@ skipping 2665 matching lines @@
 
 void WasmGraphBuilder::SetSourcePosition(Node* node, int position) {
   compiler::SourcePosition pos(position);
   if (source_position_table_)
     source_position_table_->SetSourcePosition(node, pos);
 }
 
 static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
                                       CompilationInfo* info,
                                       const char* message, uint32_t index,
-                                      wasm::WasmName func_name) {
+                                      Vector<const char> func_name) {
   Isolate* isolate = info->isolate();
   if (isolate->logger()->is_logging_code_events() ||
       isolate->cpu_profiler()->is_profiling()) {
     ScopedVector<char> buffer(128);
-    SNPrintF(buffer, "%s#%d:%.*s", message, index, func_name.length,
-             func_name.name);
+    SNPrintF(buffer, "%s#%d:%.*s", message, index, func_name.length(),
+             func_name.start());
     Handle<String> name_str =
         isolate->factory()->NewStringFromAsciiChecked(buffer.start());
     Handle<String> script_str =
         isolate->factory()->NewStringFromAsciiChecked("(WASM)");
     Handle<Code> code = info->code();
     Handle<SharedFunctionInfo> shared =
         isolate->factory()->NewSharedFunctionInfo(name_str, code, false);
     PROFILE(isolate, CodeCreateEvent(tag, AbstractCode::cast(*code), *shared,
                                      info, *script_str, 0, 0));
   }
@@ skipping 85 matching lines @@
         module->module->GetName(func->name_offset, func->name_length));
     // Set the JSFunction's machine code.
     function->set_code(*code);
   }
   return function;
 }
 
 Handle<Code> CompileWasmToJSWrapper(Isolate* isolate, wasm::ModuleEnv* module,
                                     Handle<JSFunction> function,
                                     wasm::FunctionSig* sig,
-                                    wasm::WasmName module_name,
-                                    wasm::WasmName function_name) {
+                                    Vector<const char> module_name,
+                                    Vector<const char> function_name) {
   //----------------------------------------------------------------------------
   // Create the Graph
   //----------------------------------------------------------------------------
   Zone zone(isolate->allocator());
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
   MachineOperatorBuilder machine(&zone);
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
 
   Node* control = nullptr;
@@ skipping 97 matching lines @@
     r.LowerGraph();
   }
 
   if (result.failed()) {
     if (FLAG_trace_wasm_compiler) {
       OFStream os(stdout);
       os << "Compilation failed: " << result << std::endl;
     }
     // Add the function as another context for the exception
     ScopedVector<char> buffer(128);
-    wasm::WasmName name =
+    Vector<const char> name =
         module_env->module->GetName(function.name_offset, function.name_length);
     SNPrintF(buffer, "Compiling WASM function #%d:%.*s failed:",
-             function.func_index, name.length, name.name);
+             function.func_index, name.length(), name.start());
     thrower.Failed(buffer.start(), result);
     return Handle<Code>::null();
   }
 
   int index = static_cast<int>(function.func_index);
   if (index >= FLAG_trace_wasm_ast_start && index < FLAG_trace_wasm_ast_end) {
     PrintAst(isolate->allocator(), body);
   }
 
   if (FLAG_trace_wasm_decode_time) {
@@ skipping 12 matching lines @@
   }
 
   Code::Flags flags = Code::ComputeFlags(Code::WASM_FUNCTION);
   // add flags here if a meaningful name is helpful for debugging.
   bool debugging =
 #if DEBUG
       true;
 #else
       FLAG_print_opt_code || FLAG_trace_turbo || FLAG_trace_turbo_graph;
 #endif
-  Vector<const char> func_name =
-      module_env->module
-          ->GetNameOrNull(function.name_offset, function.name_length)
-          .toVec();
+  Vector<const char> func_name = module_env->module->GetNameOrNull(
+      function.name_offset, function.name_length);
   Vector<char> buffer;
   if (func_name.is_empty()) {
     if (debugging) {
       buffer = Vector<char>::New(128);
       int chars = SNPrintF(buffer, "WASM_function_#%d", function.func_index);
       func_name = Vector<const char>::cast(buffer.SubVector(0, chars));
     } else {
       func_name = ArrayVector("wasm");
     }
   }
@@ skipping 22 matching lines @@
   // TODO(bradnelson): Improve histogram handling of size_t.
   isolate->counters()->wasm_compile_function_peak_memory_bytes()->AddSample(
       static_cast<int>(zone.allocation_size()));
   return code;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8