Move temp_index from the graph visitors to the graph builder.

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 "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
-#include "vm/code_descriptors.h"
-#include "vm/dart_entry.h"
+#include "vm/class_finalizer.h"
+#include "vm/exceptions.h"
 #include "vm/flags.h"
+#include "vm/flow_graph.h"
 #include "vm/flow_graph_compiler.h"
+#include "vm/heap.h"
 #include "vm/il_printer.h"
 #include "vm/intermediate_language.h"
+#include "vm/isolate.h"
 #include "vm/longjump.h"
-#include "vm/object_store.h"
+#include "vm/object.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 #include "vm/resolver.h"
+#include "vm/scopes.h"
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
+#include "vm/token.h"
+#include "vm/zone.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, eliminate_type_checks, true,
             "Eliminate type checks when allowed by static type analysis.");
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DEFINE_FLAG(bool, print_flow_graph_optimized, false,
             "Print the IR flow graph when optimizing.");
@@ skipping 15 matching lines @@
         : 0),
     num_stack_locals_(parsed_function->num_stack_locals()),
     exit_collector_(exit_collector),
     guarded_fields_(new ZoneGrowableArray<const Field*>()),
     last_used_block_id_(0),  // 0 is used for the graph entry.
     context_level_(0),
     try_index_(CatchClauseNode::kInvalidTryIndex),
     catch_try_index_(CatchClauseNode::kInvalidTryIndex),
     loop_depth_(0),
     graph_entry_(NULL),
+    temp_count_(0),
     args_pushed_(0),
     osr_id_(osr_id) { }
 
 
 void FlowGraphBuilder::AddCatchEntry(CatchBlockEntryInstr* entry) {
   graph_entry_->AddCatchEntry(entry);
 }
 
 
 void InlineExitCollector::PrepareGraphs(FlowGraph* callee_graph) {
@@ skipping 276 matching lines @@
   }
   call_->UnuseAllInputs();
 }
 
 
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
   if (is_empty()) {
     entry_ = other_fragment.entry();
-    exit_ = other_fragment.exit();
   } else {
     exit()->LinkTo(other_fragment.entry());
-    exit_ = other_fragment.exit();
   }
-  temp_index_ = other_fragment.temp_index();
+  exit_ = other_fragment.exit();
 }
 
 
 Value* EffectGraphVisitor::Bind(Definition* definition) {
   ASSERT(is_open());
-  DeallocateTempIndex(definition->InputCount());
+  owner()->DeallocateTemps(definition->InputCount());
+  owner()->add_args_pushed(-definition->ArgumentCount());
   definition->set_use_kind(Definition::kValue);
-  definition->set_temp_index(AllocateTempIndex());
-  owner_->add_args_pushed(-definition->ArgumentCount());
+  definition->set_temp_index(owner()->AllocateTemp());
   if (is_empty()) {
     entry_ = definition;
   } else {
     exit()->LinkTo(definition);
   }
   exit_ = definition;
   return new Value(definition);
 }
 
 
 void EffectGraphVisitor::Do(Definition* definition) {
   ASSERT(is_open());
-  DeallocateTempIndex(definition->InputCount());
+  owner()->DeallocateTemps(definition->InputCount());
+  owner()->add_args_pushed(-definition->ArgumentCount());
   definition->set_use_kind(Definition::kEffect);
-  owner_->add_args_pushed(-definition->ArgumentCount());
   if (is_empty()) {
     entry_ = definition;
   } else {
     exit()->LinkTo(definition);
   }
   exit_ = definition;
 }
 
 
 void EffectGraphVisitor::AddInstruction(Instruction* instruction) {
   ASSERT(is_open());
   ASSERT(instruction->IsPushArgument() || !instruction->IsDefinition());
   ASSERT(!instruction->IsBlockEntry());
-  DeallocateTempIndex(instruction->InputCount());
-  owner_->add_args_pushed(-instruction->ArgumentCount());
+  owner()->DeallocateTemps(instruction->InputCount());
+  owner()->add_args_pushed(-instruction->ArgumentCount());
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     exit()->LinkTo(instruction);
     exit_ = instruction;
   }
 }
 
 
 void EffectGraphVisitor::AddReturnExit(intptr_t token_pos, Value* value) {
@@ skipping 50 matching lines @@
   // (if any).
   BlockEntryInstr* true_entry = test_fragment.CreateTrueSuccessor();
   Instruction* true_exit = AppendFragment(true_entry, true_fragment);
 
   BlockEntryInstr* false_entry = test_fragment.CreateFalseSuccessor();
   Instruction* false_exit = AppendFragment(false_entry, false_fragment);
 
   // 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());
     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(intptr_t token_pos,
                                  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
@@ skipping 243 matching lines @@
   }
   ReturnValue(Bind(definition));
 }
 
 
 // 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(),
