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

src/ast.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 147 matching lines @@
 
 #define DECLARE_NODE_TYPE(type)                                         \
   virtual void Accept(AstVisitor* v);                                   \
   virtual AstNode::Type node_type() const { return AstNode::k##type; }  \
   template<class> friend class AstNodeFactory;
 
 
 enum AstPropertiesFlag {
   kDontInline,
   kDontOptimize,
+  kDontOsr,
   kDontSelfOptimize,
   kDontSoftInline,
   kDontCache
 };
 
 
 class AstProperties BASE_EMBEDDED {
  public:
   class Flags : public EnumSet<AstPropertiesFlag, int> {};
 
@@ skipping 885 matching lines @@
 class TryStatement: public Statement {
  public:
   void set_escaping_targets(ZoneList<Label*>* targets) {
     escaping_targets_ = targets;
   }
 
   int index() const { return index_; }
   Block* try_block() const { return try_block_; }
   ZoneList<Label*>* escaping_targets() const { return escaping_targets_; }
 
+  BailoutId TryEntryId() const { return try_entry_id_; }
+  BailoutId TryExitId() const { return try_exit_id_; }
+
  protected:
-  TryStatement(int index, Block* try_block)
+  TryStatement(Isolate* isolate, int index, Block* try_block)
       : index_(index),
+        try_entry_id_(GetNextId(isolate)),
+        try_exit_id_(GetNextId(isolate)),
         try_block_(try_block),
         escaping_targets_(NULL) { }
 
  private:
   // Unique (per-function) index of this handler.  This is not an AST ID.
   int index_;
 
+  BailoutId try_entry_id_;
+  BailoutId try_exit_id_;
+
   Block* try_block_;
   ZoneList<Label*>* escaping_targets_;
 };
 
 
 class TryCatchStatement: public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryCatchStatement)
 
   Scope* scope() { return scope_; }
   Variable* variable() { return variable_; }
   Block* catch_block() const { return catch_block_; }
 
  protected:
-  TryCatchStatement(int index,
+  TryCatchStatement(Isolate* isolate,
+                    int index,
                     Block* try_block,
                     Scope* scope,
                     Variable* variable,
                     Block* catch_block)
-      : TryStatement(index, try_block),
+      : TryStatement(isolate, index, try_block),
         scope_(scope),
         variable_(variable),
-        catch_block_(catch_block) {
-  }
+        catch_block_(catch_block) { }
 
  private:
   Scope* scope_;
   Variable* variable_;
   Block* catch_block_;
 };
 
 
 class TryFinallyStatement: public TryStatement {
  public:
   DECLARE_NODE_TYPE(TryFinallyStatement)
 
   Block* finally_block() const { return finally_block_; }
 
  protected:
-  TryFinallyStatement(int index, Block* try_block, Block* finally_block)
-      : TryStatement(index, try_block),
+  TryFinallyStatement(Isolate* isolate,
+                      int index,
+                      Block* try_block,
+                      Block* finally_block)
+      : TryStatement(isolate, index, try_block),
         finally_block_(finally_block) { }
 
  private:
   Block* finally_block_;
 };
 
 
 class DebuggerStatement: public Statement {
  public:
   DECLARE_NODE_TYPE(DebuggerStatement)
@@ skipping 1552 matching lines @@
   }
 
   IfStatement* NewIfStatement(Expression* condition,
                               Statement* then_statement,
                               Statement* else_statement) {
     IfStatement* stmt = new(zone_) IfStatement(
         isolate_, condition, then_statement, else_statement);
     VISIT_AND_RETURN(IfStatement, stmt)
   }
 
-  TryCatchStatement* NewTryCatchStatement(int index,
+  TryCatchStatement* NewTryCatchStatement(Isolate* isolate,
+                                          int index,
                                           Block* try_block,
                                           Scope* scope,
                                           Variable* variable,
                                           Block* catch_block) {
     TryCatchStatement* stmt = new(zone_) TryCatchStatement(
-        index, try_block, scope, variable, catch_block);
+        isolate, index, try_block, scope, variable, catch_block);
     VISIT_AND_RETURN(TryCatchStatement, stmt)
   }
 
-  TryFinallyStatement* NewTryFinallyStatement(int index,
+  TryFinallyStatement* NewTryFinallyStatement(Isolate* isolate,
+                                              int index,
                                               Block* try_block,
                                               Block* finally_block) {
     TryFinallyStatement* stmt =
-        new(zone_) TryFinallyStatement(index, try_block, finally_block);
+        new(zone_) TryFinallyStatement(isolate, index, try_block,
+                                       finally_block);
     VISIT_AND_RETURN(TryFinallyStatement, stmt)
   }
 
   DebuggerStatement* NewDebuggerStatement() {
     DebuggerStatement* stmt = new(zone_) DebuggerStatement();
     VISIT_AND_RETURN(DebuggerStatement, stmt)
   }
 
   EmptyStatement* NewEmptyStatement() {
     return new(zone_) EmptyStatement();
@@ skipping 194 matching lines @@
  private:
   Isolate* isolate_;
   Zone* zone_;
   Visitor visitor_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_