More inlining flags and tuned heuristics.

runtime/vm/flow_graph_builder.cc

 // 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.
 
 #include "vm/flow_graph_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 144 matching lines @@
 
   // 3. Add a join or select one (or neither) of the arms as exit.
   if (true_exit == NULL) {
     exit_ = false_exit;  // May be NULL.
     if (false_exit != NULL) temp_index_ = false_fragment.temp_index();
   } else if (false_exit == NULL) {
     exit_ = true_exit;
     temp_index_ = true_fragment.temp_index();
   } else {
     JoinEntryInstr* join =
-        new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new JoinEntryInstr(owner()->AllocateBlockId(),
+                           owner()->try_index(),
+                           loop_depth());
     true_exit->Goto(join);
     false_exit->Goto(join);
     exit_ = join;
     ASSERT(true_fragment.temp_index() == false_fragment.temp_index());
     temp_index_ = true_fragment.temp_index();
   }
 }
 
 
 void EffectGraphVisitor::TieLoop(const TestGraphVisitor& test_fragment,
                                  const EffectGraphVisitor& body_fragment) {
   // We have: a test graph fragment with zero, one, or two available exits;
   // and an effect graph fragment with zero or one available exits.  We want
   // to append the 'while loop' consisting of the test graph fragment as
   // condition and the effect graph fragment as body.
   ASSERT(is_open());
 
   // 1. Connect the body to the test if it is reachable, and if so record
   // its exit (if any).
   BlockEntryInstr* body_entry = test_fragment.CreateTrueSuccessor();
   Instruction* body_exit = AppendFragment(body_entry, body_fragment);
 
   // 2. Connect the test to this graph, including the body if reachable and
   // using a fresh join node if the body is reachable and has an open exit.
   if (body_exit == NULL) {
     Append(test_fragment);
   } else {
     JoinEntryInstr* join =
-        new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new JoinEntryInstr(owner()->AllocateBlockId(),
+                           owner()->try_index(),
+                           loop_depth());
     join->LinkTo(test_fragment.entry());
     Goto(join);
     body_exit->Goto(join);
   }
 
   // 3. Set the exit to the graph to be the false successor of the test, a
   // fresh target node
 
   exit_ = test_fragment.CreateFalseSuccessor();
 }
@@ skipping 91 matching lines @@
   AddInstruction(new StoreContextInstr(load_saved_context));
 }
 
 
 void TestGraphVisitor::ConnectBranchesTo(
     const GrowableArray<TargetEntryInstr**>& branches,
     JoinEntryInstr* join) const {
   ASSERT(!branches.is_empty());
   for (intptr_t i = 0; i < branches.length(); i++) {
     TargetEntryInstr* target =
-        new TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new TargetEntryInstr(owner()->AllocateBlockId(),
+                             owner()->try_index(),
+                             loop_depth());
     *(branches[i]) = target;
     target->Goto(join);
   }
 }
 
 
 void TestGraphVisitor::IfTrueGoto(JoinEntryInstr* join) const {
   ConnectBranchesTo(true_successor_addresses_, join);
 }
 
 
 void TestGraphVisitor::IfFalseGoto(JoinEntryInstr* join) const {
   ConnectBranchesTo(false_successor_addresses_, join);
 }
 
 
 BlockEntryInstr* TestGraphVisitor::CreateSuccessorFor(
     const GrowableArray<TargetEntryInstr**>& branches) const {
   ASSERT(!branches.is_empty());
 
   if (branches.length() == 1) {
     TargetEntryInstr* target =
-        new TargetEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new TargetEntryInstr(owner()->AllocateBlockId(),
+                             owner()->try_index(),
+                             loop_depth());
     *(branches[0]) = target;
     return target;
   }
 
   JoinEntryInstr* join =
-      new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+      new JoinEntryInstr(owner()->AllocateBlockId(),
+                         owner()->try_index(),
+                         loop_depth());
   ConnectBranchesTo(branches, join);
   return join;
 }
 
 
 BlockEntryInstr* TestGraphVisitor::CreateTrueSuccessor() const {
   return CreateSuccessorFor(true_successor_addresses_);
 }
 
 
@@ skipping 72 matching lines @@
 }
 
 
 // Special handling for AND/OR.
 void TestGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     TestGraphVisitor for_left(owner(),
                               temp_index(),
+                              loop_depth(),
                               node->left()->token_pos());
     node->left()->Visit(&for_left);
 
     TestGraphVisitor for_right(owner(),
                                temp_index(),
+                               loop_depth(),
                                node->right()->token_pos());
     node->right()->Visit(&for_right);
 
     Append(for_left);
 
     if (node->kind() == Token::kAND) {
       AppendFragment(for_left.CreateTrueSuccessor(), for_right);
       true_successor_addresses_.AddArray(for_right.true_successor_addresses_);
       false_successor_addresses_.AddArray(for_left.false_successor_addresses_);
       false_successor_addresses_.AddArray(for_right.false_successor_addresses_);
@@ skipping 18 matching lines @@
 
 void EffectGraphVisitor::InlineBailout(const char* reason) {
   owner()->parsed_function().function().set_is_inlinable(false);
   if (owner()->InInliningContext()) owner()->Bailout(reason);
 }
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
-    EffectGraphVisitor for_effect(owner(), temp_index());
+    EffectGraphVisitor for_effect(owner(), temp_index(), loop_depth());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
 
   Value* return_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const Function& function = owner()->parsed_function().function();
     const bool is_implicit_dynamic_getter =
         (!function.is_static() &&
@@ skipping 104 matching lines @@
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   UNREACHABLE();
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->expr()->Visit(&for_value);
   Append(for_value);
   ReturnValue(BuildAssignableValue(node->expr()->token_pos(),
                                    for_value.value(),
                                    node->type(),
                                    node->dst_name()));
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression> }
 void EffectGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // See ValueGraphVisitor::VisitBinaryOpNode.
     TestGraphVisitor for_left(owner(),
                               temp_index(),
+                              loop_depth(),
                               node->left()->token_pos());
     node->left()->Visit(&for_left);
-    EffectGraphVisitor for_right(owner(), temp_index());
+    EffectGraphVisitor for_right(owner(), temp_index(), loop_depth());
     node->right()->Visit(&for_right);
-    EffectGraphVisitor empty(owner(), temp_index());
+    EffectGraphVisitor empty(owner(), temp_index(), loop_depth());
     if (node->kind() == Token::kAND) {
       Join(for_left, for_right, empty);
     } else {
       Join(for_left, empty, for_right);
     }
     return;
   }