-                              node->left()->token_pos());
+    TestGraphVisitor for_left(owner(), node->left()->token_pos());
     node->left()->Visit(&for_left);
 
-    TestGraphVisitor for_right(owner(),
-                               temp_index(),
-                               node->right()->token_pos());
+    TestGraphVisitor for_right(owner(), 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_);
     } else {
@@ skipping 17 matching lines @@
 
 void EffectGraphVisitor::InlineBailout(const char* reason) {
   owner()->parsed_function()->function().set_is_inlinable(false);
   if (owner()->IsInlining()) 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());
   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());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
-    if (!is_open()) return;
+    if (!is_open()) {
+      owner()->DeallocateTemps(owner()->temp_count());
+      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() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kImplicitStaticFinalGetter)));
     // Implicit getters do not need a type check at return, unless they compute
@@ skipping 106 matching lines @@
                                      eliminated);
   }
   return eliminated;
 }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
 void EffectGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner());
   node->expr()->Visit(&for_value);
   Append(for_value);
   Definition* checked_value;
   if (CanSkipTypeCheck(node->expr()->token_pos(),
                        for_value.value(),
                        node->type(),
                        node->dst_name())) {
     // Drop the value and 0 additional temporaries.
     checked_value = new DropTempsInstr(0, for_value.value());
   } else {
     checked_value = BuildAssertAssignable(node->expr()->token_pos(),
                                           for_value.value(),
                                           node->type(),
                                           node->dst_name());
   }
   ReturnDefinition(checked_value);
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner());
   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(),
-                              node->left()->token_pos());
+    TestGraphVisitor for_left(owner(), node->left()->token_pos());
     node->left()->Visit(&for_left);
-    EffectGraphVisitor empty(owner(), temp_index());
+    EffectGraphVisitor empty(owner());
     if (FLAG_enable_type_checks) {
-      ValueGraphVisitor for_right(owner(), temp_index());
+      ValueGraphVisitor for_right(owner());
       node->right()->Visit(&for_right);
       Value* right_value = for_right.value();
       for_right.Do(new AssertBooleanInstr(node->right()->token_pos(),
                                           right_value));
       if (node->kind() == Token::kAND) {
         Join(for_left, for_right, empty);
       } else {
         Join(for_left, empty, for_right);
       }
     } else {
-      EffectGraphVisitor for_right(owner(), temp_index());
+      EffectGraphVisitor for_right(owner());
       node->right()->Visit(&for_right);
       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());
   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());
   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->TokenName()));
   const intptr_t kNumArgsChecked = 2;
@@ skipping 11 matching lines @@
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   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;
 
-    TestGraphVisitor for_test(owner(),
-                              temp_index(),
-                              node->left()->token_pos());
+    TestGraphVisitor for_test(owner(), node->left()->token_pos());
     node->left()->Visit(&for_test);
 
-    ValueGraphVisitor for_right(owner(), temp_index());
+    ValueGraphVisitor for_right(owner());
     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(node->token_pos(),
                                               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());
       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());
       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);
 }
 
 
 static const String& BinaryOpAndMaskName(BinaryOpNode* node) {
   if (node->kind() == Token::kSHL) {
     return Library::PrivateCoreLibName(Symbols::_leftShiftWithMask32());
   }
   UNIMPLEMENTED();
   return String::ZoneHandle();
 }
 
 
 // <Expression> :: BinaryOp { kind:  Token::Kind
 //                            left:  <Expression>
 //                            right: <Expression>
 //                            mask32: constant }
 void EffectGraphVisitor::VisitBinaryOpWithMask32Node(
     BinaryOpWithMask32Node* node) {
   ASSERT((node->kind() != Token::kAND) && (node->kind() != Token::kOR));
-  ValueGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor for_left_value(owner());
   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());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
 
   Value* mask_value = Bind(new ConstantInstr(
       Integer::ZoneHandle(Integer::New(node->mask32(), Heap::kOld))));
   PushArgumentInstr* push_mask = PushArgument(mask_value);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
