Try/catch in graph builder.

runtime/vm/intermediate_language.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 38 matching lines @@
   M(CreateArray, CreateArrayComp)                                              \
   M(CreateClosure, CreateClosureComp)                                          \
   M(AllocateObject, AllocateObjectComp)                                        \
   M(NativeLoadField, NativeLoadFieldComp)                                      \
   M(ExtractFactoryTypeArguments, ExtractFactoryTypeArgumentsComp)              \
   M(ExtractConstructorTypeArguments, ExtractConstructorTypeArgumentsComp)      \
   M(ExtractConstructorInstantiator, ExtractConstructorInstantiatorComp)        \
   M(AllocateContext, AllocateContextComp)                                      \
   M(ChainContext, ChainContextComp)                                            \
   M(CloneContext, CloneContextComp)                                            \
+  M(CatchEntry, CatchEntryComp)                                                \
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 class Computation : public ZoneAllocated {
  public:
   Computation() { }
 
@@ skipping 109 matching lines @@
  private:
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreContextComp);
 };
 
 
 class ClosureCallComp : public Computation {
  public:
   ClosureCallComp(ClosureCallNode* node,
+                  intptr_t try_index,
                   Value* context,
                   ZoneGrowableArray<Value*>* arguments)
       : ast_node_(*node),
+        try_index_(try_index),
         context_(context),
         arguments_(arguments) {
     ASSERT(context->IsTemp());
   }
 
   DECLARE_COMPUTATION(ClosureCall)
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t try_index() const { return try_index_; }
 
   Value* context() const { return context_; }
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
  private:
   const ClosureCallNode& ast_node_;
+  const intptr_t try_index_;
   Value* context_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
 
 class InstanceCallComp : public Computation {
  public:
   InstanceCallComp(intptr_t node_id,
                    intptr_t token_index,
+                   intptr_t try_index,
                    const String& function_name,
                    ZoneGrowableArray<Value*>* arguments,
                    const Array& argument_names,
                    intptr_t checked_argument_count)
       : node_id_(node_id),
         token_index_(token_index),
+        try_index_(try_index),
         function_name_(function_name),
         arguments_(arguments),
         argument_names_(argument_names),
         checked_argument_count_(checked_argument_count) {
     ASSERT(function_name.IsZoneHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle());
   }
 
   DECLARE_COMPUTATION(InstanceCall)
 
   intptr_t node_id() const { return node_id_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   const String& function_name() const { return function_name_; }
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
  private:
   const intptr_t node_id_;
   const intptr_t token_index_;
+  const intptr_t try_index_;
   const String& function_name_;
   ZoneGrowableArray<Value*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
 };
 
 
 class StrictCompareComp : public Computation {
@@ skipping 14 matching lines @@
   Value* left_;
   Value* right_;
 
   DISALLOW_COPY_AND_ASSIGN(StrictCompareComp);
 };
 
 
 class StaticCallComp : public Computation {
  public:
   StaticCallComp(intptr_t token_index,
+                 intptr_t try_index,
                  const Function& function,
                  const Array& argument_names,
                  ZoneGrowableArray<Value*>* arguments)
       : token_index_(token_index),
+        try_index_(try_index),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments) {
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle());
   }
 
   DECLARE_COMPUTATION(StaticCall)
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
 
  private:
   const intptr_t token_index_;
+  const intptr_t try_index_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<Value*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallComp);
 };
 
 
 class LoadLocalComp : public Computation {
  public:
@@ skipping 30 matching lines @@
   const LocalVariable& local_;
   Value* value_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
 };
 
 
 class NativeCallComp : public Computation {
  public:
-  explicit NativeCallComp(NativeBodyNode* node) : ast_node_(*node) {}
+  NativeCallComp(NativeBodyNode* node, intptr_t try_index)
+      : ast_node_(*node), try_index_(try_index) {}
 
   DECLARE_COMPUTATION(NativeCall)
 
   intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t try_index() const { return try_index_; }
 
   const String& native_name() const {
     return ast_node_.native_c_function_name();
   }
 
   NativeFunction native_c_function() const {
     return ast_node_.native_c_function();
   }
 
   intptr_t argument_count() const { return ast_node_.argument_count(); }
 
   bool has_optional_parameters() const {
     return ast_node_.has_optional_parameters();
   }
 
  private:
   const NativeBodyNode& ast_node_;
+  const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallComp);
 };
 
 
 class LoadInstanceFieldComp : public Computation {
  public:
   LoadInstanceFieldComp(LoadInstanceFieldNode* ast_node, Value* instance)
       : ast_node_(*ast_node), instance_(instance) {
     ASSERT(instance_ != NULL);
@@ skipping 77 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
 class StoreIndexedComp : public Computation {
  public:
   StoreIndexedComp(intptr_t node_id,
                    intptr_t token_index,
+                   intptr_t try_index,
                    Value* array,
                    Value* index,
                    Value* value)
       : node_id_(node_id),
         token_index_(token_index),
+        try_index_(try_index),
         array_(array),
         index_(index),
         value_(value) { }
 
   DECLARE_COMPUTATION(StoreIndexed)
 
   intptr_t node_id() const { return node_id_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   Value* array() const { return array_; }
   Value* index() const { return index_; }
   Value* value() const { return value_; }
 
  private:
-  intptr_t node_id_;
-  intptr_t token_index_;
+  const intptr_t node_id_;
+  const intptr_t token_index_;
+  const intptr_t try_index_;
   Value* array_;
   Value* index_;
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedComp);
 };
 
 
 // Not simply an InstanceCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
 class InstanceSetterComp : public Computation {
  public:
   InstanceSetterComp(intptr_t node_id,
                      intptr_t token_index,
+                     intptr_t try_index,
                      const String& field_name,
                      Value* receiver,
                      Value* value)
       : node_id_(node_id),
         token_index_(token_index),
+        try_index_(try_index),
         field_name_(field_name),
         receiver_(receiver),
         value_(value) { }
 
   DECLARE_COMPUTATION(InstanceSetter)
 
   intptr_t node_id() const { return node_id_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   const String& field_name() const { return field_name_; }
   Value* receiver() const { return receiver_; }
   Value* value() const { return value_; }
 
  private:
   const intptr_t node_id_;
   const intptr_t token_index_;
+  const intptr_t try_index_;
   const String& field_name_;
   Value* const receiver_;
   Value* const value_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceSetterComp);
 };
 
 
 // Not simply a StaticCall because it has somewhat more complicated
 // semantics: the value operand is preserved before the call.
 class StaticSetterComp : public Computation {
  public:
   StaticSetterComp(intptr_t token_index,
+                   intptr_t try_index,
                    const Function& setter_function,
                    Value* value)
       : token_index_(token_index),
+        try_index_(try_index),
         setter_function_(setter_function),
         value_(value) { }
 
   DECLARE_COMPUTATION(StaticSetter)
 
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   const Function& setter_function() const { return setter_function_; }
   Value* value() const { return value_; }
 
  private:
   const intptr_t token_index_;
+  const intptr_t try_index_;
   const Function& setter_function_;
   Value* const value_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticSetterComp);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateComp : public Computation {
  public:
   explicit BooleanNegateComp(Value* value) : value_(value) {}
 
   DECLARE_COMPUTATION(BooleanNegate)
 
   Value* value() const { return value_; }
 
  private:
   Value* value_;
 
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateComp);
 };
 
 
 class InstanceOfComp : public Computation {
  public:
   InstanceOfComp(intptr_t node_id,
                  intptr_t token_index,
+                 intptr_t try_index,
                  Value* value,
                  const AbstractType& type,
                  bool negate_result)
       : node_id_(node_id),
         token_index_(token_index),
+        try_index_(try_index),
         value_(value),
         type_(type),
         negate_result_(negate_result) {}
 
   DECLARE_COMPUTATION(InstanceOf)
 
   Value* value() const { return value_; }
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
   intptr_t node_id() const { return node_id_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
 
  private:
   const intptr_t node_id_;
   const intptr_t token_index_;
+  const intptr_t try_index_;
   Value* value_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfComp);
 };
 
 
 class AllocateObjectComp : public Computation {
  public:
   AllocateObjectComp(ConstructorCallNode* node,
+                     intptr_t try_index,
                      ZoneGrowableArray<Value*>* arguments)
-      : ast_node_(*node), arguments_(arguments) {
+      : ast_node_(*node), try_index_(try_index), arguments_(arguments) {
     // Either no arguments or one type-argument and one instantiator.
     ASSERT(arguments->is_empty() || (arguments->length() == 2));
   }
 
   DECLARE_COMPUTATION(AllocateObject)
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t try_index() const { return try_index_; }
   const ZoneGrowableArray<Value*>& arguments() const { return *arguments_; }
 
  private:
   const ConstructorCallNode& ast_node_;
+  const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const arguments_;
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectComp);
 };
 
 
 class CreateArrayComp : public Computation {
  public:
-  CreateArrayComp(ArrayNode* node, ZoneGrowableArray<Value*>* elements)
-      : ast_node_(*node), elements_(elements) { }
+  CreateArrayComp(ArrayNode* node,
+                  intptr_t try_index,
+                  ZoneGrowableArray<Value*>* elements)
+      : ast_node_(*node), try_index_(try_index), elements_(elements) { }
 
   DECLARE_COMPUTATION(CreateArray)
 
   intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t try_index() const { return try_index_; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   intptr_t ElementCount() const { return elements_->length(); }
   Value* ElementAt(intptr_t i) const { return (*elements_)[i]; }
 
  private:
   const ArrayNode& ast_node_;
+  const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const elements_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
 };
 
 
 class CreateClosureComp : public Computation {
  public:
   // 'type_arguments' is null if function() does not require type arguments.
-  CreateClosureComp(ClosureNode* node, Value* type_arguments)
-      : ast_node_(*node), type_arguments_(type_arguments) { }
+  CreateClosureComp(ClosureNode* node,
+                    intptr_t try_index,
+                    Value* type_arguments)
+      : ast_node_(*node),
+        try_index_(try_index),
+        type_arguments_(type_arguments) {}
 
   DECLARE_COMPUTATION(CreateClosure)
 
   intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t try_index() const { return try_index_; }
   const Function& function() const { return ast_node_.function(); }
   Value* type_arguments() const { return type_arguments_; }
 
  private:
   const ClosureNode& ast_node_;
+  const intptr_t try_index_;
   Value* type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureComp);
 };
 
 
 class NativeLoadFieldComp : public Computation {
  public:
   NativeLoadFieldComp(Value* value, intptr_t offset_in_bytes)
       : value_(value), offset_in_bytes_(offset_in_bytes) {
     ASSERT(value != NULL);
   }
 
   DECLARE_COMPUTATION(NativeLoadField)
 
   Value* value() const { return value_; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
 
  private:
   Value* value_;
   intptr_t offset_in_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeLoadFieldComp);
 };
 
 
 class ExtractFactoryTypeArgumentsComp : public Computation {
  public:
   ExtractFactoryTypeArgumentsComp(ConstructorCallNode* ast_node,
+                                  intptr_t try_index,
                                   Value* instantiator)
-      : ast_node_(*ast_node), instantiator_(instantiator) {
+      : ast_node_(*ast_node),
+        try_index_(try_index),
+        instantiator_(instantiator) {
     ASSERT(instantiator_ != NULL);
   }
 
   DECLARE_COMPUTATION(ExtractFactoryTypeArguments)
 
   Value* instantiator() const { return instantiator_; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& factory() const { return ast_node_.constructor(); }
   intptr_t node_id() const { return ast_node_.id(); }
   intptr_t token_index() const { return ast_node_.token_index(); }
+  intptr_t try_index() const { return try_index_; }
 
  private:
   const ConstructorCallNode& ast_node_;
+  const intptr_t try_index_;
   Value* instantiator_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractFactoryTypeArgumentsComp);
 };
 
 
 class ExtractConstructorTypeArgumentsComp : public Computation {
  public:
   ExtractConstructorTypeArgumentsComp(ConstructorCallNode* ast_node,
                                       Value* instantiator)
@@ skipping 45 matching lines @@
   const ConstructorCallNode& ast_node_;
   Value* instantiator_;
   Value* discard_value_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorComp);
 };
 
 
 class AllocateContextComp : public Computation {
  public:
-  AllocateContextComp(intptr_t token_index, intptr_t num_context_variables)
+  AllocateContextComp(intptr_t token_index,
+                      intptr_t try_index,
+                      intptr_t num_context_variables)
       : token_index_(token_index),
+        try_index_(try_index),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_COMPUTATION(AllocateContext);
 
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
  private:
   const intptr_t token_index_;
+  const intptr_t try_index_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextComp);
 };
 
 
 class ChainContextComp : public Computation {
  public:
   explicit ChainContextComp(Value* context_value)
       : context_value_(context_value) {
     ASSERT(context_value_ != NULL);
   }
 
   DECLARE_COMPUTATION(ChainContext)
 
   Value* context_value() const { return context_value_; }
 
  private:
   Value* context_value_;
 
   DISALLOW_COPY_AND_ASSIGN(ChainContextComp);
 };
 
 
 class CloneContextComp : public Computation {
  public:
   CloneContextComp(intptr_t node_id,
                    intptr_t token_index,
+                   intptr_t try_index,
                    Value* context_value)
       : node_id_(node_id),
         token_index_(token_index),
+        try_index_(try_index),
         context_value_(context_value) {
     ASSERT(context_value_ != NULL);
   }
 
   intptr_t node_id() const { return node_id_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   Value* context_value() const { return context_value_; }
 
   DECLARE_COMPUTATION(CloneContext)
 
  private:
   const intptr_t node_id_;
   const intptr_t token_index_;
+  const intptr_t try_index_;
   Value* context_value_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextComp);
 };
 
 