-  ValueGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
 
-  ValueGraphVisitor for_right_value(owner(), temp_index());
+  ValueGraphVisitor for_right_value(owner(), temp_index(), loop_depth());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_left);
   arguments->Add(push_right);
   const String& name = String::ZoneHandle(Symbols::New(node->Name()));
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
@@ skipping 13 matching lines @@
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
     const Bool& bool_true = Bool::ZoneHandle(Bool::True());
     const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
     TestGraphVisitor for_test(owner(),
                               temp_index(),
+                              loop_depth(),
                               node->left()->token_pos());
     node->left()->Visit(&for_test);
 
-    ValueGraphVisitor for_right(owner(), temp_index());
+    ValueGraphVisitor for_right(owner(), temp_index(), loop_depth());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       right_value =
           for_right.Bind(new AssertBooleanInstr(node->right()->token_pos(),
                                                 right_value));
     }
     Value* constant_true = for_right.Bind(new ConstantInstr(bool_true));
     Value* compare =
         for_right.Bind(new StrictCompareInstr(Token::kEQ_STRICT,
                                               right_value,
                                               constant_true));
     for_right.Do(BuildStoreExprTemp(compare));
 
     if (node->kind() == Token::kAND) {
-      ValueGraphVisitor for_false(owner(), temp_index());
+      ValueGraphVisitor for_false(owner(), temp_index(), loop_depth());
       Value* constant_false = for_false.Bind(new ConstantInstr(bool_false));
       for_false.Do(BuildStoreExprTemp(constant_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
-      ValueGraphVisitor for_true(owner(), temp_index());
+      ValueGraphVisitor for_true(owner(), temp_index(), loop_depth());
       Value* constant_true = for_true.Bind(new ConstantInstr(bool_true));
       for_true.Do(BuildStoreExprTemp(constant_true));
       Join(for_test, for_true, for_right);
     }
     ReturnDefinition(BuildLoadExprTemp());
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
@@ skipping 64 matching lines @@
                                                 const String& dst_name) {
   if (CanSkipTypeCheck(token_pos, value, dst_type, dst_name)) {
     return value;
   }
   return Bind(BuildAssertAssignable(token_pos, value, dst_type, dst_name));
 }
 
 
 void EffectGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
-  EffectGraphVisitor for_left_value(owner(), temp_index());
+  EffectGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_value);
   const String& dst_name = String::ZoneHandle(
       Symbols::New(Exceptions::kCastErrorDstName));
   if (!CanSkipTypeCheck(node->token_pos(), for_value.value(), type, dst_name)) {
     Append(for_value);
     Do(BuildAssertAssignable(
         node->token_pos(), for_value.value(), type, dst_name));
   }
 }
 
 
 void ValueGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const bool negate_result = (node->kind() == Token::kISNOT);
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type = Type::Handle(Type::ObjectType());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type, NULL)) {
     // Must evaluate left side.
-    EffectGraphVisitor for_left_value(owner(), temp_index());
+    EffectGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ReturnDefinition(new ConstantInstr(negate_result ? bool_false : bool_true));
     return;
   }
 
   // Eliminate the test if it can be performed successfully at compile time.
   if ((node->left() != NULL) &&
       node->left()->IsLiteralNode() &&
       type.IsInstantiated()) {
@@ skipping 10 matching lines @@
       if (literal_value.IsInstanceOf(type, TypeArguments::Handle(), NULL)) {
         result = new ConstantInstr(negate_result ? bool_false : bool_true);
       } else {
         result = new ConstantInstr(negate_result ? bool_true : bool_false);
       }
     }
     ReturnDefinition(result);
     return;
   }
 
-  ValueGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   if (type.IsInstantiated()) {
     instantiator = BuildNullValue();
     instantiator_type_arguments = BuildNullValue();
   } else {
     BuildTypecheckArguments(node->token_pos(),
                             &instantiator,
                             &instantiator_type_arguments);
   }
   // TODO(zerny): Remove this when issues 5216 and 5217 are fixed.
   InlineBailout("instance of");
   InstanceOfInstr* instance_of =
       new InstanceOfInstr(node->token_pos(),
                           for_left_value.value(),
                           instantiator,
                           instantiator_type_arguments,
                           node->right()->AsTypeNode()->type(),
                           (node->kind() == Token::kISNOT));
   ReturnDefinition(instance_of);
 }
 
 
 void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
       Symbols::New(Exceptions::kCastErrorDstName));
   ReturnValue(BuildAssignableValue(node->token_pos(),
                                    for_value.value(),
                                    type,
                                    dst_name));
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 // TODO(srdjan): Implement new equality.
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsTypeTestOperator(node->kind())) {
     BuildTypeTest(node);
     return;
   }
   if (Token::IsTypeCastOperator(node->kind())) {
     BuildTypeCast(node);
     return;
   }
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
-    ValueGraphVisitor for_left_value(owner(), temp_index());
+    ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ValueGraphVisitor for_right_value(owner(), temp_index());
+    ValueGraphVisitor for_right_value(owner(), temp_index(), loop_depth());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     StrictCompareInstr* comp = new StrictCompareInstr(
         node->kind(), for_left_value.value(), for_right_value.value());
     ReturnDefinition(comp);
     return;
   }
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
-    ValueGraphVisitor for_left_value(owner(), temp_index());
+    ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ValueGraphVisitor for_right_value(owner(), temp_index());
+    ValueGraphVisitor for_right_value(owner(), temp_index(), loop_depth());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     if (FLAG_enable_type_checks) {
       EqualityCompareInstr* comp = new EqualityCompareInstr(
           node->token_pos(),
           Token::kEQ,
           for_left_value.value(),
           for_right_value.value());
       if (node->kind() == Token::kEQ) {
         ReturnDefinition(comp);
       } else {
         Value* eq_result = Bind(comp);
         eq_result = Bind(new AssertBooleanInstr(node->token_pos(), eq_result));
         ReturnDefinition(new BooleanNegateInstr(eq_result));
       }
     } else {
       EqualityCompareInstr* comp = new EqualityCompareInstr(
           node->token_pos(),
           node->kind(),
           for_left_value.value(),
           for_right_value.value());
       ReturnDefinition(comp);
     }
     return;
   }
 