@@ skipping 107 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());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
 }
 
 
 void ValueGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
   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());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ReturnDefinition(new ConstantInstr(Bool::Get(!negate_result)));
     return;
   }
 
   // Eliminate the test if it can be performed successfully at compile time.
   if ((node->left() != NULL) &&
       node->left()->IsLiteralNode() &&
       type.IsInstantiated()) {
     const Instance& literal_value = node->left()->AsLiteralNode()->literal();
     ConstantInstr* result = NULL;
 
     Error& malformed_error = Error::Handle();
     if (literal_value.IsInstanceOf(type,
                                    TypeArguments::Handle(),
                                    &malformed_error)) {
       result = new ConstantInstr(Bool::Get(!negate_result));
     } else {
       result = new ConstantInstr(Bool::Get(negate_result));
     }
     ASSERT(malformed_error.IsNull());
 
     ReturnDefinition(result);
     return;
   }
 
-  ValueGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   PushArgumentInstr* push_instantiator = NULL;
   PushArgumentInstr* push_type_args = NULL;
   if (type.IsInstantiated()) {
     push_instantiator = PushArgument(BuildNullValue());
     push_type_args = PushArgument(BuildNullValue());
   } else {
     BuildTypecheckPushArguments(node->token_pos(),
@@ skipping 22 matching lines @@
       kNumArgsChecked,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
       Symbols::New(Exceptions::kCastErrorDstName));
   if (CanSkipTypeCheck(node->token_pos(), for_value.value(), type, dst_name)) {
     // Drop the value and 0 additional temporaries.
     Do(new DropTempsInstr(0, for_value.value()));
   } else {
     Do(BuildAssertAssignable(node->token_pos(),
                              for_value.value(),
                              type,
                              dst_name));
   }
 }
 
 
 void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed() && !type.IsMalbounded());
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
       Symbols::New(Exceptions::kCastErrorDstName));
   if (CanSkipTypeCheck(node->token_pos(),
                        for_value.value(),
                        type,
                        dst_name)) {
     ReturnValue(for_value.value());
     return;
@@ skipping 37 matching lines @@
   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());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ValueGraphVisitor for_right_value(owner(), temp_index());
+    ValueGraphVisitor for_right_value(owner());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     StrictCompareInstr* comp = new StrictCompareInstr(node->token_pos(),
                                                       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());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ValueGraphVisitor for_right_value(owner(), temp_index());
+    ValueGraphVisitor for_right_value(owner());
     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(),
           owner()->ic_data_array());
       if (node->kind() == Token::kEQ) {
@@ skipping 11 matching lines @@
           for_right_value.value(),
           owner()->ic_data_array());
       ReturnDefinition(comp);
     }
     return;
   }
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
 
-  ValueGraphVisitor for_left_value(owner(), temp_index());
+  ValueGraphVisitor for_left_value(owner());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
   arguments->Add(push_left);
 
-  ValueGraphVisitor for_right_value(owner(), temp_index());
+  ValueGraphVisitor for_right_value(owner());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   PushArgumentInstr* push_right = PushArgument(for_right_value.value());
   arguments->Add(push_right);
 
   ASSERT(Token::IsRelationalOperator(node->kind()));
   InstanceCallInstr* comp =
       new InstanceCallInstr(node->token_pos(),
                             String::ZoneHandle(Symbols::New(node->TokenName())),
                             node->kind(),
                             arguments,
                             Object::null_array(),
                             2,
                             owner()->ic_data_array());
   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());
     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());
   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(node->TokenName())),
                             node->kind(),
                             arguments,
                             Object::null_array(),
                             1,
                             owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  TestGraphVisitor for_test(owner(),
-                            temp_index(),
-                            node->condition()->token_pos());
+  TestGraphVisitor for_test(owner(), 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());
   node->true_expr()->Visit(&for_true);
-  EffectGraphVisitor for_false(owner(), temp_index());
+  EffectGraphVisitor for_false(owner());
   node->false_expr()->Visit(&for_false);
 
   Join(for_test, for_true, for_false);
 }
 
 
 void ValueGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
-  TestGraphVisitor for_test(owner(),
-                            temp_index(),
-                            node->condition()->token_pos());
+  TestGraphVisitor for_test(owner(), node->condition()->token_pos());
   node->condition()->Visit(&for_test);
 
-  ValueGraphVisitor for_true(owner(), temp_index());
+  ValueGraphVisitor for_true(owner());
   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());
   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(),
-                            node->condition()->token_pos());
+  TestGraphVisitor for_test(owner(), 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());
+  EffectGraphVisitor for_false(owner());
 
   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());
   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());
   // 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());
       node->label()->set_join_for_continue(statement_start);
@@ skipping 10 matching lines @@
     // 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(),
