Revert 13117: "Enable stub generation using Hydrogen/Lithium (again)"

src/compiler.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 20 matching lines @@
 #include "allocation.h"
 #include "ast.h"
 #include "zone.h"
 
 namespace v8 {
 namespace internal {
 
 static const int kPrologueOffsetNotSet = -1;
 
 class ScriptDataImpl;
-class HydrogenCodeStub;
 
 // CompilationInfo encapsulates some information known at compile time.  It
 // is constructed based on the resources available at compile-time.
 class CompilationInfo {
  public:
   CompilationInfo(Handle<Script> script, Zone* zone);
   CompilationInfo(Handle<SharedFunctionInfo> shared_info, Zone* zone);
   CompilationInfo(Handle<JSFunction> closure, Zone* zone);
-  CompilationInfo(HydrogenCodeStub* stub, Isolate* isolate, Zone* zone);
 
   virtual ~CompilationInfo();
 
   Isolate* isolate() {
     ASSERT(Isolate::Current() == isolate_);
     return isolate_;
   }
   Zone* zone() {
     return zone_;
   }
   bool is_lazy() const { return IsLazy::decode(flags_); }
   bool is_eval() const { return IsEval::decode(flags_); }
   bool is_global() const { return IsGlobal::decode(flags_); }
   bool is_classic_mode() const { return language_mode() == CLASSIC_MODE; }
   bool is_extended_mode() const { return language_mode() == EXTENDED_MODE; }
   LanguageMode language_mode() const {
     return LanguageModeField::decode(flags_);
   }
   bool is_in_loop() const { return IsInLoop::decode(flags_); }
   FunctionLiteral* function() const { return function_; }
   Scope* scope() const { return scope_; }
   Scope* global_scope() const { return global_scope_; }
   Handle<Code> code() const { return code_; }
   Handle<JSFunction> closure() const { return closure_; }
   Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
   Handle<Script> script() const { return script_; }
-  HydrogenCodeStub* code_stub() {return code_stub_; }
   v8::Extension* extension() const { return extension_; }
   ScriptDataImpl* pre_parse_data() const { return pre_parse_data_; }
   Handle<Context> context() const { return context_; }
   BailoutId osr_ast_id() const { return osr_ast_id_; }
-  int num_parameters() const;
-  int num_heap_slots() const;
-  Code::Flags flags() const;
 
   void MarkAsEval() {
     ASSERT(!is_lazy());
     flags_ |= IsEval::encode(true);
   }
   void MarkAsGlobal() {
     ASSERT(!is_lazy());
     flags_ |= IsGlobal::encode(true);
   }
   void SetLanguageMode(LanguageMode language_mode) {
     ASSERT(this->language_mode() == CLASSIC_MODE ||
            this->language_mode() == language_mode ||
            language_mode == EXTENDED_MODE);
     flags_ = LanguageModeField::update(flags_, language_mode);
   }
   void MarkAsInLoop() {
     ASSERT(is_lazy());
     flags_ |= IsInLoop::encode(true);
   }
   void MarkAsNative() {
     flags_ |= IsNative::encode(true);
   }
-
   bool is_native() const {
     return IsNative::decode(flags_);
   }
-
-  bool is_calling() const {
-    return is_deferred_calling() || is_non_deferred_calling();
-  }
-
-  void MarkAsDeferredCalling() {
-    flags_ |= IsDeferredCalling::encode(true);
-  }
-
-  bool is_deferred_calling() const {
-    return IsDeferredCalling::decode(flags_);
-  }
-
-  void MarkAsNonDeferredCalling() {
-    flags_ |= IsNonDeferredCalling::encode(true);
-  }
-
-  bool is_non_deferred_calling() const {
-    return IsNonDeferredCalling::decode(flags_);
-  }
-
   void SetFunction(FunctionLiteral* literal) {
     ASSERT(function_ == NULL);
     function_ = literal;
   }
   void SetScope(Scope* scope) {
     ASSERT(scope_ == NULL);
     scope_ = scope;
   }
   void SetGlobalScope(Scope* global_scope) {
     ASSERT(global_scope_ == NULL);
@@ skipping 30 matching lines @@
         (closure()->context()->global_object() != NULL);
   }
 
   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; }
   void SetOptimizing(BailoutId osr_ast_id) {
     SetMode(OPTIMIZE);
     osr_ast_id_ = osr_ast_id;
   }
   void DisableOptimization();
 
   // Deoptimization support.
   bool HasDeoptimizationSupport() const {
     return SupportsDeoptimization::decode(flags_);
   }
@@ skipping 38 matching lines @@
   Isolate* isolate_;
 
   // Compilation mode.
   // BASE is generated by the full codegen, optionally prepared for bailouts.
   // OPTIMIZE is optimized code generated by the Hydrogen-based backend.
   // NONOPT is generated by the full codegen and is not prepared for
   //   recompilation/bailouts.  These functions are never recompiled.
   enum Mode {
     BASE,
     OPTIMIZE,
-    NONOPT,
-    STUB
+    NONOPT
   };
 
-  void Initialize(Isolate* isolate, Mode mode, Zone* zone);
+  void Initialize(Zone* zone);
 
   void SetMode(Mode mode) {
     ASSERT(V8::UseCrankshaft());
     mode_ = mode;
   }
 
   // Flags using template class BitField<type, start, length>.  All are
   // false by default.
   //
   // Compilation is either eager or lazy.
   class IsLazy:   public BitField<bool, 0, 1> {};
   // Flags that can be set for eager compilation.
   class IsEval:   public BitField<bool, 1, 1> {};
   class IsGlobal: public BitField<bool, 2, 1> {};
   // Flags that can be set for lazy compilation.
   class IsInLoop: public BitField<bool, 3, 1> {};
   // Strict mode - used in eager compilation.
   class LanguageModeField: public BitField<LanguageMode, 4, 2> {};
   // Is this a function from our natives.
   class IsNative: public BitField<bool, 6, 1> {};
   // Is this code being compiled with support for deoptimization..
   class SupportsDeoptimization: public BitField<bool, 7, 1> {};
   // If compiling for debugging produce just full code matching the
   // initial mode setting.
   class IsCompilingForDebugging: public BitField<bool, 8, 1> {};
-  // If the compiled code contains calls that require building a frame
-  class IsCalling: public BitField<bool, 9, 1> {};
-  // If the compiled code contains calls that require building a frame
-  class IsDeferredCalling: public BitField<bool, 10, 1> {};
-  // If the compiled code contains calls that require building a frame
-  class IsNonDeferredCalling: public BitField<bool, 11, 1> {};
 
 
   unsigned flags_;
 
   // Fields filled in by the compilation pipeline.
   // AST filled in by the parser.
   FunctionLiteral* function_;
   // The scope of the function literal as a convenience.  Set to indicate
   // that scopes have been analyzed.
   Scope* scope_;
   // The global scope provided as a convenience.
   Scope* global_scope_;
-  // For compiled stubs, the stub object
-  HydrogenCodeStub* code_stub_;
   // The compiled code.
   Handle<Code> code_;
 
   // Possible initial inputs to the compilation process.
   Handle<JSFunction> closure_;
   Handle<SharedFunctionInfo> shared_info_;
   Handle<Script> script_;
 
   // Fields possibly needed for eager compilation, NULL by default.
   v8::Extension* extension_;
@@ skipping 40 matching lines @@
         zone_(script->GetIsolate()),
         zone_scope_(&zone_, DELETE_ON_EXIT) {}
   explicit CompilationInfoWithZone(Handle<SharedFunctionInfo> shared_info)
       : CompilationInfo(shared_info, &zone_),
         zone_(shared_info->GetIsolate()),
         zone_scope_(&zone_, DELETE_ON_EXIT) {}
   explicit CompilationInfoWithZone(Handle<JSFunction> closure)
       : CompilationInfo(closure, &zone_),
         zone_(closure->GetIsolate()),
         zone_scope_(&zone_, DELETE_ON_EXIT) {}
-  explicit CompilationInfoWithZone(HydrogenCodeStub* stub, Isolate* isolate)
-      : CompilationInfo(stub, isolate, &zone_),
-        zone_(isolate),
-        zone_scope_(&zone_, DELETE_ON_EXIT) {}
 
  private:
   Zone zone_;
   ZoneScope zone_scope_;
 };
 
 
 // A wrapper around a CompilationInfo that detaches the Handles from
 // the underlying DeferredHandleScope and stores them in info_ on
 // destruction.
 class CompilationHandleScope BASE_EMBEDDED {
  public:
   explicit CompilationHandleScope(CompilationInfo* info)
       : deferred_(info->isolate()), info_(info) {}
   ~CompilationHandleScope() {
     info_->set_deferred_handles(deferred_.Detach());
   }
 
  private:
   DeferredHandleScope deferred_;
   CompilationInfo* info_;
 };
 
 
 class HGraph;
-class HOptimizedGraphBuilder;
+class HGraphBuilder;
 class LChunk;
 
 // A helper class that calls the three compilation phases in
 // Crankshaft and keeps track of its state.  The three phases
 // CreateGraph, OptimizeGraph and GenerateAndInstallCode can either
 // fail, bail-out to the full code generator or succeed.  Apart from
 // their return value, the status of the phase last run can be checked
 // using last_status().
 class OptimizingCompiler: public ZoneObject {
  public:
@@ skipping 21 matching lines @@
 
   MUST_USE_RESULT Status AbortOptimization() {
     info_->AbortOptimization();
     info_->shared_info()->DisableOptimization(info_->bailout_reason());
     return SetLastStatus(BAILED_OUT);
   }
 
  private:
   CompilationInfo* info_;
   TypeFeedbackOracle* oracle_;
-  HOptimizedGraphBuilder* graph_builder_;
+  HGraphBuilder* graph_builder_;
   HGraph* graph_;
   LChunk* chunk_;
   int64_t time_taken_to_create_graph_;
   int64_t time_taken_to_optimize_;
   int64_t time_taken_to_codegen_;
   Status last_status_;
 
   MUST_USE_RESULT Status SetLastStatus(Status status) {
     last_status_ = status;
     return last_status_;
@@ skipping 82 matching lines @@
 
   static void RecordFunctionCompilation(Logger::LogEventsAndTags tag,
                                         CompilationInfo* info,
                                         Handle<SharedFunctionInfo> shared);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_