Added Isolate parameter to CodeStub::GetCode().

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 108 matching lines @@
  public:
   enum Major {
 #define DEF_ENUM(name) name,
     CODE_STUB_LIST(DEF_ENUM)
 #undef DEF_ENUM
     NoCache,  // marker for stubs that do custom caching
     NUMBER_OF_IDS
   };
 
   // Retrieve the code for the stub. Generate the code if needed.
-  Handle<Code> GetCode();
+  Handle<Code> GetCode(Isolate* isolate);
 
   static Major MajorKeyFromKey(uint32_t key) {
     return static_cast<Major>(MajorKeyBits::decode(key));
   }
   static int MinorKeyFromKey(uint32_t key) {
     return MinorKeyBits::decode(key);
   }
 
   // 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() {
     bool is_pregenerated = IsPregenerated();
     Code* code = NULL;
     CHECK(!is_pregenerated || FindCodeInCache(&code, Isolate::Current()));
     return is_pregenerated;
   }
 
   // See comment above, where Instanceof is defined.
   virtual bool IsPregenerated() { return false; }
 
-  static void GenerateStubsAheadOfTime();
-  static void GenerateFPStubs();
+  static void GenerateStubsAheadOfTime(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.
   virtual bool SometimesSetsUpAFrame() { return true; }
 
   // Lookup the code in the (possibly custom) cache.
@@ skipping 668 matching lines @@
                       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();
-  static void GenerateAheadOfTime();
+  static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
   void GenerateCore(MacroAssembler* masm,
                     Label* throw_normal_exception,
                     Label* throw_termination_exception,
                     Label* throw_out_of_memory_exception,
                     bool do_gc,
                     bool always_allocate_scope);
 
   // Number of pointers/values returned.
@@ skipping 597 matching lines @@
 
 class StubFailureTrampolineStub : public PlatformCodeStub {
  public:
   static const int kMaxExtraExpressionStackCount = 1;
 
   explicit StubFailureTrampolineStub(int extra_expression_stack_count)
       : extra_expression_stack_count_(extra_expression_stack_count) {}
 
   virtual bool IsPregenerated() { return true; }
 
-  static void GenerateAheadOfTime();
+  static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
   Major MajorKey() { return StubFailureTrampoline; }
   int MinorKey() { return extra_expression_stack_count_; }
 
   void Generate(MacroAssembler* masm);
 
   int extra_expression_stack_count_;
 
   DISALLOW_COPY_AND_ASSIGN(StubFailureTrampolineStub);
@@ skipping 28 matching lines @@
 
   // The current function entry hook.
   static FunctionEntryHook entry_hook_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_