-                                         case_expr->token_pos());
+    TestGraphVisitor for_case_expression(owner(), 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();
@@ skipping 40 matching lines @@
 // The fragment is composed as follows:
 // 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) {
   owner()->IncrementLoopDepth();
-  TestGraphVisitor for_test(owner(),
-                            temp_index(),
-                            node->condition()->token_pos());
+  TestGraphVisitor for_test(owner(), 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());
   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);
     for_body.exit_ = join;
   }
@@ skipping 11 matching lines @@
 // 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) {
   owner()->IncrementLoopDepth();
   // Traverse body first in order to generate continue and break labels.
-  EffectGraphVisitor for_body(owner(), temp_index());
+  EffectGraphVisitor for_body(owner());
   node->body()->Visit(&for_body);
 
-  TestGraphVisitor for_test(owner(),
-                            temp_index(),
-                            node->condition()->token_pos());
+  TestGraphVisitor for_test(owner(), 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());
   Goto(body_entry_join);
   Instruction* body_exit = AppendFragment(body_entry_join, for_body);
 
@@ skipping 30 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());
   node->initializer()->Visit(&for_initializer);
   Append(for_initializer);
   ASSERT(is_open());
 
   owner()->IncrementLoopDepth();
   // Compose body to set any jump labels.
-  EffectGraphVisitor for_body(owner(), temp_index());
+  EffectGraphVisitor for_body(owner());
   node->body()->Visit(&for_body);
 