-  ValueGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  ValueGraphVisitor for_right_value(owner(), temp_index());
+  ValueGraphVisitor for_right_value(owner(), temp_index(), loop_depth());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   RelationalOpInstr* comp = new RelationalOpInstr(node->token_pos(),
                                                   node->kind(),
                                                   for_left_value.value(),
                                                   for_right_value.value());
   ReturnDefinition(comp);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
-    ValueGraphVisitor for_value(owner(), temp_index());
+    ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       value =
           Bind(new AssertBooleanInstr(node->operand()->token_pos(), value));
     }
     BooleanNegateInstr* negate = new BooleanNegateInstr(value);
     ReturnDefinition(negate);
     return;
   }
 
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->operand()->Visit(&for_value);
   Append(for_value);
   PushArgumentInstr* push_value = PushArgument(for_value.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_value);
   InstanceCallInstr* call =
       new InstanceCallInstr(node->token_pos(),
                             String::ZoneHandle(
                                 Symbols::New(Token::Str(node->kind()))),
                             node->kind(),
                             arguments,
                             Array::ZoneHandle(),
                             1);
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
+                            loop_depth(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
   // Translate the subexpressions for their effects.
-  EffectGraphVisitor for_true(owner(), temp_index());
+  EffectGraphVisitor for_true(owner(), temp_index(), loop_depth());
   node->true_expr()->Visit(&for_true);
-  EffectGraphVisitor for_false(owner(), temp_index());
+  EffectGraphVisitor for_false(owner(), temp_index(), loop_depth());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
+                            loop_depth(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
-  ValueGraphVisitor for_true(owner(), temp_index());
+  ValueGraphVisitor for_true(owner(), temp_index(), loop_depth());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
   for_true.Do(BuildStoreExprTemp(for_true.value()));
 
-  ValueGraphVisitor for_false(owner(), temp_index());
+  ValueGraphVisitor for_false(owner(), temp_index(), loop_depth());
   node->false_expr()->Visit(&for_false);
   ASSERT(for_false.is_open());
   for_false.Do(BuildStoreExprTemp(for_false.value()));
 
   Join(for_test, for_true, for_false);
   ReturnDefinition(BuildLoadExprTemp());
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
+                            loop_depth(),
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
-  EffectGraphVisitor for_true(owner(), temp_index());
-  EffectGraphVisitor for_false(owner(), temp_index());
+  EffectGraphVisitor for_true(owner(), temp_index(), loop_depth());
+  EffectGraphVisitor for_false(owner(), temp_index(), loop_depth());
 
   node->true_branch()->Visit(&for_true);
   // The for_false graph fragment will be empty (default graph fragment) if
   // we do not call Visit.
   if (node->false_branch() != NULL) node->false_branch()->Visit(&for_false);
   Join(for_test, for_true, for_false);
 }
 
 
 void EffectGraphVisitor::VisitSwitchNode(SwitchNode* node) {
-  EffectGraphVisitor switch_body(owner(), temp_index());
+  EffectGraphVisitor switch_body(owner(), temp_index(), loop_depth());
   node->body()->Visit(&switch_body);
   Append(switch_body);
   if ((node->label() != NULL) && (node->label()->join_for_break() != NULL)) {
     if (is_open()) Goto(node->label()->join_for_break());
     exit_ = node->label()->join_for_break();
   }
   // No continue label allowed.
   ASSERT((node->label() == NULL) ||
          (node->label()->join_for_continue() == NULL));
 }
@@ skipping 16 matching lines @@
 //   g) case-statements-join
 //   h) [ case-statements ] -> exit-join
 //   i) exit-target -> exit-join
 //   j) exit-join
 //
 // Note: The specification of switch/case is under discussion and may change
 // drastically.
 void EffectGraphVisitor::VisitCaseNode(CaseNode* node) {
   const intptr_t len = node->case_expressions()->length();
   // Create case statements instructions.
-  EffectGraphVisitor for_case_statements(owner(), temp_index());
+  EffectGraphVisitor for_case_statements(owner(), temp_index(), loop_depth());
   // Compute start of statements fragment.
   JoinEntryInstr* statement_start = NULL;
   if ((node->label() != NULL) && node->label()->is_continue_target()) {
     // Since a labeled jump continue statement occur in a different case node,
     // allocate JoinNode here and use it as statement start.
     statement_start = node->label()->join_for_continue();
     if (statement_start == NULL) {
-      statement_start =
-          new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+      statement_start = new JoinEntryInstr(owner()->AllocateBlockId(),
+                                           owner()->try_index(),
+                                           loop_depth());
       node->label()->set_join_for_continue(statement_start);
     }
   } else {
-    statement_start =
-        new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+    statement_start = new JoinEntryInstr(owner()->AllocateBlockId(),
+                                         owner()->try_index(),
+                                         loop_depth());
   }
   node->statements()->Visit(&for_case_statements);
   Instruction* statement_exit =
       AppendFragment(statement_start, for_case_statements);
   if (is_open() && (len == 0)) {
     ASSERT(node->contains_default());
     // Default only case node.
     Goto(statement_start);
     exit_ = statement_exit;
     return;
   }
 
   // Generate instructions for all case expressions.
   TargetEntryInstr* next_target = NULL;
   for (intptr_t i = 0; i < len; i++) {
     AstNode* case_expr = node->case_expressions()->NodeAt(i);
     TestGraphVisitor for_case_expression(owner(),
                                          temp_index(),
+                                         loop_depth(),
                                          case_expr->token_pos());
     case_expr->Visit(&for_case_expression);
     if (i == 0) {
       // Append only the first one, everything else is connected from it.
       Append(for_case_expression);
     } else {
       ASSERT(next_target != NULL);
       AppendFragment(next_target, for_case_expression);
     }
     for_case_expression.IfTrueGoto(statement_start);
     next_target = for_case_expression.CreateFalseSuccessor()->AsTargetEntry();
   }
 
   // Once a test fragment has been added, this fragment is closed.
   ASSERT(!is_open());
 
   Instruction* exit_instruction = NULL;
   // Handle last (or only) case: false goes to exit or to statement if this
   // node contains default.
   if (len > 0) {
     ASSERT(next_target != NULL);
     if (node->contains_default()) {
       // True and false go to statement start.
       next_target->Goto(statement_start);
       exit_instruction = statement_exit;
     } else {
       if (statement_exit != NULL) {
         JoinEntryInstr* join = new JoinEntryInstr(owner()->AllocateBlockId(),
-                                                  owner()->try_index());
+                                                  owner()->try_index(),
+                                                  loop_depth());
         statement_exit->Goto(join);
         next_target->Goto(join);
         exit_instruction = join;
       } else {
         exit_instruction = next_target;
       }
     }
   } else {
     // A CaseNode without case expressions must contain default.
     ASSERT(node->contains_default());
@@ skipping 13 matching lines @@
 // a) loop-join
 // b) [ test ] -> (body-entry-target, loop-exit-target)
 // c) body-entry-target
 // d) [ body ] -> (continue-join)
 // e) continue-join -> (loop-join)
 // f) loop-exit-target
 // g) break-join (optional)
 void EffectGraphVisitor::VisitWhileNode(WhileNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
+                            loop_depth() + 1,
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(!for_test.is_empty());  // Language spec.
 
-  EffectGraphVisitor for_body(owner(), temp_index());
+  EffectGraphVisitor for_body(owner(), temp_index(), loop_depth() + 1);
   for_body.AddInstruction(
       new CheckStackOverflowInstr(node->token_pos()));
   node->body()->Visit(&for_body);
 
   // Labels are set after body traversal.
   SourceLabel* lbl = node->label();
   ASSERT(lbl != NULL);
   JoinEntryInstr* join = lbl->join_for_continue();
   if (join != NULL) {
     if (for_body.is_open()) for_body.Goto(join);
@@ skipping 11 matching lines @@
 // The fragment is composed as follows:
 // a) body-entry-join
 // b) [ body ]
 // c) test-entry (continue-join or body-exit-target)
 // d) [ test-entry ] -> (back-target, loop-exit-target)
 // e) back-target -> (body-entry-join)
 // f) loop-exit-target
 // g) break-join
 void EffectGraphVisitor::VisitDoWhileNode(DoWhileNode* node) {
   // Traverse body first in order to generate continue and break labels.
-  EffectGraphVisitor for_body(owner(), temp_index());
+  EffectGraphVisitor for_body(owner(), temp_index(), loop_depth() + 1);
   for_body.AddInstruction(
       new CheckStackOverflowInstr(node->token_pos()));
   node->body()->Visit(&for_body);
 
   TestGraphVisitor for_test(owner(),
                             temp_index(),
+                            loop_depth() + 1,
                             node->condition()->token_pos());
   node->condition()->Visit(&for_test);
   ASSERT(is_open());
 
   // Tie do-while loop (test is after the body).
   JoinEntryInstr* body_entry_join =
-      new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+      new JoinEntryInstr(owner()->AllocateBlockId(),
+                         owner()->try_index(),
+                         loop_depth() + 1);
   Goto(body_entry_join);
   Instruction* body_exit = AppendFragment(body_entry_join, for_body);
 
   JoinEntryInstr* join = node->label()->join_for_continue();
   if ((body_exit != NULL) || (join != NULL)) {
     if (join == NULL) {
-      join =
-          new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+      join = new JoinEntryInstr(owner()->AllocateBlockId(),
+                                owner()->try_index(),
+                                loop_depth() + 1);
     }
     join->LinkTo(for_test.entry());
     if (body_exit != NULL) {
       body_exit->Goto(join);
     }
   }
 
 
   for_test.IfTrueGoto(body_entry_join);
   if (node->label()->join_for_break() == NULL) {
@@ skipping 11 matching lines @@
 // a) [ initializer ]
 // b) loop-join
 // c) [ test ] -> (body-entry-target, loop-exit-target)
 // d) body-entry-target
 // e) [ body ]
 // f) continue-join (optional)
 // g) [ increment ] -> (loop-join)
 // h) loop-exit-target
 // i) break-join
 void EffectGraphVisitor::VisitForNode(ForNode* node) {
-  EffectGraphVisitor for_initializer(owner(), temp_index());
+  EffectGraphVisitor for_initializer(owner(), temp_index(), loop_depth());
   node->initializer()->Visit(&for_initializer);
   Append(for_initializer);
   ASSERT(is_open());
 
   // Compose body to set any jump labels.
-  EffectGraphVisitor for_body(owner(), temp_index());
+  EffectGraphVisitor for_body(owner(), temp_index(), loop_depth() + 1);
   for_body.AddInstruction(
       new CheckStackOverflowInstr(node->token_pos()));
   node->body()->Visit(&for_body);
 
   // Join loop body, increment and compute their end instruction.
   ASSERT(!for_body.is_empty());
   Instruction* loop_increment_end = NULL;
-  EffectGraphVisitor for_increment(owner(), temp_index());
+  EffectGraphVisitor for_increment(owner(), temp_index(), loop_depth() + 1);
   node->increment()->Visit(&for_increment);
   JoinEntryInstr* join = node->label()->join_for_continue();
   if (join != NULL) {
     // Insert the join between the body and increment.
     if (for_body.is_open()) for_body.Goto(join);
     loop_increment_end = AppendFragment(join, for_increment);
     ASSERT(loop_increment_end != NULL);
   } else if (for_body.is_open()) {
     // Do not insert an extra basic block.
     for_body.Append(for_increment);
     loop_increment_end = for_body.exit();
     // 'for_body' contains at least the stack check.
     ASSERT(loop_increment_end != NULL);
   } else {
     loop_increment_end = NULL;
   }
 
   // 'loop_increment_end' is NULL only if there is no join for continue and the
   // body is not open, i.e., no backward branch exists.
   if (loop_increment_end != NULL) {
     JoinEntryInstr* loop_start =
-        new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new JoinEntryInstr(owner()->AllocateBlockId(),
+                           owner()->try_index(),
+                           loop_depth() + 1);
     Goto(loop_start);
     loop_increment_end->Goto(loop_start);
     exit_ = loop_start;
   }
 
   if (node->condition() == NULL) {
     // Endless loop, no test.
     JoinEntryInstr* body_entry =
-        new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new JoinEntryInstr(owner()->AllocateBlockId(),
+                           owner()->try_index(),
+                           loop_depth() + 1);
     AppendFragment(body_entry, for_body);
     Goto(body_entry);
     if (node->label()->join_for_break() != NULL) {
       // Control flow of ForLoop continues into join_for_break.
       exit_ = node->label()->join_for_break();
     }
   } else {
     TestGraphVisitor for_test(owner(),
                               temp_index(),
+                              loop_depth() + 1,
                               node->condition()->token_pos());
     node->condition()->Visit(&for_test);
     Append(for_test);
 
     BlockEntryInstr* body_entry = for_test.CreateTrueSuccessor();
     AppendFragment(body_entry, for_body);
 
     if (node->label()->join_for_break() == NULL) {
       exit_ = for_test.CreateFalseSuccessor();
     } else {
       for_test.IfFalseGoto(node->label()->join_for_break());
       exit_ = node->label()->join_for_break();
     }
   }
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
-    EffectGraphVisitor for_effect(owner(), temp_index());
+    EffectGraphVisitor for_effect(owner(), temp_index(), loop_depth());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
 
   // Unchain the context(s) up to the outer context level of the scope which
   // contains the destination label.
   SourceLabel* label = node->label();
   ASSERT(label->owner() != NULL);
   int target_context_level = 0;
@@ skipping 17 matching lines @@
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= target_context_level);
   while (current_context_level-- > target_context_level) {
     UnchainContext();
   }
 
   JoinEntryInstr* jump_target = NULL;
   if (node->kind() == Token::kBREAK) {
     if (node->label()->join_for_break() == NULL) {
       node->label()->set_join_for_break(
-          new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index()));
+          new JoinEntryInstr(owner()->AllocateBlockId(),
+                             owner()->try_index(),
+                             loop_depth() - 1));  // Breaks out of a loop.
     }
     jump_target = node->label()->join_for_break();
   } else {
     if (node->label()->join_for_continue() == NULL) {
       node->label()->set_join_for_continue(
-          new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index()));
+          new JoinEntryInstr(owner()->AllocateBlockId(),
+                             owner()->try_index(),
+                             loop_depth()));  // Continue in same loop.
     }
     jump_target = node->label()->join_for_continue();
   }
   Goto(jump_target);
 }
 
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
 }
 
 
 void EffectGraphVisitor::VisitArgumentDefinitionTestNode(
     ArgumentDefinitionTestNode* node) {
   InlineBailout("EffectGraphVisitor::VisitArgumentDefinitionTestNode");
   Definition* load = BuildLoadLocal(node->saved_arguments_descriptor());
   Value* arguments_descriptor = Bind(load);
   ArgumentDefinitionTestInstr* arg_def_test =
       new ArgumentDefinitionTestInstr(node, arguments_descriptor);
   ReturnDefinition(arg_def_test);
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   // Translate the array elements and collect their values.
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->length());
   for (int i = 0; i < node->length(); ++i) {
-    ValueGraphVisitor for_value(owner(), temp_index());
+    ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     arguments->Add(PushArgument(for_value.value()));
   }
   const AbstractTypeArguments& type_args =
       AbstractTypeArguments::ZoneHandle(node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   CreateArrayInstr* create = new CreateArrayInstr(node->token_pos(),
                                                   arguments,
@@ skipping 13 matching lines @@
     if (function.context_scope() == ContextScope::null()) {
       // TODO(regis): Why are we not doing this in the parser?
       const ContextScope& context_scope = ContextScope::ZoneHandle(
           node->scope()->PreserveOuterScope(owner()->context_level()));
       ASSERT(!function.HasCode());
       ASSERT(function.context_scope() == ContextScope::null());
       function.set_context_scope(context_scope);
     }
     receiver = BuildNullValue();
   } else if (function.IsImplicitInstanceClosureFunction()) {
-    ValueGraphVisitor for_receiver(owner(), temp_index());
+    ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     receiver = for_receiver.value();
   } else {
     receiver = BuildNullValue();
   }
   PushArgumentInstr* push_receiver = PushArgument(receiver);
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_receiver);
@@ skipping 14 matching lines @@
   PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
   arguments->Add(push_type_arguments);
   ReturnDefinition(new CreateClosureInstr(node, arguments));
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
-    ValueGraphVisitor for_argument(owner(), temp_index());
+    ValueGraphVisitor for_argument(owner(), temp_index(), loop_depth());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     values->Add(for_argument.value());
   }
 }
 
 
 void EffectGraphVisitor::BuildPushArguments(
     const ArgumentListNode& node,
     ZoneGrowableArray<PushArgumentInstr*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
-    ValueGraphVisitor for_argument(owner(), temp_index());
+    ValueGraphVisitor for_argument(owner(), temp_index(), loop_depth());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
     PushArgumentInstr* push_arg = PushArgument(for_argument.value());
     values->Add(push_arg);
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
-  ValueGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(
           node->arguments()->length() + 1);
   arguments->Add(push_receiver);
 
   BuildPushArguments(*node->arguments(), arguments);
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
       node->function_name(), Token::kILLEGAL, arguments,
       node->arguments()->names(), 1);
   ReturnDefinition(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   if (node->function().name() == Symbols::Identical()) {
     // Attempt to replace identical with strcit equal early on.
     // TODO(hausner): Evaluate if this can happen at AST building time.
     const Class& cls = Class::Handle(node->function().Owner());
     if (cls.IsTopLevel()) {
       const Library& core_lib = Library::Handle(Library::CoreLibrary());
       if (cls.library() == core_lib.raw()) {
         ASSERT(node->arguments()->length() == 2);
-        ValueGraphVisitor for_left_value(owner(), temp_index());
+        ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
         node->arguments()->NodeAt(0)->Visit(&for_left_value);
         Append(for_left_value);
-        ValueGraphVisitor for_right_value(owner(), temp_index());
+        ValueGraphVisitor for_right_value(owner(), temp_index(), loop_depth());
         node->arguments()->NodeAt(1)->Visit(&for_right_value);
         Append(for_right_value);
         StrictCompareInstr* comp = new StrictCompareInstr(
             Token::kEQ_STRICT,
             for_left_value.value(),
             for_right_value.value());
         ReturnDefinition(comp);
         return;
       }
     }
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   BuildPushArguments(*node->arguments(), arguments);
   StaticCallInstr* call =
       new StaticCallInstr(node->token_pos(),
                           node->function(),
                           node->arguments()->names(),
                           arguments);
   ReturnDefinition(call);
 }
 
 
 ClosureCallInstr* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
-  ValueGraphVisitor for_closure(owner(), temp_index());
+  ValueGraphVisitor for_closure(owner(), temp_index(), loop_depth());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
   PushArgumentInstr* push_closure = PushArgument(for_closure.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   // Save context around the call.
@@ skipping 150 matching lines @@
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     return NULL;
   }
 
   ASSERT(owner()->parsed_function().instantiator() != NULL);
-  ValueGraphVisitor for_instantiator(owner(), temp_index());
+  ValueGraphVisitor for_instantiator(owner(), temp_index(), loop_depth());
   owner()->parsed_function().instantiator()->Visit(&for_instantiator);
   Append(for_instantiator);
   return for_instantiator.value();
 }
 
 
 // 'expression_temp_var' may not be used inside this method if 'instantiator'
 // is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
     intptr_t token_pos, Value* instantiator) {
@@ skipping 14 matching lines @@
   }
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // No instantiator for factories.
     ASSERT(instantiator == NULL);
     ASSERT(owner()->parsed_function().instantiator() != NULL);
