Drop IsPregenerated() and allow_stub_calls flag.

src/code-stubs.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 143 matching lines @@
 
   // Gets the major key from a code object that is a code stub or binary op IC.
   static Major GetMajorKey(Code* code_stub) {
     return static_cast<Major>(code_stub->major_key());
   }
 
   static const char* MajorName(Major major_key, bool allow_unknown_keys);
 
   virtual ~CodeStub() {}
 
-  bool CompilingCallsToThisStubIsGCSafe(Isolate* isolate) {
-    bool is_pregenerated = IsPregenerated(isolate);
-    Code* code = NULL;
-    CHECK(!is_pregenerated || FindCodeInCache(&code, isolate));
-    return is_pregenerated;
-  }
-
-  // See comment above, where Instanceof is defined.
-  virtual bool IsPregenerated(Isolate* isolate) { return false; }
-
   static void GenerateStubsAheadOfTime(Isolate* isolate);
   static void GenerateStubsRequiringBuiltinsAheadOfTime(Isolate* isolate);
   static void GenerateFPStubs(Isolate* isolate);
 
   // Some stubs put untagged junk on the stack that cannot be scanned by the
   // GC.  This means that we must be statically sure that no GC can occur while
   // they are running.  If that is the case they should override this to return
   // true, which will cause an assertion if we try to call something that can
   // GC or if we try to put a stack frame on top of the junk, which would not
   // result in a traversable stack.
@@ skipping 492 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FastCloneShallowObjectStub);
 };
 
 
 class CreateAllocationSiteStub : public HydrogenCodeStub {
  public:
   explicit CreateAllocationSiteStub() { }
 
   virtual Handle<Code> GenerateCode(Isolate* isolate);
 
-  virtual bool IsPregenerated(Isolate* isolate) V8_OVERRIDE { return true; }
-
   static void GenerateAheadOfTime(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor);
 
  private:
   Major MajorKey() { return CreateAllocationSite; }
   int NotMissMinorKey() { return 0; }
 
@@ skipping 762 matching lines @@
   explicit CEntryStub(int result_size,
                       SaveFPRegsMode save_doubles = kDontSaveFPRegs)
       : result_size_(result_size), save_doubles_(save_doubles) { }
 
   void Generate(MacroAssembler* masm);
 
   // The version of this stub that doesn't save doubles is generated ahead of
   // time, so it's OK to call it from other stubs that can't cope with GC during
   // their code generation.  On machines that always have gp registers (x64) we
   // can generate both variants ahead of time.
-  virtual bool IsPregenerated(Isolate* isolate) V8_OVERRIDE;
   static void GenerateAheadOfTime(Isolate* isolate);
 
  protected:
   virtual void VerifyPlatformFeatures(Isolate* isolate) V8_OVERRIDE {
     ASSERT(CpuFeatures::VerifyCrossCompiling(SSE2));
   };
 
  private:
   void GenerateCore(MacroAssembler* masm,
                     Label* throw_normal_exception,
@@ skipping 331 matching lines @@
   }
 
  private:
   StringCharCodeAtGenerator char_code_at_generator_;
   StringCharFromCodeGenerator char_from_code_generator_;
 
   DISALLOW_COPY_AND_ASSIGN(StringCharAtGenerator);
 };
 
 
-class AllowStubCallsScope {
- public:
-  AllowStubCallsScope(MacroAssembler* masm, bool allow)
-       : masm_(masm), previous_allow_(masm->allow_stub_calls()) {
-    masm_->set_allow_stub_calls(allow);
-  }
-  ~AllowStubCallsScope() {
-    masm_->set_allow_stub_calls(previous_allow_);
-  }
-
- private:
-  MacroAssembler* masm_;
-  bool previous_allow_;
-
-  DISALLOW_COPY_AND_ASSIGN(AllowStubCallsScope);
-};
-
-
 class KeyedLoadDictionaryElementStub : public HydrogenCodeStub {
  public:
   KeyedLoadDictionaryElementStub() {}
 
   virtual Handle<Code> GenerateCode(Isolate* isolate) V8_OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       Isolate* isolate,
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
@@ skipping 227 matching lines @@
   }
 
   AllocationSiteOverrideMode override_mode() const {
     return AllocationSiteOverrideModeBits::decode(bit_field_);
   }
 
   ContextCheckMode context_mode() const {
     return ContextCheckModeBits::decode(bit_field_);
   }
 
-  virtual bool IsPregenerated(Isolate* isolate) V8_OVERRIDE {
-    // We only pre-generate stubs that verify correct context
-    return context_mode() == CONTEXT_CHECK_REQUIRED;
-  }
-
   static void GenerateStubsAheadOfTime(Isolate* isolate);
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kConstructor = 0;
   static const int kPropertyCell = 1;
 
  private:
   int NotMissMinorKey() { return bit_field_; }
 
@@ skipping 76 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ArrayNArgumentsConstructorStub);
 };
 
 
 class InternalArrayConstructorStubBase : public HydrogenCodeStub {
  public:
   explicit InternalArrayConstructorStubBase(ElementsKind kind) {
     kind_ = kind;
   }
 
-  virtual bool IsPregenerated(Isolate* isolate) V8_OVERRIDE { return true; }
   static void GenerateStubsAheadOfTime(Isolate* isolate);
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kConstructor = 0;
 
   ElementsKind elements_kind() const { return kind_; }
 
  private:
   int NotMissMinorKey() { return kind_; }
@@ skipping 243 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StoreArrayLiteralElementStub);
 };
 
 
 class StubFailureTrampolineStub : public PlatformCodeStub {
  public:
   explicit StubFailureTrampolineStub(StubFunctionMode function_mode)
       : fp_registers_(CanUseFPRegisters()), function_mode_(function_mode) {}
 
-  virtual bool IsPregenerated(Isolate* isolate) V8_OVERRIDE { return true; }
-
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
   class FPRegisters:       public BitField<bool,                0, 1> {};
   class FunctionModeField: public BitField<StubFunctionMode,    1, 1> {};
 
   Major MajorKey() { return StubFailureTrampoline; }
   int MinorKey() {
     return FPRegisters::encode(fp_registers_) |
         FunctionModeField::encode(function_mode_);
   }
 
   void Generate(MacroAssembler* masm);
 
   bool fp_registers_;
   StubFunctionMode function_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(StubFailureTrampolineStub);
 };
 
 
 class StubFailureTailCallTrampolineStub : public PlatformCodeStub {
  public:
   StubFailureTailCallTrampolineStub() : fp_registers_(CanUseFPRegisters()) {}
 
-  virtual bool IsPregenerated(Isolate* isolate) V8_OVERRIDE { return true; }
-
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
   class FPRegisters: public BitField<bool, 0, 1> {};
   Major MajorKey() { return StubFailureTailCallTrampoline; }
   int MinorKey() { return FPRegisters::encode(fp_registers_); }
 
   void Generate(MacroAssembler* masm);
 
   bool fp_registers_;
@@ skipping 21 matching lines @@
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 
   DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_