-  EffectGraphVisitor for_increment(owner(), temp_index());
+  EffectGraphVisitor for_increment(owner());
   node->increment()->Visit(&for_increment);
 
   // Join the loop body and increment and then tie the loop.
   JoinEntryInstr* continue_join = node->label()->join_for_continue();
   if ((continue_join != NULL) || for_body.is_open()) {
     JoinEntryInstr* loop_entry =
         new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
     if (continue_join != NULL) {
       if (for_body.is_open()) for_body.Goto(continue_join);
       Instruction* current = AppendFragment(continue_join, for_increment);
       current->Goto(loop_entry);
     } else {
       for_body.Append(for_increment);
       for_body.Goto(loop_entry);
     }
     Goto(loop_entry);
     exit_ = loop_entry;
     AddInstruction(
         new CheckStackOverflowInstr(node->token_pos(), owner()->loop_depth()));
   }
 
   if (node->condition() == NULL) {
     // Endless loop, no test.
     Append(for_body);
     exit_ = node->label()->join_for_break();  // May be NULL.
   } else {
-    TestGraphVisitor for_test(owner(),
-                              temp_index(),
-                              node->condition()->token_pos());
+    TestGraphVisitor for_test(owner(), 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();
     }
   }
   owner()->DecrementLoopDepth();
 }
 
 
 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());
     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 41 matching lines @@
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
 }
 
 
 intptr_t EffectGraphVisitor::GetCurrentTempLocalIndex() const {
   return kFirstLocalSlotFromFp
       - owner()->num_stack_locals()
       - owner()->num_copied_params()
       - owner()->args_pushed()
-      - temp_index() + 1;
+      - owner()->temp_count() + 1;
 }
 
 
 LocalVariable* EffectGraphVisitor::EnterTempLocalScope(Value* value) {
   Do(new PushTempInstr(value));
-  AllocateTempIndex();
+  owner()->AllocateTemp();
 
-  ASSERT(value->definition()->temp_index() == temp_index() - 1);
+  ASSERT(value->definition()->temp_index() == owner()->temp_count());
   intptr_t index = GetCurrentTempLocalIndex();
   char name[64];
   OS::SNPrint(name, 64, ":tmp_local%" Pd, index);
   LocalVariable*  var =
       new LocalVariable(0,
                         String::ZoneHandle(Symbols::New(name)),
                         *value->Type()->ToAbstractType());
   var->set_index(index);
   return var;
 }
 
 
 Definition* EffectGraphVisitor::ExitTempLocalScope(LocalVariable* var) {
     Value* tmp = Bind(new LoadLocalInstr(*var));
-    DeallocateTempIndex(1);
+    owner()->DeallocateTemps(1);
     ASSERT(GetCurrentTempLocalIndex() == var->index());
     return new DropTempsInstr(1, tmp);
 }
 
 
 void EffectGraphVisitor::BuildLetTempExpressions(LetNode* node) {
   intptr_t num_temps = node->num_temps();
   for (intptr_t i = 0; i < num_temps; ++i) {
-    ValueGraphVisitor for_value(owner(), temp_index());
+    ValueGraphVisitor for_value(owner());
     node->InitializerAt(i)->Visit(&for_value);
     Append(for_value);
     Value* temp_val = for_value.value();
     node->TempAt(i)->set_index(GetCurrentTempLocalIndex());
     Do(new PushTempInstr(temp_val));
-    AllocateTempIndex();
+    owner()->AllocateTemp();
   }
 }
 
 
 void EffectGraphVisitor::VisitLetNode(LetNode* node) {
   intptr_t num_temps = node->num_temps();
   if (num_temps > 0) {
     BuildLetTempExpressions(node);
     // TODO(fschneider): Generate better code for effect context by visiting the
     // body for effect. Currently, the value of the body expression is
     // materialized and then dropped. This also requires changing DropTempsInstr
     // to have zero or one inputs.
 
     // Visit body.
     for (intptr_t i = 0; i < node->nodes().length() - 1; ++i) {
-      EffectGraphVisitor for_effect(owner(), temp_index());
+      EffectGraphVisitor for_effect(owner());
       node->nodes()[i]->Visit(&for_effect);
       Append(for_effect);
     }
     // Visit the last body expression for value.
-    ValueGraphVisitor for_value(owner(), temp_index());
+    ValueGraphVisitor for_value(owner());
     node->nodes().Last()->Visit(&for_value);
     Append(for_value);
     Value* result_value = for_value.value();
-    DeallocateTempIndex(num_temps);
+    owner()->DeallocateTemps(num_temps);
     Do(new DropTempsInstr(num_temps, result_value));
   } else {
     ASSERT(num_temps == 0);
     for (intptr_t i = 0; i < node->nodes().length(); ++i) {
-      EffectGraphVisitor for_effect(owner(), temp_index());
+      EffectGraphVisitor for_effect(owner());
       node->nodes()[i]->Visit(&for_effect);
       Append(for_effect);
     }
   }
 }
 
 
 void ValueGraphVisitor::VisitLetNode(LetNode* node) {
   BuildLetTempExpressions(node);
 
   // Visit body.
   for (intptr_t i = 0; i < node->nodes().length() - 1; ++i) {
-    EffectGraphVisitor for_effect(owner(), temp_index());
+    EffectGraphVisitor for_effect(owner());
     node->nodes()[i]->Visit(&for_effect);
     Append(for_effect);
   }
   // Visit the last body expression for value.
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner());
   node->nodes().Last()->Visit(&for_value);
   Append(for_value);
   Value* result_value = for_value.value();
 
   intptr_t num_temps = node->num_temps();
   if (num_temps > 0) {
-    DeallocateTempIndex(num_temps);
+    owner()->DeallocateTemps(num_temps);
     ReturnDefinition(new DropTempsInstr(num_temps, result_value));
   } else {
     ReturnValue(result_value);
   }
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   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(),
                                                   node->length(),
                                                   node->type(),
                                                   element_type);
   Value* array_val = Bind(create);
 
   { LocalVariable* tmp_var = EnterTempLocalScope(array_val);
     const intptr_t class_id = create->Type()->ToCid();
     const intptr_t deopt_id = Isolate::kNoDeoptId;
     for (int i = 0; i < node->length(); ++i) {
       Value* array = Bind(new LoadLocalInstr(*tmp_var));
       Value* index = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(i))));