+class CatchEntryComp : public Computation {
+ public:
+  CatchEntryComp(const LocalVariable& exception_var,
+                 const LocalVariable& stacktrace_var)
+      : exception_var_(exception_var), stacktrace_var_(stacktrace_var) {}
+
+  const LocalVariable& exception_var() const { return exception_var_; }
+  const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
+
+  DECLARE_COMPUTATION(CatchEntry)
+
+ private:
+  const LocalVariable& exception_var_;
+  const LocalVariable& stacktrace_var_;
+
+  DISALLOW_COPY_AND_ASSIGN(CatchEntryComp);
+};
+
+
 #undef DECLARE_COMPUTATION
 
 
 // Instructions.
 //
 // <Instruction> ::= JoinEntry <Instruction>
 //                 | TargetEntry <Instruction>
 //                 | PickTemp <int> <int> <Instruction>
 //                 | TuckTemp <int> <int> <Instruction>
 //                 | Do <Computation> <Instruction>
@@ skipping 149 matching lines @@
   ZoneGrowableArray<BlockEntryInstr*> predecessors_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(JoinEntryInstr);
 };
 
 
 class TargetEntryInstr : public BlockEntryInstr {
  public:
   TargetEntryInstr()
-      : BlockEntryInstr(), predecessor_(NULL), successor_(NULL) { }
+      : BlockEntryInstr(),
+        predecessor_(NULL),
+        successor_(NULL),
+        try_index_(CatchClauseNode::kInvalidTryIndex) { }
+
+  // Used for exception catch entries.
+  explicit TargetEntryInstr(intptr_t try_index)
+      : BlockEntryInstr(),
+        predecessor_(NULL),
+        successor_(NULL),
+        try_index_(try_index) { }
 
   DECLARE_INSTRUCTION(TargetEntry)
 
   virtual intptr_t PredecessorCount() const {
     return (predecessor_ == NULL) ? 0 : 1;
   }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     ASSERT((index == 0) && (predecessor_ != NULL));
     return predecessor_;
   }
 
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
     successor_ = instr;
   }
 
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
       GrowableArray<BlockEntryInstr*>* preorder,
       GrowableArray<BlockEntryInstr*>* postorder,
       GrowableArray<intptr_t>* parent);
 
