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(),
-                      parse_info->zone()) {
+    : CompilationInfo(parse_info, nullptr, interpreter::Bytecode::kLast, 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, interpreter::Bytecode::kLast, STUB,
+                      isolate, zone) {}
 
+CompilationInfo::CompilationInfo(interpreter::Bytecode bytecode,
+                                 Isolate* isolate, Zone* zone)
+    : CompilationInfo(nullptr, nullptr, bytecode, BYTECODE_HANDLER, isolate,
+                      zone) {}
 
 CompilationInfo::CompilationInfo(ParseInfo* parse_info, CodeStub* code_stub,
-                                 Mode mode, Isolate* isolate, Zone* zone)
+                                 interpreter::Bytecode bytecode, Mode mode,
+                                 Isolate* isolate, Zone* zone)
     : parse_info_(parse_info),
       isolate_(isolate),
       flags_(0),
       code_stub_(code_stub),
+      bytecode_(bytecode),
       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),
@@ skipping 39 matching lines @@
 
 bool CompilationInfo::is_this_defined() const { return !IsStub(); }
 
 
 int CompilationInfo::num_heap_slots() const {
   return has_scope() ? scope()->num_heap_slots() : 0;
 }
 
 
 Code::Flags CompilationInfo::flags() const {
-  return code_stub() != nullptr
-             ? Code::ComputeFlags(
-                   code_stub()->GetCodeKind(), code_stub()->GetICState(),
-                   code_stub()->GetExtraICState(), code_stub()->GetStubType())
-             : Code::ComputeFlags(Code::OPTIMIZED_FUNCTION);
+  if (IsBytecodeHandler()) {
+    return Code::ComputeFlags(Code::STUB);
+  } else if (code_stub() != nullptr) {
+    return Code::ComputeFlags(
+        code_stub()->GetCodeKind(), code_stub()->GetICState(),
+        code_stub()->GetExtraICState(), code_stub()->GetStubType());
+  } else {
+    return Code::ComputeFlags(Code::OPTIMIZED_FUNCTION);
+  }
 }
 
 
 // Primitive functions are unlikely to be picked up by the stack-walking
 // profiler, so they trigger their own optimization when they're called
 // for the SharedFunctionInfo::kCallsUntilPrimitiveOptimization-th time.
 bool CompilationInfo::ShouldSelfOptimize() {
   return FLAG_crankshaft &&
          !(literal()->flags() & AstProperties::kDontSelfOptimize) &&
          !literal()->dont_optimize() &&
@@ skipping 1493 matching lines @@
 
 
 #if DEBUG
 void CompilationInfo::PrintAstForTesting() {
   PrintF("--- Source from AST ---\n%s\n",
          PrettyPrinter(isolate(), zone()).PrintProgram(literal()));
 }
 #endif
 }  // namespace internal
 }  // namespace v8