-      ValueGraphVisitor for_value(owner(), temp_index());
+      ValueGraphVisitor for_value(owner());
       node->ElementAt(i)->Visit(&for_value);
       Append(for_value);
       // No store barrier needed for constants.
       const StoreBarrierType emit_store_barrier =
           for_value.value()->BindsToConstant()
               ? kNoStoreBarrier
               : kEmitStoreBarrier;
       intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(class_id);
       StoreIndexedInstr* store = new StoreIndexedInstr(
           array, index, for_value.value(),
           emit_store_barrier, index_scale, class_id, deopt_id);
       Do(store);
     }
     ReturnDefinition(ExitTempLocalScope(tmp_var));
   }
 }
 
 
 void EffectGraphVisitor::VisitStringInterpolateNode(
     StringInterpolateNode* node) {
-  ValueGraphVisitor for_argument(owner(), temp_index());
+  ValueGraphVisitor for_argument(owner());
   node->value()->Visit(&for_argument);
   Append(for_argument);
   StringInterpolateInstr* instr =
       new StringInterpolateInstr(for_argument.value(), node->token_pos());
   ReturnDefinition(instr);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
@@ skipping 98 matching lines @@
       tmp_val = Bind(new LoadLocalInstr(*tmp_var));
       Value* context = Bind(new CurrentContextInstr());
       Do(new StoreInstanceFieldInstr(context_field,
                                      tmp_val,
                                      context,
                                      kEmitStoreBarrier));
       ReturnDefinition(ExitTempLocalScope(tmp_var));
     }
   } else {
     ASSERT(function.IsImplicitInstanceClosureFunction());
-    ValueGraphVisitor for_receiver(owner(), temp_index());
+    ValueGraphVisitor for_receiver(owner());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     Value* receiver = for_receiver.value();
 
     PushArgumentInstr* push_receiver = PushArgument(receiver);
     ZoneGrowableArray<PushArgumentInstr*>* arguments =
         new ZoneGrowableArray<PushArgumentInstr*>(2);
     arguments->Add(push_receiver);
     ASSERT(function.context_scope() != ContextScope::null());
 
@@ skipping 17 matching lines @@
     ReturnDefinition(
         new CreateClosureInstr(node->function(), arguments, node->token_pos()));
   }
 }
 
 
 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());
     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());
   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(
@@ skipping 51 matching lines @@
   if (node->function().is_native()) {
     const intptr_t result_cid = GetResultCidOfNative(node->function());
     call->set_result_cid(result_cid);
   }
   ReturnDefinition(call);
 }
 
 
 ClosureCallInstr* EffectGraphVisitor::BuildClosureCall(
     ClosureCallNode* node) {
-  ValueGraphVisitor for_closure(owner(), temp_index());
+  ValueGraphVisitor for_closure(owner());
   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 191 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());
   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,
@@ 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());
     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 117 matching lines @@
   { LocalVariable* tmp_var = EnterTempLocalScope(allocate);
     Value* allocated_tmp = Bind(new LoadLocalInstr(*tmp_var));
     PushArgumentInstr* push_allocated_value = PushArgument(allocated_tmp);
     BuildConstructorCall(node, push_allocated_value);
     ReturnDefinition(ExitTempLocalScope(tmp_var));
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
-  ValueGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner());
   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, Object::null_array(),
       1,
       owner()->ic_data_array());
   ReturnDefinition(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceSetterArguments(
     InstanceSetterNode* node,
     ZoneGrowableArray<PushArgumentInstr*>* arguments,
     bool result_is_needed) {
-  ValueGraphVisitor for_receiver(owner(), temp_index());
+  ValueGraphVisitor for_receiver(owner());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   arguments->Add(PushArgument(for_receiver.value()));
 
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner());
   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 51 matching lines @@
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->cls(),
                                       node->receiver(),
                                       getter_name,
                                       arguments,
                                       false,  // Don't save last argument.
                                       true);  // Super invocation.
       ReturnDefinition(call);
       return;
     } else {
-      ValueGraphVisitor receiver_value(owner(), temp_index());
+      ValueGraphVisitor receiver_value(owner());
       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
@@ skipping 73 matching lines @@
           arguments,  // Argument is the value passed to the setter.
           InvocationMirror::EncodeType(
             node->cls().IsTopLevel() ?
                 InvocationMirror::kTopLevel :
                 InvocationMirror::kStatic,
             InvocationMirror::kSetter));
     }
   } else {
     if (is_super_setter) {
       // Add receiver of instance getter.
-      ValueGraphVisitor for_receiver(owner(), temp_index());
+      ValueGraphVisitor for_receiver(owner());
       node->receiver()->Visit(&for_receiver);
       Append(for_receiver);
       arguments->Add(PushArgument(for_receiver.value()));
     }
-    ValueGraphVisitor for_value(owner(), temp_index());
+    ValueGraphVisitor for_value(owner());
     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 144 matching lines @@
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* 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());
   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());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadFieldInstr* load = new LoadFieldInstr(
       for_instance.value(),
       node->field().Offset(),
       AbstractType::ZoneHandle(node->field().type()));
   load->set_field(&node->field());
   if (owner()->exit_collector() != NULL) {
     // While inlining into an optimized function, the field has
     // to be added to the list of guarded fields of the caller.
     if (node->field().guarded_cid() != kIllegalCid) {
       if (!node->field().is_nullable() ||
           (node->field().guarded_cid() == kNullCid)) {
         load->set_result_cid(node->field().guarded_cid());
       }
       FlowGraph::AddToGuardedFields(owner()->guarded_fields(), &node->field());
     }
   }
   ReturnDefinition(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreInstanceFieldNode(
     StoreInstanceFieldNode* node) {
-  ValueGraphVisitor for_instance(owner(), temp_index());
+  ValueGraphVisitor for_instance(owner());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
-  ValueGraphVisitor for_value(owner(), for_instance.temp_index());
+  ValueGraphVisitor for_value(owner());
   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 32 matching lines @@
     return ReturnDefinition(result);
   }
   Value* field_value = Bind(new ConstantInstr(node->field()));
   LoadStaticFieldInstr* load = new LoadStaticFieldInstr(field_value);
   ReturnDefinition(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreStaticField(
   StoreStaticFieldNode* node, bool result_is_needed) {
-  ValueGraphVisitor for_value(owner(), temp_index());
+  ValueGraphVisitor for_value(owner());
   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 44 matching lines @@
                                       Symbols::IndexToken(),
                                       arguments,
                                       false,  // Don't save last arg.
                                       true);  // Super invocation.
       ReturnDefinition(call);
       return;
     }
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
-  ValueGraphVisitor for_array(owner(), temp_index());
+  ValueGraphVisitor for_array(owner());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
-  ValueGraphVisitor for_index(owner(), temp_index());
+  ValueGraphVisitor for_index(owner());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   arguments->Add(PushArgument(for_index.value()));
 
   if (super_function != NULL) {
     // Generate static call to super operator.
     StaticCallInstr* load = new StaticCallInstr(node->token_pos(),
                                                 *super_function,
                                                 Object::null_array(),
                                                 arguments,
@@ skipping 42 matching lines @@
         // BuildStaticNoSuchMethodCall stores the value in expression_temp.
         return BuildLoadExprTemp();
       } else {
         return call;
       }
     }
   }
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
-  ValueGraphVisitor for_array(owner(), temp_index());
+  ValueGraphVisitor for_array(owner());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
 