-    ValueGraphVisitor for_instantiator(owner(), temp_index());
+    ValueGraphVisitor for_instantiator(owner(), temp_index(), loop_depth());
     owner()->parsed_function().instantiator()->Visit(&for_instantiator);
     Append(for_instantiator);
     return for_instantiator.value();
   }
   if (instantiator == NULL) {
     instantiator = BuildInstantiator();
   }
   // The instantiator is the receiver of the caller, which is not a factory.
   // The receiver cannot be null; extract its AbstractTypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
@@ skipping 127 matching lines @@
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
   Definition* load_allocated = BuildLoadLocal(
       node->allocated_object_var());
   allocated_value = Bind(load_allocated);
   ReturnValue(allocated_value);
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  ValueGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   arguments->Add(push_receiver);
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(), name, Token::kGET,
       arguments, Array::ZoneHandle(), 1);
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
-  ValueGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   arguments->Add(PushArgument(for_receiver.value()));
 
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
@@ skipping 37 matching lines @@
       String::Handle(Field::GetterName(node->field_name()));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle();
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     getter_function =
     Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
     ASSERT(!getter_function.IsNull());
     ASSERT(node->receiver() != NULL);
-    ValueGraphVisitor receiver_value(owner(), temp_index());
+    ValueGraphVisitor receiver_value(owner(), temp_index(), loop_depth());
     node->receiver()->Visit(&receiver_value);
     Append(receiver_value);
     arguments->Add(PushArgument(receiver_value.value()));
   } else {
     getter_function = node->cls().LookupStaticFunction(getter_name);
     if (getter_function.IsNull()) {
       // When the parser encounters a reference to a static field materialized
       // only by a static setter, but no corresponding static getter, it creates
       // a StaticGetterNode ast node referring to the non-existing static getter
       // for the case this field reference appears in a left hand side
@@ skipping 47 matching lines @@
   const Function& setter_function =
       Function::ZoneHandle(is_super_setter
           ? Resolver::ResolveDynamicAnyArgs(node->cls(), setter_name)
           : node->cls().LookupStaticFunction(setter_name));
   ASSERT(!setter_function.IsNull());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(1);
   if (is_super_setter) {
     // Add receiver of instance getter.
-    ValueGraphVisitor for_receiver(owner(), temp_index());
+    ValueGraphVisitor for_receiver(owner(), temp_index(), loop_depth());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     arguments->Add(PushArgument(for_receiver.value()));
   }
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
@@ skipping 29 matching lines @@
 
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   // PrimaryNodes are temporary during parsing.
   UNREACHABLE();
 }
 
 
 // <Expression> ::= LoadLocal { local: LocalVariable }
 void EffectGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   if (node->HasPseudo()) {
-    EffectGraphVisitor for_pseudo(owner(), temp_index());
+    EffectGraphVisitor for_pseudo(owner(), temp_index(), loop_depth());
     node->pseudo()->Visit(&for_pseudo);
     Append(for_pseudo);
   }
 }
 
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   EffectGraphVisitor::VisitLoadLocalNode(node);
   Definition* load = BuildLoadLocal(node->local());
   ReturnDefinition(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::HandleStoreLocal(StoreLocalNode* node,
                                           bool result_is_needed) {
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
   Definition* store = BuildStoreLocal(node->local(),
                                       store_value,
                                       result_is_needed);
   ReturnDefinition(store);
 }
 
 
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   HandleStoreLocal(node, kResultNotNeeded);
 }
 
 
 void ValueGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   HandleStoreLocal(node, kResultNeeded);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
