Merge (7265, 7271] from bleeding_edge to experimental/gc branch....

src/deoptimizer.h

 // Copyright 2011 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 75 matching lines @@
   virtual void EnterContext(Context* context) = 0;
 
   virtual void VisitFunction(JSFunction* function) = 0;
 
   // Function which is called after iteration of all optimized functions
   // from given global context.
   virtual void LeaveContext(Context* context) = 0;
 };
 
 
+class Deoptimizer;
+
+
+class DeoptimizerData {
+ public:
+  DeoptimizerData();
+  ~DeoptimizerData();
+
+ private:
+  MemoryChunk* eager_deoptimization_entry_code_;
+  MemoryChunk* lazy_deoptimization_entry_code_;
+  Deoptimizer* current_;
+
+  // List of deoptimized code which still have references from active stack
+  // frames. These code objects are needed by the deoptimizer when deoptimizing
+  // a frame for which the code object for the function function has been
+  // changed from the code present when deoptimizing was done.
+  DeoptimizingCodeListNode* deoptimizing_code_list_;
+
+  friend class Deoptimizer;
+
+  DISALLOW_COPY_AND_ASSIGN(DeoptimizerData);
+};
+
+
 class Deoptimizer : public Malloced {
  public:
   enum BailoutType {
     EAGER,
     LAZY,
     OSR
   };
 
   int output_count() const { return output_count_; }
 
   static Deoptimizer* New(JSFunction* function,
                           BailoutType type,
                           unsigned bailout_id,
                           Address from,
-                          int fp_to_sp_delta);
-  static Deoptimizer* Grab();
+                          int fp_to_sp_delta,
+                          Isolate* isolate);
+  static Deoptimizer* Grab(Isolate* isolate);
 
   // Deoptimize the function now. Its current optimized code will never be run
   // again and any activations of the optimized code will get deoptimized when
   // execution returns.
   static void DeoptimizeFunction(JSFunction* function);
 
   // Deoptimize all functions in the heap.
   static void DeoptimizeAll();
 
   static void DeoptimizeGlobalObject(JSObject* object);
@@ skipping 31 matching lines @@
   // Change all patched stack guard checks in the unoptimized code
   // back to a normal stack guard check.
   static void RevertStackCheckCodeAt(Address pc_after,
                                      Code* check_code,
                                      Code* replacement_code);
 
   ~Deoptimizer();
 
   void InsertHeapNumberValues(int index, JavaScriptFrame* frame);
 
-  static void ComputeOutputFrames(Deoptimizer* deoptimizer);
+  static void ComputeOutputFrames(Deoptimizer* deoptimizer, Isolate* isolate);
 
   static Address GetDeoptimizationEntry(int id, BailoutType type);
   static int GetDeoptimizationId(Address addr, BailoutType type);
   static int GetOutputInfo(DeoptimizationOutputData* data,
                            unsigned node_id,
                            SharedFunctionInfo* shared);
 
-  static void Setup();
-  static void TearDown();
-
   // Code generation support.
   static int input_offset() { return OFFSET_OF(Deoptimizer, input_); }
   static int output_count_offset() {
     return OFFSET_OF(Deoptimizer, output_count_);
   }
   static int output_offset() { return OFFSET_OF(Deoptimizer, output_); }
 
-  static int GetDeoptimizedCodeCount();
+  static int GetDeoptimizedCodeCount(Isolate* isolate);
 
   static const int kNotDeoptimizationEntry = -1;
 
   // Generators for the deoptimization entry code.
   class EntryGenerator BASE_EMBEDDED {
    public:
     EntryGenerator(MacroAssembler* masm, BailoutType type)
         : masm_(masm), type_(type) { }
     virtual ~EntryGenerator() { }
 
@@ skipping 20 matching lines @@
 
    private:
     int count() const { return count_; }
 
     int count_;
   };
 
  private:
   static const int kNumberOfEntries = 4096;
 
-  Deoptimizer(JSFunction* function,
+  Deoptimizer(Isolate* isolate,
+              JSFunction* function,
               BailoutType type,
               unsigned bailout_id,
               Address from,
               int fp_to_sp_delta);
   void DeleteFrameDescriptions();
 
   void DoComputeOutputFrames();
   void DoComputeOsrOutputFrame();
   void DoComputeFrame(TranslationIterator* iterator, int frame_index);
   void DoTranslateCommand(TranslationIterator* iterator,
@@ skipping 25 matching lines @@
   static MemoryChunk* CreateCode(BailoutType type);
   static void GenerateDeoptimizationEntries(
       MacroAssembler* masm, int count, BailoutType type);
 
   // Weak handle callback for deoptimizing code objects.
   static void HandleWeakDeoptimizedCode(
       v8::Persistent<v8::Value> obj, void* data);
   static Code* FindDeoptimizingCodeFromAddress(Address addr);
   static void RemoveDeoptimizingCode(Code* code);
 
-  static MemoryChunk* eager_deoptimization_entry_code_;
-  static MemoryChunk* lazy_deoptimization_entry_code_;
-  static Deoptimizer* current_;
-
-  // List of deoptimized code which still have references from active stack
-  // frames. These code objects are needed by the deoptimizer when deoptimizing
-  // a frame for which the code object for the function function has been
-  // changed from the code present when deoptimizing was done.
-  static DeoptimizingCodeListNode* deoptimizing_code_list_;
-
+  Isolate* isolate_;
   JSFunction* function_;
   Code* optimized_code_;
   unsigned bailout_id_;
   BailoutType bailout_type_;
   Address from_;
   int fp_to_sp_delta_;
 
   // Input frame description.
   FrameDescription* input_;
   // Number of output frames.
@@ skipping 233 matching lines @@
   Handle<Code> code_;
 
   // Next pointer for linked list.
   DeoptimizingCodeListNode* next_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_