Add CompileInfo::GetDebugName()

src/compiler.h

 // 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.
 
 #ifndef V8_COMPILER_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/compilation-dependencies.h"
+#include "src/interpreter/bytecodes.h"
 #include "src/signature.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 class AstValueFactory;
 class HydrogenCodeStub;
 class JavaScriptFrame;
 class ParseInfo;
@@ skipping 106 matching lines @@
     kDisableFutureOptimization = 1 << 12,
     kSplittingEnabled = 1 << 13,
     kTypeFeedbackEnabled = 1 << 14,
     kDeoptimizationEnabled = 1 << 15,
     kSourcePositionsEnabled = 1 << 16,
     kFirstCompile = 1 << 17,
   };
 
   explicit CompilationInfo(ParseInfo* parse_info);
   CompilationInfo(CodeStub* stub, Isolate* isolate, Zone* zone);
+  CompilationInfo(interpreter::Bytecode bytecode, Isolate* isolate, Zone* zone);
   virtual ~CompilationInfo();
 
   ParseInfo* parse_info() const { return parse_info_; }
 
   // -----------------------------------------------------------
   // TODO(titzer): inline and delete accessors of ParseInfo
   // -----------------------------------------------------------
   Handle<Script> script() const;
   bool is_eval() const;
   bool is_native() const;
@@ skipping 11 matching lines @@
   bool has_scope() const;
   // -----------------------------------------------------------
 
   Isolate* isolate() const {
     return isolate_;
   }
   Zone* zone() { return zone_; }
   bool is_osr() const { return !osr_ast_id_.IsNone(); }
   Handle<Code> code() const { return code_; }
   CodeStub* code_stub() const { return code_stub_; }
+  interpreter::Bytecode bytecode() const { return bytecode_; }
   BailoutId osr_ast_id() const { return osr_ast_id_; }
   Handle<Code> unoptimized_code() const { return unoptimized_code_; }
   int opt_count() const { return opt_count_; }
   int num_parameters() const;
   int num_parameters_including_this() const;
   bool is_this_defined() const;
   int num_heap_slots() const;
   Code::Flags flags() const;
 
   void set_parameter_count(int parameter_count) {
@@ skipping 109 matching lines @@
   }
 
   GlobalObject* global_object() const {
     return has_global_object() ? closure()->context()->global_object() : NULL;
   }
 
   // Accessors for the different compilation modes.
   bool IsOptimizing() const { return mode_ == OPTIMIZE; }
   bool IsOptimizable() const { return mode_ == BASE; }
   bool IsStub() const { return mode_ == STUB; }
+  bool IsBytecodeHandler() const { return mode_ == BYTECODE_HANDLER; }
   void SetOptimizing(BailoutId osr_ast_id, Handle<Code> unoptimized) {
     DCHECK(!shared_info().is_null());
     SetMode(OPTIMIZE);
     osr_ast_id_ = osr_ast_id;
     unoptimized_code_ = unoptimized;
     optimization_id_ = isolate()->NextOptimizationId();
   }
 
   void SetFunctionType(Type::FunctionType* function_type) {
     function_type_ = function_type;
   }
   Type::FunctionType* function_type() const { return function_type_; }
 
   void SetStub(CodeStub* code_stub) {
     SetMode(STUB);
     code_stub_ = code_stub;
   }
 
   // Deoptimization support.
   bool HasDeoptimizationSupport() const {
     return GetFlag(kDeoptimizationSupport);
   }
   void EnableDeoptimizationSupport() {
     DCHECK(IsOptimizable());
     SetFlag(kDeoptimizationSupport);
   }
+  bool ShouldEnsureSpaceForLazyDeopt() {
+    return !IsStub() && !IsBytecodeHandler();
+  }
 
   // Determines whether or not to insert a self-optimization header.
   bool ShouldSelfOptimize();
 
   void set_deferred_handles(DeferredHandles* deferred_handles) {
     DCHECK(deferred_handles_ == NULL);
     deferred_handles_ = deferred_handles;
   }
 
   void ReopenHandlesInNewHandleScope() {
@@ skipping 89 matching lines @@
     }
   }
 
  private:
   // Compilation mode.
   // BASE is generated by the full codegen, optionally prepared for bailouts.
   // OPTIMIZE is optimized code generated by the Hydrogen-based backend.
   enum Mode {
     BASE,
     OPTIMIZE,
-    STUB
+    STUB,
+    BYTECODE_HANDLER

[titzer, 2015/08/21 13:37:21]

Do we really need a new mode? What does it control?

[rmcilroy, 2015/08/21 16:41:05]

Removed this mode and replaced it's need with debug_name.

   };
 
-  CompilationInfo(ParseInfo* parse_info, CodeStub* code_stub, Mode mode,
-                  Isolate* isolate, Zone* zone);
+  CompilationInfo(ParseInfo* parse_info, CodeStub* code_stub,
+                  interpreter::Bytecode bytecode, Mode mode, Isolate* isolate,
+                  Zone* zone);
 
   Isolate* isolate_;
 
   void SetMode(Mode mode) {
     mode_ = mode;
   }
 
   void SetFlag(Flag flag) { flags_ |= flag; }
 
   void SetFlag(Flag flag, bool value) {
     flags_ = value ? flags_ | flag : flags_ & ~flag;
   }
 
   bool GetFlag(Flag flag) const { return (flags_ & flag) != 0; }
 
   unsigned flags_;
 
   // For compiled stubs, the stub object
   CodeStub* code_stub_;
+  // For compiled bytecode handlers, the bytecode
+  interpreter::Bytecode bytecode_;

[titzer, 2015/08/21 13:37:21]

AFAICT this is only used for debugging purposes in printing to the log file. Can
we find another way to handle that without adding more stuff to the (already
bloated) compilation info?

[rmcilroy, 2015/08/21 16:41:05]

Done with GetDebugName as discussed.

   // The compiled code.
   Handle<Code> code_;
 
   // Used by codegen, ultimately kept rooted by the SharedFunctionInfo.
   Handle<TypeFeedbackVector> feedback_vector_;
 
   // Compilation mode flag and whether deoptimization is allowed.
   Mode mode_;
   BailoutId osr_ast_id_;
   // The unoptimized code we patched for OSR may not be the shared code
@@ skipping 234 matching lines @@
   Zone zone_;
   size_t info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_