-  ValueGraphVisitor for_instance(owner(), temp_index());
+  ValueGraphVisitor for_instance(owner(), temp_index(), loop_depth());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadFieldInstr* load = new LoadFieldInstr(
       for_instance.value(),
       node->field().Offset(),
       AbstractType::ZoneHandle(node->field().type()));
   ReturnDefinition(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
-  ValueGraphVisitor for_instance(owner(), temp_index());
+  ValueGraphVisitor for_instance(owner(), temp_index(), loop_depth());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
-  ValueGraphVisitor for_value(owner(), for_instance.temp_index());
+  ValueGraphVisitor for_value(owner(), for_instance.temp_index(), loop_depth());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
@@ skipping 13 matching lines @@
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   LoadStaticFieldInstr* load = new LoadStaticFieldInstr(node->field());
   ReturnDefinition(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreStaticField(
   StoreStaticFieldNode* node, bool result_is_needed) {
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = NULL;
   if (result_is_needed) {
     store_value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     store_value = for_value.value();
   }
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
@@ skipping 21 matching lines @@
 
 
 void ValueGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ReturnDefinition(BuildStoreStaticField(node, kResultNeeded));
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
-  ValueGraphVisitor for_array(owner(), temp_index());
+  ValueGraphVisitor for_array(owner(), temp_index(), loop_depth());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
-  ValueGraphVisitor for_index(owner(), temp_index());
+  ValueGraphVisitor for_index(owner(), temp_index(), loop_depth());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   const intptr_t checked_argument_count = 1;
   const String& name =
       String::ZoneHandle(Symbols::New(Token::Str(Token::kINDEX)));
   InstanceCallInstr* load = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   Token::kINDEX,
                                                   arguments,
                                                   Array::ZoneHandle(),
                                                   checked_argument_count);
   ReturnDefinition(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreIndexedValues(
     StoreIndexedNode* node,
     bool result_is_needed) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
-  ValueGraphVisitor for_array(owner(), temp_index());
+  ValueGraphVisitor for_array(owner(), temp_index(), loop_depth());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
-  ValueGraphVisitor for_index(owner(), temp_index());
+  ValueGraphVisitor for_index(owner(), temp_index(), loop_depth());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner(), temp_index(), loop_depth());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* value = NULL;
   if (result_is_needed) {
     value = Bind(BuildStoreExprTemp(for_value.value()));
   } else {
     value = for_value.value();
   }
   arguments->Add(PushArgument(value));
 
@@ skipping 145 matching lines @@
         // variable so that ssa renaming detects the dependency and makes use
         // of the checked type in type propagation.
         Do(BuildStoreLocal(parameter, parameter_value, kResultNotNeeded));
       }
       pos++;
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
-    EffectGraphVisitor for_effect(owner(), temp_index());
+    EffectGraphVisitor for_effect(owner(), temp_index(), loop_depth());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
     }
   }
 
   if (is_open()) {
     if (MustSaveRestoreContext(node)) {
@@ skipping 24 matching lines @@
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCatchClauseNode (exception)");
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restores CTX from local variable ':saved_context'.
   AddInstruction(
       new CatchEntryInstr(node->exception_var(), node->stacktrace_var()));
   BuildLoadContext(node->context_var());
 
-  EffectGraphVisitor for_catch(owner(), temp_index());
+  EffectGraphVisitor for_catch(owner(), temp_index(), loop_depth());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   InlineBailout("EffectGraphVisitor::VisitTryCatchNode (exception)");
   intptr_t old_try_index = owner()->try_index();
   intptr_t try_index = owner()->AllocateTryIndex();
   owner()->set_try_index(try_index);
 
   // Preserve CTX into local variable '%saved_context'.
   BuildStoreContext(node->context_var());
 
-  EffectGraphVisitor for_try_block(owner(), temp_index());
+  EffectGraphVisitor for_try_block(owner(), temp_index(), loop_depth());
   node->try_block()->Visit(&for_try_block);
 
   if (for_try_block.is_open()) {
     JoinEntryInstr* after_try =
-        new JoinEntryInstr(owner()->AllocateBlockId(), old_try_index);
+        new JoinEntryInstr(owner()->AllocateBlockId(),
+                           old_try_index,
+                           loop_depth());
     for_try_block.Goto(after_try);
     for_try_block.exit_ = after_try;
   }
 
   JoinEntryInstr* try_entry =
-      new JoinEntryInstr(owner()->AllocateBlockId(), try_index);
+      new JoinEntryInstr(owner()->AllocateBlockId(), try_index, loop_depth());
 
   Goto(try_entry);
   AppendFragment(try_entry, for_try_block);
   exit_ = for_try_block.exit_;
 
   // We are done generating code for the try block.
   owner()->set_try_index(old_try_index);
 
   CatchClauseNode* catch_block = node->catch_block();
   if (catch_block != NULL) {
     // Set the corresponding try index for this catch block so
     // that we can set the appropriate handler pc when we generate
     // code for this catch block.
     catch_block->set_try_index(try_index);
-    EffectGraphVisitor for_catch_block(owner(), temp_index());
+    EffectGraphVisitor for_catch_block(owner(), temp_index(), loop_depth());
     catch_block->Visit(&for_catch_block);
     TargetEntryInstr* catch_entry =
-        new TargetEntryInstr(owner()->AllocateBlockId(), old_try_index);
+        new TargetEntryInstr(owner()->AllocateBlockId(),
+                             old_try_index,
+                             loop_depth());
     catch_entry->set_catch_try_index(try_index);
     owner()->AddCatchEntry(catch_entry);
     ASSERT(!for_catch_block.is_open());
     AppendFragment(catch_entry, for_catch_block);
     if (node->end_catch_label() != NULL) {
       JoinEntryInstr* join = node->end_catch_label()->join_for_continue();
       if (join != NULL) {
         if (is_open()) Goto(join);
         exit_ = join;
       }
     }
   }
 
   // Generate code for the finally block if one exists.
   if ((node->finally_block() != NULL) && is_open()) {
-    EffectGraphVisitor for_finally_block(owner(), temp_index());
+    EffectGraphVisitor for_finally_block(owner(), temp_index(), loop_depth());
     node->finally_block()->Visit(&for_finally_block);
     Append(for_finally_block);
   }
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   // TODO(kmillikin) non-local control flow is not handled correctly
   // by the inliner.
   InlineBailout("EffectGraphVisitor::BuildThrowNode (exception)");
-  ValueGraphVisitor for_exception(owner(), temp_index());
+  ValueGraphVisitor for_exception(owner(), temp_index(), loop_depth());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
     instr = new ThrowInstr(node->token_pos());
   } else {
-    ValueGraphVisitor for_stack_trace(owner(), temp_index());
+    ValueGraphVisitor for_stack_trace(owner(), temp_index(), loop_depth());
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
     PushArgument(for_stack_trace.value());
     instr = new ReThrowInstr(node->token_pos());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
@@ skipping 16 matching lines @@
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     owner()->set_try_index((try_index - 1));
   }
   BuildLoadContext(node->context_var());
 
   JoinEntryInstr* finally_entry =
-      new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
-  EffectGraphVisitor for_finally_block(owner(), temp_index());
+      new JoinEntryInstr(owner()->AllocateBlockId(),
+                         owner()->try_index(),
+                         loop_depth());
+  EffectGraphVisitor for_finally_block(owner(), temp_index(), loop_depth());
   node->finally_block()->Visit(&for_finally_block);
 
   if (try_index >= 0) {
     owner()->set_try_index(try_index);
   }
 
   if (for_finally_block.is_open()) {
     JoinEntryInstr* after_finally =
-        new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
+        new JoinEntryInstr(owner()->AllocateBlockId(),
+                           owner()->try_index(),
+                           loop_depth());
     for_finally_block.Goto(after_finally);
     for_finally_block.exit_ = after_finally;
   }
 
   Goto(finally_entry);
   AppendFragment(finally_entry, for_finally_block);
   exit_ = for_finally_block.exit_;
 }
 
 