-  ValueGraphVisitor for_index(owner(), temp_index());
+  ValueGraphVisitor for_index(owner());
   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());
   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 166 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());
     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 21 matching lines @@
          (node != owner()->parsed_function()->node_sequence()));
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCatchClauseNode (exception)");
   // Restores CTX from local variable ':saved_context'.
   BuildRestoreContext(node->context_var());
 
-  EffectGraphVisitor for_catch(owner(), temp_index());
+  EffectGraphVisitor for_catch(owner());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   InlineBailout("EffectGraphVisitor::VisitTryCatchNode (exception)");
   intptr_t original_handler_index = owner()->try_index();
   const intptr_t try_handler_index = node->try_index();
   ASSERT(try_handler_index != original_handler_index);
   owner()->set_try_index(try_handler_index);
 
   // Preserve CTX into local variable '%saved_context'.
   BuildSaveContext(node->context_var());
 
-  EffectGraphVisitor for_try(owner(), temp_index());
+  EffectGraphVisitor for_try(owner());
   node->try_block()->Visit(&for_try);
 
   if (for_try.is_open()) {
     JoinEntryInstr* after_try =
         new JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index);
     for_try.Goto(after_try);
     for_try.exit_ = after_try;
   }
 
   JoinEntryInstr* try_entry =
@@ skipping 12 matching lines @@
   // If there is a finally block, it is the handler for code in the catch
   // block.
   const intptr_t catch_handler_index = (finally_block == NULL)
       ? original_handler_index
       : catch_block->catch_handler_index();
 
   const intptr_t prev_catch_try_index = owner()->catch_try_index();
 
   owner()->set_try_index(catch_handler_index);
   owner()->set_catch_try_index(try_handler_index);
