Add CompileInfo::GetDebugName()

src/compiler.cc

 // Copyright 2012 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.h"
 
 #include <algorithm>
 
 #include "src/ast-numbering.h"
 #include "src/bootstrapper.h"
@@ skipping 101 matching lines @@
   return parse_info_ && parse_info_->literal() != nullptr;
 }
 
 
 bool CompilationInfo::has_scope() const {
   return parse_info_ && parse_info_->scope() != nullptr;
 }
 
 
 CompilationInfo::CompilationInfo(ParseInfo* parse_info)
-    : CompilationInfo(parse_info, nullptr, BASE, parse_info->isolate(),
+    : CompilationInfo(parse_info, nullptr, nullptr, BASE, parse_info->isolate(),
                       parse_info->zone()) {
   // Compiling for the snapshot typically results in different code than
   // compiling later on. This means that code recompiled with deoptimization
   // support won't be "equivalent" (as defined by SharedFunctionInfo::
   // EnableDeoptimizationSupport), so it will replace the old code and all
   // its type feedback. To avoid this, always compile functions in the snapshot
   // with deoptimization support.
   if (isolate_->serializer_enabled()) EnableDeoptimizationSupport();
 
   if (FLAG_context_specialization) MarkAsContextSpecializing();
   if (FLAG_turbo_inlining) MarkAsInliningEnabled();
   if (FLAG_turbo_source_positions) MarkAsSourcePositionsEnabled();
   if (FLAG_turbo_splitting) MarkAsSplittingEnabled();
   if (FLAG_turbo_types) MarkAsTypingEnabled();
 
   if (has_shared_info()) {
     if (shared_info()->is_compiled()) {
       // We should initialize the CompilationInfo feedback vector from the
       // passed in shared info, rather than creating a new one.
       feedback_vector_ = Handle<TypeFeedbackVector>(
           shared_info()->feedback_vector(), parse_info->isolate());
     }
     if (shared_info()->never_compiled()) MarkAsFirstCompile();
   }
 }
 
 
 CompilationInfo::CompilationInfo(CodeStub* stub, Isolate* isolate, Zone* zone)
-    : CompilationInfo(nullptr, stub, STUB, isolate, zone) {}
+    : CompilationInfo(nullptr, stub, CodeStub::MajorName(stub->MajorKey()),
+                      STUB, isolate, zone) {}
 
+CompilationInfo::CompilationInfo(const char* debug_name, Isolate* isolate,
+                                 Zone* zone)
+    : CompilationInfo(nullptr, nullptr, debug_name, STUB, isolate, zone) {}
 
 CompilationInfo::CompilationInfo(ParseInfo* parse_info, CodeStub* code_stub,
-                                 Mode mode, Isolate* isolate, Zone* zone)
+                                 const char* code_stub_debug_name, Mode mode,
+                                 Isolate* isolate, Zone* zone)
     : parse_info_(parse_info),
       isolate_(isolate),
       flags_(0),
       code_stub_(code_stub),
       mode_(mode),
       osr_ast_id_(BailoutId::None()),
       zone_(zone),
       deferred_handles_(nullptr),
       dependencies_(isolate, zone),
       bailout_reason_(kNoReason),
       prologue_offset_(Code::kPrologueOffsetNotSet),
       no_frame_ranges_(isolate->cpu_profiler()->is_profiling()
                            ? new List<OffsetRange>(2)
                            : nullptr),
       track_positions_(FLAG_hydrogen_track_positions ||
                        isolate->cpu_profiler()->is_profiling()),
       opt_count_(has_shared_info() ? shared_info()->opt_count() : 0),
       parameter_count_(0),
       optimization_id_(-1),
       osr_expr_stack_height_(0),
-      function_type_(nullptr) {
+      function_type_(nullptr),
+      code_stub_debug_name_(code_stub_debug_name) {
   // Parameter count is number of stack parameters.
   if (code_stub_ != NULL) {
     CodeStubDescriptor descriptor(code_stub_);
     parameter_count_ = descriptor.GetStackParameterCount();
     if (descriptor.function_mode() == NOT_JS_FUNCTION_STUB_MODE) {
       parameter_count_--;
     }
   }
 }
 
 
 CompilationInfo::~CompilationInfo() {
   DisableFutureOptimization();
   delete deferred_handles_;
   delete no_frame_ranges_;
 #ifdef DEBUG
   // Check that no dependent maps have been added or added dependent maps have
   // been rolled back or committed.
   DCHECK(dependencies()->IsEmpty());
 #endif  // DEBUG
 }
 
 
+void CompilationInfo::SetStub(CodeStub* code_stub) {
+  SetMode(STUB);
+  code_stub_ = code_stub;
+  code_stub_debug_name_ = CodeStub::MajorName(code_stub->MajorKey());
+}
+
+
 int CompilationInfo::num_parameters() const {
   return has_scope() ? scope()->num_parameters() : parameter_count_;
 }
 
 
 int CompilationInfo::num_parameters_including_this() const {
   return num_parameters() + (is_this_defined() ? 1 : 0);
 }
 
 
@@ skipping 93 matching lines @@
 
 
 Handle<Code> CompilationInfo::GenerateCodeStub() {
   // Run a "mini pipeline", extracted from compiler.cc.
   CHECK(Parser::ParseStatic(parse_info()));
   CHECK(Compiler::Analyze(parse_info()));
   return compiler::Pipeline(this).GenerateCode();
 }
 
 
+base::SmartArrayPointer<char> CompilationInfo::GetDebugName() const {
+  if (IsStub()) {
+    size_t len = strlen(code_stub_debug_name_) + 1;
+    base::SmartArrayPointer<char> name(new char[len]);
+    memcpy(name.get(), code_stub_debug_name_, len);
+    return name;
+  } else {
+    AllowHandleDereference allow_deref;
+    return literal()->debug_name()->ToCString();
+  }
+}
+
+
 class HOptimizedGraphBuilderWithPositions: public HOptimizedGraphBuilder {
  public:
   explicit HOptimizedGraphBuilderWithPositions(CompilationInfo* info)
       : HOptimizedGraphBuilder(info) {
   }
 
 #define DEF_VISIT(type)                                      \
   void Visit##type(type* node) override {                    \
     SourcePosition old_position = SourcePosition::Unknown(); \
     if (node->position() != RelocInfo::kNoPosition) {        \
@@ skipping 1395 matching lines @@
 
 
 #if DEBUG
 void CompilationInfo::PrintAstForTesting() {
   PrintF("--- Source from AST ---\n%s\n",
          PrettyPrinter(isolate(), zone()).PrintProgram(literal()));
 }
 #endif
 }  // namespace internal
 }  // namespace v8