Partial ia32 implementation of optimized try/catch (by Kevin Millikin)

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 58 matching lines @@
 
   // Function which is called after iteration of all optimized functions
   // from given native context.
   virtual void LeaveContext(Context* context) = 0;
 };
 
 
 class Deoptimizer;
 
 
+// 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 DeoptimizerData {
  public:
   DeoptimizerData();
   ~DeoptimizerData();
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   void Iterate(ObjectVisitor* v);
 #endif
 
+  void append_deoptimizing_code(Code* code) {
+    DeoptimizingCodeListNode* head = new DeoptimizingCodeListNode(code);
+    head->set_next(deoptimizing_code_list_);
+    deoptimizing_code_list_ = head;
+  }
+
  private:
   MemoryChunk* eager_deoptimization_entry_code_;
   MemoryChunk* lazy_deoptimization_entry_code_;
   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 Deoptimizer : public Malloced {
  public:
   enum BailoutType {
     EAGER,
     LAZY,
@@ skipping 144 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);
+
  private:
   static const int kNumberOfEntries = 16384;
 
   Deoptimizer(Isolate* isolate,
               JSFunction* function,
               BailoutType type,
               unsigned bailout_id,
               Address from,
               int fp_to_sp_delta,
               Code* optimized_code);
@@ skipping 17 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 AddDoubleValue(intptr_t slot_address, double value);
 
   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);
 
   // Fill the input from from a JavaScript frame. This is used when
   // the debugger needs to inspect an optimized frame. For normal
   // deoptimizations the input frame is filled in generated code.
   void FillInputFrame(Address tos, JavaScriptFrame* frame);
 
   Isolate* isolate_;
   JSFunction* function_;
   Code* optimized_code_;
   unsigned bailout_id_;
@@ skipping 147 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::kNumAllocatableRegisters];
@@ skipping 91 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 BeginArgumentsAdaptorFrame(int literal_id, unsigned height);
   void BeginConstructStubFrame(int literal_id, unsigned height);
   void BeginGetterStubFrame(int literal_id);
   void BeginSetterStubFrame(int literal_id);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
   void StoreUint32Register(Register reg);
   void StoreDoubleRegister(DoubleRegister reg);
   void StoreStackSlot(int index);
   void StoreInt32StackSlot(int index);
@@ skipping 14 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 149 matching lines @@
   Object** expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_