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

src/hydrogen.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 508 matching lines @@
   bool ExpressionStackIsEmpty() const;
 
   HValue* ExpressionStackAt(int index_from_top) const {
     int index = length() - index_from_top - 1;
     ASSERT(HasExpressionAt(index));
     return values_[index];
   }
 
   void SetExpressionStackAt(int index_from_top, HValue* value);
 
+  int handler_count() { return handler_count_; }
+  void AddExceptionHandler() { ++handler_count_; }
+  void RemoveExceptionHandler() {
+    ASSERT(handler_count_ > 0);
+    --handler_count_;
+  }
+
   HEnvironment* Copy() const;
   HEnvironment* CopyWithoutHistory() const;
   HEnvironment* CopyAsLoopHeader(HBasicBlock* block) const;
 
   // Create an "inlined version" of this environment, where the original
   // environment is the outer environment but the top expression stack
   // elements are moved to an inner environment as parameters.
   HEnvironment* CopyForInlining(Handle<JSFunction> target,
                                 int arguments,
                                 FunctionLiteral* function,
@@ skipping 53 matching lines @@
   }
 
   Handle<JSFunction> closure_;
   // Value array [parameters] [specials] [locals] [temporaries].
   ZoneList<HValue*> values_;
   ZoneList<int> assigned_variables_;
   FrameType frame_type_;
   int parameter_count_;
   int specials_count_;
   int local_count_;
+  int handler_count_;
   HEnvironment* outer_;
   int pop_count_;
   int push_count_;
   BailoutId ast_id_;
   Zone* zone_;
 };
 
 
 class HGraphBuilder;
 
@@ skipping 190 matching lines @@
 class HGraphBuilder: public AstVisitor {
  public:
   enum BreakType { BREAK, CONTINUE };
   enum SwitchType { UNKNOWN_SWITCH, SMI_SWITCH, STRING_SWITCH };
 
   // A class encapsulating (lazily-allocated) break and continue blocks for
   // a breakable statement.  Separated from BreakAndContinueScope so that it
   // can have a separate lifetime.
   class BreakAndContinueInfo BASE_EMBEDDED {
    public:
-    explicit BreakAndContinueInfo(BreakableStatement* target,
-                                  int drop_extra = 0)
-        : target_(target),
+    BreakAndContinueInfo(Statement* statement, int drop_extra)
+        : statement_(statement),
           break_block_(NULL),
           continue_block_(NULL),
           drop_extra_(drop_extra) {
     }
 
-    BreakableStatement* target() { return target_; }
+    Statement* statement() { return statement_; }
+
     HBasicBlock* break_block() { return break_block_; }
     void set_break_block(HBasicBlock* block) { break_block_ = block; }
     HBasicBlock* continue_block() { return continue_block_; }
     void set_continue_block(HBasicBlock* block) { continue_block_ = block; }
     int drop_extra() { return drop_extra_; }
 
    private:
-    BreakableStatement* target_;
+    Statement* statement_;
     HBasicBlock* break_block_;
     HBasicBlock* continue_block_;
     int drop_extra_;
   };
 
   // A helper class to maintain a stack of current BreakAndContinueInfo
   // structures mirroring BreakableStatement nesting.
   class BreakAndContinueScope BASE_EMBEDDED {
    public:
     BreakAndContinueScope(BreakAndContinueInfo* info, HGraphBuilder* owner)
         : info_(info), owner_(owner), next_(owner->break_scope()) {
       owner->set_break_scope(this);
     }
 
     ~BreakAndContinueScope() { owner_->set_break_scope(next_); }
 
     BreakAndContinueInfo* info() { return info_; }
     HGraphBuilder* owner() { return owner_; }
     BreakAndContinueScope* next() { return next_; }
 
-    // Search the break stack for a break or continue target.
-    HBasicBlock* Get(BreakableStatement* stmt, BreakType type, int* drop_extra);
+    // Search the break stack for a break or continue target, emit any
+    // instructions necessary to unwind the break stack and emit a jump to
+    // the target block.
+    void Unwind(BreakableStatement* target, BreakType type);
+
+    // Unwind the entire break stack for returning from the function.
+    void UnwindReturn();
 
    private:
     BreakAndContinueInfo* info_;
     HGraphBuilder* owner_;
     BreakAndContinueScope* next_;
   };
 
   HGraphBuilder(CompilationInfo* info, TypeFeedbackOracle* oracle);
 
   HGraph* CreateGraph();
@@ skipping 621 matching lines @@
   const char* filename_;
   HeapStringAllocator string_allocator_;
   StringStream trace_;
   int indent_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_