+  bool HasTryIndex() const {
+    return try_index_ != CatchClauseNode::kInvalidTryIndex;
+  }
+
+  intptr_t try_index() const {
+    ASSERT(HasTryIndex());
+    return try_index_;
+  }
+
  private:
   BlockEntryInstr* predecessor_;
   Instruction* successor_;
+  const intptr_t try_index_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetEntryInstr);
 };
 
 
 // The non-optimizing compiler assumes that there is exactly one use of
 // every temporary so they can be deallocated at their use.  Some AST nodes,
 // e.g., expr0[expr1]++, violate this assumption (there are two uses of each
 // of the values expr0 and expr1).
 //
@@ skipping 132 matching lines @@
  private:
   Value* value_;
   intptr_t token_index_;
 
   DISALLOW_COPY_AND_ASSIGN(ReturnInstr);
 };
 
 
 class ThrowInstr : public Instruction {
  public:
-  ThrowInstr(intptr_t node_id, intptr_t token_index, Value* exception)
+  ThrowInstr(intptr_t node_id,
+             intptr_t token_index,
+             intptr_t try_index,
+             Value* exception)
       : node_id_(node_id),
         token_index_(token_index),
+        try_index_(try_index),
         exception_(exception),
         successor_(NULL) {
     ASSERT(exception_ != NULL);
   }
 
   DECLARE_INSTRUCTION(Throw)
 
   intptr_t node_id() const { return node_id_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
 
   // Parser can generate a throw within an expression tree.
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
     successor_ = instr;
   }
 
  private:
-  intptr_t node_id_;
-  intptr_t token_index_;
+  const intptr_t node_id_;
+  const intptr_t token_index_;
+  const intptr_t try_index_;
   Value* exception_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ThrowInstr);
 };
 
 
 class ReThrowInstr : public Instruction {
  public:
   ReThrowInstr(intptr_t node_id,
               intptr_t token_index,
+              intptr_t try_index,
               Value* exception,
               Value* stack_trace)
       : node_id_(node_id),
         token_index_(token_index),
+        try_index_(try_index),
         exception_(exception),
         stack_trace_(stack_trace),
         successor_(NULL) {
     ASSERT(exception_ != NULL);
     ASSERT(stack_trace_ != NULL);
   }
 
   DECLARE_INSTRUCTION(ReThrow)
 
   intptr_t node_id() const { return node_id_; }
   intptr_t token_index() const { return token_index_; }
+  intptr_t try_index() const { return try_index_; }
   Value* exception() const { return exception_; }
   Value* stack_trace() const { return stack_trace_; }
 
   // Parser can generate a rethrow within an expression tree.
   virtual Instruction* StraightLineSuccessor() const {
     return successor_;
   }
   virtual void SetSuccessor(Instruction* instr) {
     ASSERT(successor_ == NULL);
     successor_ = instr;
   }
 
  private:
-  intptr_t node_id_;
-  intptr_t token_index_;
+  const intptr_t node_id_;
+  const intptr_t token_index_;
+  const intptr_t try_index_;
   Value* exception_;
   Value* stack_trace_;
   Instruction* successor_;
 
   DISALLOW_COPY_AND_ASSIGN(ReThrowInstr);
 };
 
 
 class BranchInstr : public Instruction {
  public:
@@ skipping 68 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_