Rebase of partial ia32 implementation of optimized try/catch (started by Kevin Millikin, continued …

src/deoptimizer.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 87 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 native context.
   virtual void LeaveContext(Context* context) = 0;
 };
 
 
+// Linked list holding deoptimizing code objects. The deoptimizing code objects
+// are kept as weak handles until they are no longer activated on the stack.
+class DeoptimizingCodeListNode : public Malloced {
+ public:
+  explicit DeoptimizingCodeListNode(Code* code);
+  ~DeoptimizingCodeListNode();
+
+  DeoptimizingCodeListNode* next() const { return next_; }
+  void set_next(DeoptimizingCodeListNode* next) { next_ = next; }
+  Handle<Code> code() const { return code_; }
+
+ private:
+  // Global (weak) handle to the deoptimizing code object.
+  Handle<Code> code_;
+
+  // Next pointer for linked list.
+  DeoptimizingCodeListNode* next_;
+};
+
+
 class OptimizedFunctionFilter BASE_EMBEDDED {
  public:
   virtual ~OptimizedFunctionFilter() {}
 
   virtual bool TakeFunction(JSFunction* function) = 0;
 };
 
 
-class Deoptimizer;
-
-
 class Deoptimizer : public Malloced {
  public:
   enum BailoutType {
     EAGER,
     LAZY,
     SOFT,
     OSR,
     // This last bailout type is not really a bailout, but used by the
     // debugger to deoptimize stack frames to allow inspection.
     DEBUGGER
@@ skipping 197 matching lines @@
     virtual void GeneratePrologue();
 
    private:
     int count() const { return count_; }
 
     int count_;
   };
 
   int ConvertJSFrameIndexToFrameIndex(int jsframe_index);
 
+  // Unregister a code object from lazy deoptimization.
+  static void RemoveDeoptimizingCode(Code* code);
+
   static size_t GetMaxDeoptTableSize();
 
   static void EnsureCodeForDeoptimizationEntry(Isolate* isolate,
                                                BailoutType type,
                                                int max_entry_id);
 
   Isolate* isolate() const { return isolate_; }
 
  private:
   static const int kMinNumberOfEntries = 64;
@@ skipping 42 matching lines @@
   // (e.g., a number conversion failed) and may or may not have updated the
   // input offset.
   bool DoOsrTranslateCommand(TranslationIterator* iterator,
                              int* input_offset);
 
   unsigned ComputeInputFrameSize() const;
   unsigned ComputeFixedSize(JSFunction* function) const;
 
   unsigned ComputeIncomingArgumentSize(JSFunction* function) const;
   unsigned ComputeOutgoingArgumentSize() const;
+  unsigned ComputeHandlersSize() const;
 
   Object* ComputeLiteral(int index) const;
 
   void AddObjectStart(intptr_t slot_address, int argc);
   void AddObjectTaggedValue(intptr_t value);
   void AddObjectDoubleValue(double value);
   void AddDoubleValue(intptr_t slot_address, double value);
 
   static void GenerateDeoptimizationEntries(
       MacroAssembler* masm, int count, BailoutType type);
@@ skipping 175 matching lines @@
   }
 
   static int continuation_offset() {
     return OFFSET_OF(FrameDescription, continuation_);
   }
 
   static int frame_content_offset() {
     return OFFSET_OF(FrameDescription, frame_content_);
   }
 
+  unsigned frame_size() { return static_cast<unsigned>(frame_size_); }
+
  private:
   static const uint32_t kZapUint32 = 0xbeeddead;
 
   // Frame_size_ must hold a uint32_t value.  It is only a uintptr_t to
   // keep the variable-size array frame_content_ of type intptr_t at
   // the end of the structure aligned.
   uintptr_t frame_size_;  // Number of bytes.
   JSFunction* function_;
   intptr_t registers_[Register::kNumRegisters];
   double double_registers_[DoubleRegister::kMaxNumRegisters];
@@ skipping 27 matching lines @@
   explicit DeoptimizerData(MemoryAllocator* allocator);
   ~DeoptimizerData();
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   void Iterate(ObjectVisitor* v);
 #endif
 
   Code* FindDeoptimizingCode(Address addr);
   void RemoveDeoptimizingCode(Code* code);
 
+  void append_deoptimizing_code(Code* code) {
+    DeoptimizingCodeListNode* head = new DeoptimizingCodeListNode(code);
+    head->set_next(deoptimizing_code_list_);
+    deoptimizing_code_list_ = head;
+  }
+
  private:
   MemoryAllocator* allocator_;
   int deopt_entry_code_entries_[Deoptimizer::kBailoutTypesWithCodeEntry];
   MemoryChunk* deopt_entry_code_[Deoptimizer::kBailoutTypesWithCodeEntry];
   Deoptimizer* current_;
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   DeoptimizedFrameInfo* deoptimized_frame_info_;
 #endif
 
   // 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;
+  friend class Isolate;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptimizerData);
 };
 
 
 class TranslationBuffer BASE_EMBEDDED {
  public:
   explicit TranslationBuffer(Zone* zone) : contents_(256, zone) { }
 
   int CurrentIndex() const { return contents_.length(); }
@@ skipping 59 matching lines @@
         index_(buffer->CurrentIndex()),
         zone_(zone) {
     buffer_->Add(BEGIN, zone);
     buffer_->Add(frame_count, zone);
     buffer_->Add(jsframe_count, zone);
   }
 
   int index() const { return index_; }
 
   // Commands.
-  void BeginJSFrame(BailoutId node_id, int literal_id, unsigned height);
+  void BeginJSFrame(BailoutId node_id,
+                    int literal_id,
+                    unsigned height,
+                    int handler_count);
   void BeginCompiledStubFrame();
   void BeginArgumentsAdaptorFrame(int literal_id, unsigned height);
   void BeginConstructStubFrame(int literal_id, unsigned height);
   void BeginGetterStubFrame(int literal_id);
   void BeginSetterStubFrame(int literal_id);
   void BeginArgumentsObject(int args_length);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
   void StoreUint32Register(Register reg);
   void StoreDoubleRegister(DoubleRegister reg);
@@ skipping 15 matching lines @@
   // A literal id which refers to the JSFunction itself.
   static const int kSelfLiteralId = -239;
 
  private:
   TranslationBuffer* buffer_;
   int index_;
   Zone* zone_;
 };
 
 
-// Linked list holding deoptimizing code objects. The deoptimizing code objects
-// are kept as weak handles until they are no longer activated on the stack.
-class DeoptimizingCodeListNode : public Malloced {
- public:
-  explicit DeoptimizingCodeListNode(Code* code);
-  ~DeoptimizingCodeListNode();
-
-  DeoptimizingCodeListNode* next() const { return next_; }
-  void set_next(DeoptimizingCodeListNode* next) { next_ = next; }
-  Handle<Code> code() const { return code_; }
-
- private:
-  // Global (weak) handle to the deoptimizing code object.
-  Handle<Code> code_;
-
-  // Next pointer for linked list.
-  DeoptimizingCodeListNode* next_;
-};
-
-
 class SlotRef BASE_EMBEDDED {
  public:
   enum SlotRepresentation {
     UNKNOWN,
     TAGGED,
     INT32,
     UINT32,
     DOUBLE,
     LITERAL
   };
@@ skipping 148 matching lines @@
   Object** expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_