Pass debug name as Vector instead of const char*

test/cctest/wasm/wasm-run-utils.h

 // Copyright 2016 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.
 
 #ifndef WASM_RUN_UTILS_H
 #define WASM_RUN_UTILS_H
 
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 364 matching lines @@
 
         rep_builder.AddReturn(MachineRepresentation::kWord32);
         for (int i = 0; i < WASM_RUNNER_MAX_NUM_PARAMETERS + 1; i++) {
           rep_builder.AddParam(MachineRepresentation::kWord32);
         }
         Int64Lowering r(graph(), machine(), common(), zone(),
                         rep_builder.Build());
         r.LowerGraph();
       }
 
-      CompilationInfo info("testing", isolate, graph()->zone());
+      CompilationInfo info(ArrayVector("testing"), isolate, graph()->zone());
       code_ =
           Pipeline::GenerateCodeForTesting(&info, descriptor, graph(), nullptr);
       CHECK(!code_.is_null());
 #ifdef ENABLE_DISASSEMBLER
       if (FLAG_print_opt_code) {
         OFStream os(stdout);
         code_->Disassemble("wasm wrapper", os);
       }
 #endif
     }
 
     return code_;
   }
 
   Signature<MachineType>* signature() const { return signature_; }
 
  private:
   Node* inner_code_node_;
   Handle<Code> code_;
   Signature<MachineType>* signature_;
 };
 
 // A helper for compiling WASM functions for testing. This class can create a
 // standalone function if {module} is NULL or a function within a
 // {TestingModule}. It contains the internal state for compilation (i.e.
 // TurboFan graph) and, later, interpretation.
 class WasmFunctionCompiler : public HandleAndZoneScope,
                              private GraphAndBuilders {
  public:
-  explicit WasmFunctionCompiler(FunctionSig* sig, TestingModule* module,
-                                const char* debug_name = "<WASM UNNAMED>")
+  explicit WasmFunctionCompiler(
+      FunctionSig* sig, TestingModule* module,
+      Vector<const char> debug_name = ArrayVector("<WASM UNNAMED>"))
       : GraphAndBuilders(main_zone()),
         jsgraph(this->isolate(), this->graph(), this->common(), nullptr,
                 nullptr, this->machine()),
         sig(sig),
         descriptor_(nullptr),
         testing_module_(module),
         debug_name_(debug_name),
         source_position_table_(this->graph()) {
     if (module) {
       // Get a new function from the testing module.
       function_ = nullptr;
       function_index_ = module->AddFunction(sig, Handle<Code>::null());
     } else {
       // Create our own function.
       function_ = new WasmFunction();
       function_->sig = sig;
       function_index_ = 0;
     }
   }
 
   ~WasmFunctionCompiler() {
     if (function_) delete function_;
   }
 
   JSGraph jsgraph;
   FunctionSig* sig;
   // The call descriptor is initialized when the function is compiled.
   CallDescriptor* descriptor_;
   TestingModule* testing_module_;
-  const char* debug_name_;
+  Vector<const char> debug_name_;
   WasmFunction* function_;
   int function_index_;
   LocalDeclEncoder local_decls;
   SourcePositionTable source_position_table_;
 
   Isolate* isolate() { return main_isolate(); }
   Graph* graph() const { return main_graph_; }
   Zone* zone() const { return graph()->zone(); }
   CommonOperatorBuilder* common() { return &main_common_; }
   MachineOperatorBuilder* machine() { return &main_machine_; }
@@ skipping 189 matching lines @@
     if (p1 == MachineType::None()) return 1;
     if (p2 == MachineType::None()) return 2;
     if (p3 == MachineType::None()) return 3;
     return 4;
   }
 };
 
 }  // namespace
 
 #endif