-  EffectGraphVisitor for_catch(owner(), temp_index());
+  EffectGraphVisitor for_catch(owner());
   catch_block->Visit(&for_catch);
   owner()->set_catch_try_index(prev_catch_try_index);
 
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   ASSERT(!catch_block->exception_var().is_captured());
   ASSERT(!catch_block->stacktrace_var().is_captured());
 
   CatchBlockEntryInstr* catch_entry =
       new CatchBlockEntryInstr(owner()->AllocateBlockId(),
@@ skipping 11 matching lines @@
     if (join != NULL) {
       if (is_open()) Goto(join);
       exit_ = join;
     }
   }
 
   if (finally_block != NULL) {
     // Create a handler for the code in the catch block, containing the
     // code in the finally block.
     owner()->set_try_index(original_handler_index);
-    EffectGraphVisitor for_finally(owner(), temp_index());
+    EffectGraphVisitor for_finally(owner());
     for_finally.BuildRestoreContext(catch_block->context_var());
 
     finally_block->Visit(&for_finally);
     if (for_finally.is_open()) {
       // Rethrow the exception.  Manually build the graph for rethrow.
       Value* exception = for_finally.Bind(
           for_finally.BuildLoadLocal(catch_block->exception_var()));
       for_finally.PushArgument(exception);
       Value* stacktrace = for_finally.Bind(
           for_finally.BuildLoadLocal(catch_block->stacktrace_var()));
@@ skipping 13 matching lines @@
                                  catch_handler_index,
                                  catch_block->exception_var(),
                                  catch_block->stacktrace_var(),
                                  catch_block->needs_stacktrace());
     owner()->AddCatchEntry(finally_entry);
     AppendFragment(finally_entry, for_finally);
   }
 
   // Generate code for the finally block if one exists.
   if ((finally_block != NULL) && is_open()) {
-    EffectGraphVisitor for_finally_block(owner(), temp_index());
+    EffectGraphVisitor for_finally_block(owner());
     finally_block->Visit(&for_finally_block);
     Append(for_finally_block);
   }
 }
 
 
 // Looks up dynamic method noSuchMethod in target_class
 // (including its super class chain) and builds a static call to it.
 StaticCallInstr* EffectGraphVisitor::BuildStaticNoSuchMethodCall(
     const Class& target_class,
@@ skipping 54 matching lines @@
   arguments->Add(PushArgument(member_name_value));
   // Smi invocation_type.
   Value* invocation_type_value = Bind(new ConstantInstr(
       Smi::ZoneHandle(Smi::New(invocation_type))));
   arguments->Add(PushArgument(invocation_type_value));
   // List arguments.
   if (function_arguments == NULL) {
     Value* arguments_value = Bind(new ConstantInstr(Array::ZoneHandle()));
     arguments->Add(PushArgument(arguments_value));
   } else {
-    ValueGraphVisitor array_val(owner(), temp_index());
+    ValueGraphVisitor array_val(owner());
     ArrayNode* array =
         new ArrayNode(token_pos, Type::ZoneHandle(Type::ArrayType()),
                       function_arguments->nodes());
     array->Visit(&array_val);
     Append(array_val);
     arguments->Add(PushArgument(array_val.value()));
   }
   // List argumentNames.
   ConstantInstr* cinstr = new ConstantInstr(
       (function_arguments == NULL) ? Array::ZoneHandle()
@@ skipping 18 matching lines @@
   ASSERT(!func.IsNull());
   return new StaticCallInstr(token_pos,
                              func,
                              Object::null_array(),  // No names.
                              arguments,
                              owner()->ic_data_array());
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
-  ValueGraphVisitor for_exception(owner(), temp_index());
+  ValueGraphVisitor for_exception(owner());
   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());
     node->stacktrace()->Visit(&for_stack_trace);
     Append(for_stack_trace);
     PushArgument(for_stack_trace.value());
     instr = new ReThrowInstr(node->token_pos(), owner()->catch_try_index());
   }
   AddInstruction(instr);
 }
 
 
 void EffectGraphVisitor::VisitThrowNode(ThrowNode* node) {
@@ skipping 18 matching lines @@
     // 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.
     intptr_t outer_try_index = node->try_index();
     owner()->set_try_index(outer_try_index);
   }
   BuildRestoreContext(node->context_var());
 
   JoinEntryInstr* finally_entry =
       new JoinEntryInstr(owner()->AllocateBlockId(), owner()->try_index());
-  EffectGraphVisitor for_finally_block(owner(), temp_index());
+  EffectGraphVisitor for_finally_block(owner());
   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());
     for_finally_block.Goto(after_finally);
@@ skipping 12 matching lines @@
     AstPrinter::PrintFunctionNodes(*parsed_function());
   }
   if (FLAG_print_scopes) {
     AstPrinter::PrintFunctionScope(*parsed_function());
   }
   const Function& function = parsed_function()->function();
   TargetEntryInstr* normal_entry =
       new TargetEntryInstr(AllocateBlockId(),
                            CatchClauseNode::kInvalidTryIndex);
   graph_entry_ = new GraphEntryInstr(parsed_function(), normal_entry, osr_id_);
-  EffectGraphVisitor for_effect(this, 0);
+  EffectGraphVisitor for_effect(this);
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
   if (!function.is_native()) {
     CheckStackOverflowInstr* check =
         new CheckStackOverflowInstr(function.token_pos(), 0);
     // If we are inlining don't actually attach the stack check. We must still
     // create the stack check in order to allocate a deopt id.
     if (!IsInlining()) for_effect.AddInstruction(check);
   }
   parsed_function()->node_sequence()->Visit(&for_effect);
@@ skipping 31 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