-FlowGraph* FlowGraphBuilder::BuildGraph(InliningContext context) {
+FlowGraph* FlowGraphBuilder::BuildGraph(InliningContext context,
+                                        intptr_t initial_loop_depth) {
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
     AstPrinter::PrintFunctionNodes(parsed_function());
   }
   // Set the inlining context.
   ASSERT(inlining_context_ == kNotInlining);
   inlining_context_ = context;
   if (InInliningContext()) exits_ = new ZoneGrowableArray<ReturnInstr*>();
   // Compilation can be nested, preserve the computation-id.
   const Function& function = parsed_function().function();
   TargetEntryInstr* normal_entry =
       new TargetEntryInstr(AllocateBlockId(),
-                           CatchClauseNode::kInvalidTryIndex);
+                           CatchClauseNode::kInvalidTryIndex,
+                           initial_loop_depth);
   graph_entry_ = new GraphEntryInstr(normal_entry);
-  EffectGraphVisitor for_effect(this, 0);
+  EffectGraphVisitor for_effect(this, 0, initial_loop_depth);
   if (InInliningContext()) {
     exits_ = new ZoneGrowableArray<ReturnInstr*>();
   }
   // TODO(kmillikin): We can eliminate stack checks in some cases (e.g., the
   // stack check on entry for leaf routines).
   Instruction* check = new CheckStackOverflowInstr(function.token_pos());
   // If we are inlining don't actually attach the stack check. We must still
   // create the stack check inorder to allocate a deopt id.
   if (!InInliningContext()) for_effect.AddInstruction(check);
   parsed_function().node_sequence()->Visit(&for_effect);
@@ skipping 12 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart