Automatically assign temporary indices to definitions in the IL.

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 30 matching lines @@
 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()->SetSuccessor(other_fragment.entry());
     exit_ = other_fragment.exit();
   }
+  temp_index_ = other_fragment.temp_index();
 }
 
 
 void EffectGraphVisitor::AddInstruction(Instruction* instruction) {
   ASSERT(is_open());
+  DeallocateTempIndex(instruction->InputCount());
+  if (instruction->IsDefinition()) {
+    instruction->AsDefinition()->set_temp_index(AllocateTempIndex());
+  }
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     exit()->SetSuccessor(instruction);
     exit_ = instruction;
   }
 }
 
 
 void EffectGraphVisitor::Join(const TestGraphVisitor& test_fragment,
@@ skipping 18 matching lines @@
   true_exit = true_fragment.is_empty() ? true_entry : true_fragment.exit();
 
   TargetEntryInstr* false_entry = new TargetEntryInstr();
   *test_fragment.false_successor_address() = false_entry;
   false_entry->SetSuccessor(false_fragment.entry());
   false_exit = false_fragment.is_empty() ? false_entry : false_fragment.exit();
 
   // 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 {
     exit_ = new JoinEntryInstr();
     true_exit->SetSuccessor(exit_);
     false_exit->SetSuccessor(exit_);
+    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.
@@ skipping 19 matching lines @@
   }
 
   // 3. Set the exit to the graph to be the false successor of the test, a
   // fresh target node
   exit_ = *test_fragment.false_successor_address() = new TargetEntryInstr();
 }
 
 
 // Stores current context into the 'variable'
 void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable) {
-  BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
+  BindInstr* context = new BindInstr(new CurrentContextComp());
   AddInstruction(context);
   StoreLocalComp* store_context =
       new StoreLocalComp(variable, new UseVal(context),
                          owner()->context_level());
   AddInstruction(new DoInstr(store_context));
 }
 
 
 // Loads context saved in 'context_variable' into the current context.
 void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
   BindInstr* load_saved_context =
-      new BindInstr(temp_index(),
-                    new LoadLocalComp(variable, owner()->context_level()));
+      new BindInstr(new LoadLocalComp(variable, owner()->context_level()));
   AddInstruction(load_saved_context);
   DoInstr* store_context =
       new DoInstr(new StoreContextComp(new UseVal(load_saved_context)));
   AddInstruction(store_context);
 }
 
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     BindInstr* assert_boolean =
-        new BindInstr(temp_index(),
-                      new AssertBooleanComp(condition_token_index(),
+        new BindInstr(new AssertBooleanComp(condition_token_index(),
                                             owner()->try_index(),
                                             value));
     AddInstruction(assert_boolean);
     value = new UseVal(assert_boolean);
   }
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
-    EffectGraphVisitor for_effect(owner(), for_value.temp_index());
+    EffectGraphVisitor for_effect(owner(), temp_index());
     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 RawFunction::Kind kind = owner()->parsed_function().function().kind();
     const bool is_implicit_getter =
         (kind == RawFunction::kImplicitGetter) ||
         (kind == RawFunction::kConstImplicitGetter);
     const bool is_static = owner()->parsed_function().function().is_static();
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     if (is_static || !is_implicit_getter) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
       const String& dst_name =
           String::ZoneHandle(String::NewSymbol("function result"));
       return_value = BuildAssignableValue(node->value(),
                                           return_value,
                                           dst_type,
-                                          dst_name,
-                                          temp_index());
+                                          dst_name);
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
@@ skipping 83 matching lines @@
 }
 
 
 void ValueGraphVisitor::VisitAssignableNode(AssignableNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->expr()->Visit(&for_value);
   Append(for_value);
   ReturnValue(BuildAssignableValue(node->expr(),
                                    for_value.value(),
                                    node->type(),
-                                   node->dst_name(),
-                                   temp_index()));
+                                   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_index());
     node->left()->Visit(&for_left);
     EffectGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     EffectGraphVisitor empty(owner(), temp_index());
     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());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
+  ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(node->token_index(),
                                                 owner()->try_index(),
                                                 name,
                                                 arguments,
@@ skipping 18 matching lines @@
     TestGraphVisitor for_test(owner(),
                               temp_index(),
                               node->left()->token_index());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       BindInstr* assert_boolean =
-          new BindInstr(temp_index(),
-                        new AssertBooleanComp(node->right()->token_index(),
+          new BindInstr(new AssertBooleanComp(node->right()->token_index(),
                                               owner()->try_index(),
                                               right_value));
       for_right.AddInstruction(assert_boolean);
       right_value = new UseVal(assert_boolean);
     }
-    BindInstr* constant_true =
-        new BindInstr(temp_index(), new ConstantVal(bool_true));
+    BindInstr* constant_true = new BindInstr(new ConstantVal(bool_true));
     for_right.AddInstruction(constant_true);
     StrictCompareComp* comp = new StrictCompareComp(Token::kEQ_STRICT,
         right_value, new UseVal(constant_true));
-    for_right.AddInstruction(new BindInstr(temp_index(), comp));
+    for_right.AddInstruction(new BindInstr(comp));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
       for_false.ReturnComputation(new ConstantVal(bool_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index());
       for_true.ReturnComputation(new ConstantVal(bool_true));
       Join(for_test, for_true, for_right);
     }
-    ReturnValue(new TempVal(AllocateTempIndex()));
+    ReturnValue(new TempVal(temp_index() - 1));
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::CompiletimeStringInterpolation(
     const Function& interpol_func, const Array& literals) {
   // Do nothing.
 }
@@ skipping 52 matching lines @@
   }
   if (compile_time_interpolation) {
     // Not needed for effect, only for value
     CompiletimeStringInterpolation(interpol_func, literals);
     return;
   }
   // Runtime string interpolation.
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
   ArgumentListNode* interpol_arg = new ArgumentListNode(node->token_index());
   interpol_arg->Add(node->values());
-  TranslateArgumentList(*interpol_arg, temp_index(), values);
+  TranslateArgumentList(*interpol_arg, values);
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
                          owner()->try_index(),
                          interpol_func,
                          interpol_arg->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildAssertAssignable(intptr_t token_index,
                                                Value* value,
                                                const AbstractType& dst_type,
-                                               const String& dst_name,
-                                               intptr_t start_index) {
+                                               const String& dst_name) {
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (!dst_type.IsInstantiated()) {
     instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(token_index, start_index + 1);
+        BuildInstantiatorTypeArguments(token_index);
   }
   AssertAssignableComp* assert_assignable =
       new AssertAssignableComp(token_index,
                                owner()->try_index(),
                                value,
                                instantiator_type_arguments,
                                dst_type,
                                dst_name);
   AddInstruction(new DoInstr(assert_assignable));
 }
 
 
 Value* EffectGraphVisitor::BuildAssignableValue(AstNode* value_node,
                                                 Value* value,
                                                 const AbstractType& dst_type,
-                                                const String& dst_name,
-                                                intptr_t start_index) {
+                                                const String& dst_name) {
   if (CanSkipTypeCheck(value_node, dst_type)) {
     return value;
   }
 
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (!dst_type.IsInstantiated()) {
     instantiator_type_arguments =
-        BuildInstantiatorTypeArguments(value_node->token_index(),
-                                       start_index + 1);
+        BuildInstantiatorTypeArguments(value_node->token_index());
   }
   BindInstr* assert_assignable =
-      new BindInstr(start_index,
-                    new AssertAssignableComp(value_node->token_index(),
+      new BindInstr(new AssertAssignableComp(value_node->token_index(),
                                              owner()->try_index(),
                                              value,
                                              instantiator_type_arguments,
                                              dst_type,
                                              dst_name));
   AddInstruction(assert_assignable);
   return new UseVal(assert_assignable);
 }
 
 
@@ skipping 53 matching lines @@
     ReturnComputation(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* type_arguments = NULL;
   if (!type.IsInstantiated()) {
     type_arguments =
-        BuildInstantiatorTypeArguments(node->token_index(),
-                                       for_left_value.temp_index());
+        BuildInstantiatorTypeArguments(node->token_index());
   }
   InstanceOfComp* instance_of =
       new InstanceOfComp(node->token_index(),
                          owner()->try_index(),
                          for_left_value.value(),
                          type_arguments,
                          node->right()->AsTypeNode()->type(),
                          (node->kind() == Token::kISNOT));
   ReturnComputation(instance_of);
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 // TODO(srdjan): Implement new equality.
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsInstanceofOperator(node->kind())) {
     BuildInstanceOf(node);
     return;
   }
   if ((node->kind() == Token::kEQ_STRICT) ||
       (node->kind() == Token::kNE_STRICT)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
+    ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     StrictCompareComp* comp = new StrictCompareComp(
         node->kind(), for_left_value.value(), for_right_value.value());
     ReturnComputation(comp);
     return;
   }
 
   if ((node->kind() == Token::kEQ) || (node->kind() == Token::kNE)) {
     ValueGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
+    ValueGraphVisitor for_right_value(owner(), temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     EqualityCompareComp* comp = new EqualityCompareComp(
         node->token_index(), owner()->try_index(),
         for_left_value.value(), for_right_value.value());
     if (node->kind() == Token::kEQ) {
       ReturnComputation(comp);
     } else {
-      Definition* eq_result = new BindInstr(temp_index(), comp);
+      Definition* eq_result = new BindInstr(comp);
       AddInstruction(eq_result);
       if (FLAG_enable_type_checks) {
         eq_result =
-            new BindInstr(temp_index(),
-                          new AssertBooleanComp(node->token_index(),
+            new BindInstr(new AssertBooleanComp(node->token_index(),
                                                 owner()->try_index(),
                                                 new UseVal(eq_result)));
         AddInstruction(eq_result);
       }
       BooleanNegateComp* negate = new BooleanNegateComp(new UseVal(eq_result));
       ReturnComputation(negate);
     }
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
+  ValueGraphVisitor for_right_value(owner(), temp_index());
   node->right()->Visit(&for_right_value);
   Append(for_right_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_left_value.value());
   arguments->Add(for_right_value.value());
   const String& name = String::ZoneHandle(String::NewSymbol(node->Name()));
   InstanceCallComp* call = new InstanceCallComp(
       node->token_index(), owner()->try_index(), name,
       arguments, Array::ZoneHandle(), 2);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitUnaryOpNode(UnaryOpNode* node) {
   // "!" cannot be overloaded, therefore do not call operator.
   if (node->kind() == Token::kNOT) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->operand()->Visit(&for_value);
     Append(for_value);
     Value* value = for_value.value();
     if (FLAG_enable_type_checks) {
       BindInstr* assert_boolean =
-          new BindInstr(temp_index(),
-                        new AssertBooleanComp(node->operand()->token_index(),
+          new BindInstr(new AssertBooleanComp(node->operand()->token_index(),
                                               owner()->try_index(),
                                               value));
       AddInstruction(assert_boolean);
       value = new UseVal(assert_boolean);
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   ValueGraphVisitor for_value(owner(), temp_index());
@@ skipping 12 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   BindInstr* load =
-      new BindInstr(temp_index(),
-                    new LoadLocalComp(node->local(), owner()->context_level()));
+      new BindInstr(new LoadLocalComp(node->local(), owner()->context_level()));
   AddInstruction(load);
-  AllocateTempIndex();
   // 2. Increment.
   Definition* incr =
       BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 3. Perform the store, resulting in the new value.
-  DeallocateTempIndex();  // Consuming incr.
   StoreLocalComp* store = new StoreLocalComp(
       node->local(), new UseVal(incr), owner()->context_level());
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (node->prefix()) {
     // Base class handles preincrement.
     EffectGraphVisitor::VisitIncrOpLocalNode(node);
     return;
   }
   // For postincrement, duplicate the original value to use one copy as the
   // result.
   //
   // 1. Load the value.
   BindInstr* load =
-      new BindInstr(temp_index(),
-                    new LoadLocalComp(node->local(), owner()->context_level()));
+      new BindInstr(new LoadLocalComp(node->local(), owner()->context_level()));
   AddInstruction(load);
-  AllocateTempIndex();
   // 2. Duplicate it to increment.
-  PickTempInstr* duplicate =
-      new PickTempInstr(temp_index(), load->temp_index());
+  PickTempInstr* duplicate = new PickTempInstr(load->temp_index());
   AddInstruction(duplicate);
-  AllocateTempIndex();
   // 3. Increment.
   Definition* incr =
       BuildIncrOpIncrement(node->kind(), node->token_index(),
                            new UseVal(duplicate));
   // 4. Perform the store and return the original value.
-  DeallocateTempIndex();  // Consuming incr.
   StoreLocalComp* store = new StoreLocalComp(
       node->local(), new UseVal(incr), owner()->context_level());
   AddInstruction(new DoInstr(store));
   ReturnValue(new UseVal(load));
 }
 
 
 Definition* EffectGraphVisitor::BuildIncrOpFieldLoad(
     IncrOpInstanceFieldNode* node,
     Value** receiver) {
   // Evaluate the receiver and duplicate it (it has two uses).
   //   t_n   <- ... receiver ...
   //   t_n+1 <- Pick(t_n)
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
-  AllocateTempIndex();
   ASSERT(temp_index() == for_receiver.temp_index());
-  PickTempInstr* duplicate =
-      new PickTempInstr(temp_index(), temp_index() - 1);
+  PickTempInstr* duplicate = new PickTempInstr(temp_index() - 1);
   AddInstruction(duplicate);
 
   // Load the value.
   //   t_n+1 <- InstanceCall(get:name, t_n+1)
   const String& getter_name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(new UseVal(duplicate));
   BindInstr* load =
-      new BindInstr(temp_index(),
-                    new InstanceCallComp(
+      new BindInstr(new InstanceCallComp(
                         node->token_index(),
                         owner()->try_index(), getter_name, arguments,
                         Array::ZoneHandle(), 1));
   AddInstruction(load);
-  AllocateTempIndex();
 
   *receiver = for_receiver.value();
   return load;
 }
 
 
 Definition* EffectGraphVisitor::BuildIncrOpIncrement(Token::Kind kind,
                                                      intptr_t token_index,
                                                      Value* original) {
   ASSERT((kind == Token::kINCR) || (kind == Token::kDECR));
   // Assumed that t_n-1 (where n is start_index) is the field value.
   //   t_n   <- #1
   //   t_n-1 <- InstanceCall(op, t_n-1, t_n)
   BindInstr* one =
-      new BindInstr(temp_index(),
-                    new ConstantVal(Smi::ZoneHandle(Smi::New(1))));
+      new BindInstr(new ConstantVal(Smi::ZoneHandle(Smi::New(1))));
   AddInstruction(one);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(original);
   arguments->Add(new UseVal(one));
   const String& op_name =
       String::ZoneHandle(String::NewSymbol((kind == Token::kINCR) ? "+" : "-"));
-  DeallocateTempIndex();  // Consuming original.
   BindInstr* add =
-      new BindInstr(temp_index(),
-                    new InstanceCallComp(
+      new BindInstr(new InstanceCallComp(
                         token_index, owner()->try_index(), op_name,
                         arguments, Array::ZoneHandle(), 2));
   AddInstruction(add);
-  AllocateTempIndex();
   return add;
 }
 
 
 void EffectGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   Value* receiver = NULL;
   Definition* load = BuildIncrOpFieldLoad(node, &receiver);
   // 2. Increment.
   Definition* incr =
       BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 3. Perform the store, returning the stored value.
   InstanceSetterComp* store =
       new InstanceSetterComp(node->token_index(),
                              owner()->try_index(),
                              node->field_name(),
                              receiver,
                              new UseVal(incr));
-  DeallocateTempIndex();  // Consuming incr.
-  DeallocateTempIndex();  // Consuming receiver.
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (node->prefix()) {
     // Base class handles preincrement.
     EffectGraphVisitor::VisitIncrOpInstanceFieldNode(node);
     return;
   }
   // For postincrement, preallocate a temporary to preserve the original
   // value.
   //
   // 1. Name a placeholder.
   BindInstr* placeholder =
-      new BindInstr(temp_index(),
-                    new ConstantVal(Smi::ZoneHandle(Smi::New(0))));
+      new BindInstr(new ConstantVal(Smi::ZoneHandle(Smi::New(0))));
   AddInstruction(placeholder);
-  AllocateTempIndex();
   // 2. Load the value.
   Value* receiver = NULL;
   Definition* load = BuildIncrOpFieldLoad(node, &receiver);
   // 3. Preserve the original value.
   AddInstruction(new TuckTempInstr(placeholder->temp_index(),
                                    load->temp_index()));
   // 4. Increment.
   Definition* incr =
       BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 5. Perform the store and return the original value.
   const String& setter_name =
       String::ZoneHandle(Field::SetterSymbol(node->field_name()));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(receiver);
   arguments->Add(new UseVal(incr));
   InstanceCallComp* store = new InstanceCallComp(
       node->token_index(), owner()->try_index(),
       setter_name, arguments, Array::ZoneHandle(), 1);
-  DeallocateTempIndex();  // Consuming incr.
-  DeallocateTempIndex();  // Consuming receiver.
   AddInstruction(new DoInstr(store));
   ReturnValue(new UseVal(placeholder));
 }
 
 
 Definition* EffectGraphVisitor::BuildIncrOpIndexedLoad(
     IncrOpIndexedNode* node,
     Value** receiver,
     Value** index) {
   // Evaluate the receiver and index.
   //   t_n   <- ... receiver ...
   //   t_n+1 <- ... index ...
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->array()->Visit(&for_receiver);
   Append(for_receiver);
-  AllocateTempIndex();
   ASSERT(temp_index() == for_receiver.temp_index());
 
   ValueGraphVisitor for_index(owner(), temp_index());
   node->index()->Visit(&for_index);
   Append(for_index);
-  AllocateTempIndex();
   ASSERT(temp_index() == for_index.temp_index());
 
   // Duplicate the receiver and index values, load the value.
   //   t_n+2 <- Pick(t_n)
   //   t_n+3 <- Pick(t_n+1)
   //   t_n+2 <- InstanceCall([], t_n+2, t_n+3)
-  PickTempInstr* duplicate_receiver =
-      new PickTempInstr(temp_index(), temp_index() - 2);
+  PickTempInstr* duplicate_receiver = new PickTempInstr(temp_index() - 2);
   AddInstruction(duplicate_receiver);
-  PickTempInstr* duplicate_index =
-      new PickTempInstr(temp_index() + 1, temp_index() - 1);
+  PickTempInstr* duplicate_index = new PickTempInstr(temp_index() - 2);
   AddInstruction(duplicate_index);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(new UseVal(duplicate_receiver));
   arguments->Add(new UseVal(duplicate_index));
   const String& load_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
   BindInstr* load =
-      new BindInstr(temp_index(),
-                    new InstanceCallComp(
+      new BindInstr(new InstanceCallComp(
                         node->token_index(),
                         owner()->try_index(), load_name, arguments,
                         Array::ZoneHandle(), 1));
   AddInstruction(load);
-  AllocateTempIndex();
 
   *receiver = for_receiver.value();
   *index = for_index.value();
   return load;
 }
 
 
 void EffectGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
   Value* receiver = NULL;
   Value* index = NULL;
   Definition* load = BuildIncrOpIndexedLoad(node, &receiver, &index);
   // 2. Increment.
   Definition* incr =
       BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 3. Perform the store, returning the stored value.
   StoreIndexedComp* store = new StoreIndexedComp(node->token_index(),
                                                  owner()->try_index(),
                                                  receiver,
                                                  index,
                                                  new UseVal(incr));
-  DeallocateTempIndex();  // Consuming incr.
-  DeallocateTempIndex();  // Consuming index.
-  DeallocateTempIndex();  // Consuming receiver.
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (node->prefix()) {
     // Base class handles preincrement.
     EffectGraphVisitor::VisitIncrOpIndexedNode(node);
     return;
   }
   // For postincrement, preallocate a temporary to preserve the original
   // value.
   //
   // 1. Name a placeholder.
   BindInstr* placeholder =
-      new BindInstr(temp_index(),
-                    new ConstantVal(Smi::ZoneHandle(Smi::New(0))));
+      new BindInstr(new ConstantVal(Smi::ZoneHandle(Smi::New(0))));
   AddInstruction(placeholder);
-  AllocateTempIndex();
   // 2. Load the value.
   Value* receiver = NULL;
   Value* index = NULL;
   Definition* load = BuildIncrOpIndexedLoad(node, &receiver, &index);
   // 3. Preserve the original value.
   AddInstruction(new TuckTempInstr(placeholder->temp_index(),
                                    load->temp_index()));
   // 4. Increment.
   Definition* incr =
       BuildIncrOpIncrement(node->kind(), node->token_index(), new UseVal(load));
   // 5. Perform the store and return the original value.
   const String& store_name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(3);
   arguments->Add(receiver);
   arguments->Add(index);
   arguments->Add(new UseVal(incr));
   InstanceCallComp* store = new InstanceCallComp(
       node->token_index(), owner()->try_index(),
       store_name, arguments, Array::ZoneHandle(), 1);
-  DeallocateTempIndex();  // Consuming incr.
-  DeallocateTempIndex();  // Consuming index.
-  DeallocateTempIndex();  // Consuming receiver.
   AddInstruction(new DoInstr(store));
   ReturnValue(new UseVal(placeholder));
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
@@ skipping 12 matching lines @@
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_index());
   node->condition()->Visit(&for_test);
 
   // Ensure that the value of the true/false subexpressions are named with
   // the same temporary name.
   ValueGraphVisitor for_true(owner(), temp_index());
   node->true_expr()->Visit(&for_true);
   ASSERT(for_true.is_open());
-  if (for_true.value()->IsTemp()) {
-    ASSERT(for_true.value()->AsTemp()->index() == temp_index());
-  } else {
-    for_true.AddInstruction(new BindInstr(temp_index(), for_true.value()));
-  }
+  ASSERT(for_true.value()->IsTemp() || for_true.value()->IsUse());
 
   ValueGraphVisitor for_false(owner(), temp_index());
   node->false_expr()->Visit(&for_false);
   ASSERT(for_false.is_open());
-  if (for_false.value()->IsTemp()) {
-    ASSERT(for_false.value()->AsTemp()->index() == temp_index());
-  } else {
-    for_false.AddInstruction(new BindInstr(temp_index(), for_false.value()));
-  }
+  ASSERT(for_false.value()->IsTemp() || for_false.value()->IsUse());
 
   Join(for_test, for_true, for_false);
-  ReturnValue(new TempVal(AllocateTempIndex()));
+  ReturnValue(new TempVal(temp_index() - 1));
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
 //                      false_branch: <Sequence> }
 void EffectGraphVisitor::VisitIfNode(IfNode* node) {
   TestGraphVisitor for_test(owner(),
                             temp_index(),
                             node->condition()->token_index());
@@ skipping 381 matching lines @@
 
 void EffectGraphVisitor::VisitArgumentListNode(ArgumentListNode* node) {
   UNREACHABLE();
 }
 
 
 void EffectGraphVisitor::VisitArrayNode(ArrayNode* node) {
   // Translate the array elements and collect their values.
   ZoneGrowableArray<Value*>* values =
       new ZoneGrowableArray<Value*>(node->length());
-  int index = temp_index();
   for (int i = 0; i < node->length(); ++i) {
-    ValueGraphVisitor for_value(owner(), index);
+    ValueGraphVisitor for_value(owner(), temp_index());
     node->ElementAt(i)->Visit(&for_value);
     Append(for_value);
     values->Add(for_value.value());
-    index = for_value.temp_index();
   }
   CreateArrayComp* create = new CreateArrayComp(node,
                                                 owner()->try_index(),
                                                 values);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
-  int next_index = temp_index();
   if (function.IsNonImplicitClosureFunction()) {
     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);
   } else if (function.IsImplicitInstanceClosureFunction()) {
     ValueGraphVisitor for_receiver(owner(), temp_index());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
-    if (!for_receiver.value()->IsTemp()) {
-      AddInstruction(new BindInstr(temp_index(), for_receiver.value()));
-    }
-    ++next_index;
   }
   ASSERT(function.context_scope() != ContextScope::null());
 
   // The function type of a closure may have type arguments. In that case, pass
   // the type arguments of the instantiator.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     type_arguments =
-        BuildInstantiatorTypeArguments(node->token_index(), temp_index());
+        BuildInstantiatorTypeArguments(node->token_index());
   }
 
   CreateClosureComp* create =
       new CreateClosureComp(node, owner()->try_index(), type_arguments);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
-    intptr_t next_temp_index,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
-    ValueGraphVisitor for_argument(owner(), next_temp_index);
+    ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
-    next_temp_index = for_argument.temp_index();
     values->Add(for_argument.value());
   }
 }
 
 void EffectGraphVisitor::VisitInstanceCallNode(InstanceCallNode* node) {
   ArgumentListNode* arguments = node->arguments();
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
 
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   values->Add(for_receiver.value());
 
-  TranslateArgumentList(*arguments, for_receiver.temp_index(), values);
+  TranslateArgumentList(*arguments, values);
   InstanceCallComp* call = new InstanceCallComp(
       node->token_index(), owner()->try_index(),
       node->function_name(), values,
                            arguments->names(), 1);
   ReturnComputation(call);
 }
 
 
 // <Expression> ::= StaticCall { function: Function
 //                               arguments: <ArgumentList> }
 void EffectGraphVisitor::VisitStaticCallNode(StaticCallNode* node) {
   int length = node->arguments()->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length);
-  TranslateArgumentList(*node->arguments(), temp_index(), values);
+  TranslateArgumentList(*node->arguments(), values);
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
                          owner()->try_index(),
                          node->function(),
                          node->arguments()->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   // Context is saved around the call, it's treated as an extra operand
   // consumed by the call (but not an argument).
-  BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
+  BindInstr* context = new BindInstr(new CurrentContextComp());
   AddInstruction(context);
 
-  ValueGraphVisitor for_closure(owner(), temp_index() + 1);
+  ValueGraphVisitor for_closure(owner(), temp_index());
   node->closure()->Visit(&for_closure);
   Append(for_closure);
 
   ZoneGrowableArray<Value*>* arguments =
       new ZoneGrowableArray<Value*>(node->arguments()->length());
   arguments->Add(for_closure.value());
-  TranslateArgumentList(*node->arguments(), temp_index() + 2, arguments);
+  TranslateArgumentList(*node->arguments(), arguments);
   // First operand is the saved context, consumed by the call.
   ClosureCallComp* call =  new ClosureCallComp(node,
                                                owner()->try_index(),
                                                new UseVal(context),
                                                arguments);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
-  BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
+  BindInstr* context = new BindInstr(new CurrentContextComp());
   AddInstruction(context);
   BindInstr* clone =
-      new BindInstr(temp_index(),
-                    new CloneContextComp(node->token_index(),
+      new BindInstr(new CloneContextComp(node->token_index(),
                                          owner()->try_index(),
                                          new UseVal(context)));
   AddInstruction(clone);
   ReturnComputation(new StoreContextComp(new UseVal(clone)));
 }
 
 
 Definition* EffectGraphVisitor::BuildObjectAllocation(
     ConstructorCallNode* node) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
@@ skipping 21 matching lines @@
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
     allocate_comp = new AllocateObjectWithBoundsCheckComp(node,
                                                           owner()->try_index(),
                                                           allocate_arguments);
   } else {
     allocate_comp = new AllocateObjectComp(node,
                                            owner()->try_index(),
                                            allocate_arguments);
   }
-  BindInstr* allocate = new BindInstr(temp_index(), allocate_comp);
+  BindInstr* allocate = new BindInstr(allocate_comp);
   AddInstruction(allocate);
-  AllocateTempIndex();
   return allocate;
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(ConstructorCallNode* node,
                                               Value* alloc_value) {
   BindInstr* ctor_arg =
-      new BindInstr(temp_index(),
-                    new ConstantVal(
+      new BindInstr(new ConstantVal(
                         Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   AddInstruction(ctor_arg);
-  AllocateTempIndex();
 
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>();
   values->Add(alloc_value);
   values->Add(new UseVal(ctor_arg));
 
-  TranslateArgumentList(*node->arguments(), temp_index(), values);
+  TranslateArgumentList(*node->arguments(), values);
   StaticCallComp* call =
       new StaticCallComp(node->token_index(),
                          owner()->try_index(),
                          node->constructor(),
                          node->arguments()->names(),
                          values);
-  DeallocateTempIndex();  // Consuming ctor_arg.
-  DeallocateTempIndex();  // Consuming alloc_value.
   AddInstruction(new DoInstr(call));
 }
 
 
 void EffectGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     ZoneGrowableArray<Value*>* factory_arguments =
         new ZoneGrowableArray<Value*>();
     factory_arguments->Add(new UseVal(BuildFactoryTypeArguments(node)));
     ASSERT(factory_arguments->length() == 1);
-    TranslateArgumentList(*node->arguments(),
-                          temp_index(),
-                          factory_arguments);
+    TranslateArgumentList(*node->arguments(), factory_arguments);
     StaticCallComp* call =
         new StaticCallComp(node->token_index(),
                            owner()->try_index(),
                            node->constructor(),
                            node->arguments()->names(),
                            factory_arguments);
-    DeallocateTempIndex();  // Consuming type arguments.
     ReturnComputation(call);
     return;
   }
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Definition* allocate = BuildObjectAllocation(node);
   BuildConstructorCall(node, new UseVal(allocate));
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
-    intptr_t token_index, intptr_t start_index) {
+    intptr_t token_index) {
   const Class& instantiator_class = Class::Handle(
       owner()->parsed_function().function().owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // TODO(regis): Temporary type should be allocated in new gen heap.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_index));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalizeWellFormed);
     type_arguments = type.arguments();
-    BindInstr* args =
-        new BindInstr(temp_index(), new ConstantVal(type_arguments));
+    BindInstr* args = new BindInstr(new ConstantVal(type_arguments));
     AddInstruction(args);
     return new UseVal(args);
   }
   ASSERT(owner()->parsed_function().instantiator() != NULL);
-  ValueGraphVisitor for_instantiator(owner(), start_index);
+  ValueGraphVisitor for_instantiator(owner(), temp_index());
   owner()->parsed_function().instantiator()->Visit(&for_instantiator);
   Append(for_instantiator);
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // All OK.
     return for_instantiator.value();
   }
 
   // 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
   // of the factory, i.e. already an AbstractTypeArguments object.
   intptr_t type_arguments_instance_field_offset =
       instantiator_class.type_arguments_instance_field_offset();
   ASSERT(type_arguments_instance_field_offset != Class::kNoTypeArguments);
 
   BindInstr* load =
-      new BindInstr(start_index,
-                    new NativeLoadFieldComp(
+      new BindInstr(new NativeLoadFieldComp(
                         for_instantiator.value(),
                         type_arguments_instance_field_offset));
   AddInstruction(load);
   return new UseVal(load);
 }
 
 
 Definition* EffectGraphVisitor::BuildFactoryTypeArguments(
     ConstructorCallNode* node) {
   ASSERT(node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
     BindInstr* type_args =
-        new BindInstr(temp_index(), new ConstantVal(node->type_arguments()));
+        new BindInstr(new ConstantVal(node->type_arguments()));
     AddInstruction(type_args);
-    AllocateTempIndex();
     return type_args;
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
-      BuildInstantiatorTypeArguments(node->token_index(), temp_index());
+      BuildInstantiatorTypeArguments(node->token_index());
   BindInstr* extract =
-      new BindInstr(temp_index(),
-                    new ExtractFactoryTypeArgumentsComp(node,
+      new BindInstr(new ExtractFactoryTypeArgumentsComp(node,
                                                         owner()->try_index(),
                                                         instantiator_value));
   AddInstruction(extract);
-  AllocateTempIndex();
   return extract;
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     ZoneGrowableArray<Value*>* args) {
   const Class& cls = Class::ZoneHandle(node->constructor().owner());
   ASSERT(cls.HasTypeArguments() && !node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
     BindInstr* type_args =
-        new BindInstr(temp_index(), new ConstantVal(node->type_arguments()));
+        new BindInstr(new ConstantVal(node->type_arguments()));
     AddInstruction(type_args);
     // No instantiator required.
     BindInstr* no_instantiator =
-        new BindInstr(temp_index() + 1,
-                      new ConstantVal(
+        new BindInstr(new ConstantVal(
                           Smi::ZoneHandle(Smi::New(
                               StubCode::kNoInstantiator))));
     AddInstruction(no_instantiator);
     args->Add(new UseVal(type_args));
     args->Add(new UseVal(no_instantiator));
     return;
   }
   // The type arguments are uninstantiated.
   // Place holder to hold uninstantiated constructor type arguments.
   BindInstr* placeholder =
-      new BindInstr(temp_index(),
-                    new ConstantVal(Object::ZoneHandle()));
+      new BindInstr(new ConstantVal(Object::ZoneHandle()));
   AddInstruction(placeholder);
   Value* instantiator =
-      BuildInstantiatorTypeArguments(node->token_index(), temp_index() + 1);
+      BuildInstantiatorTypeArguments(node->token_index());
   ASSERT(instantiator->IsUse());
   PickTempInstr* duplicate_instantiator =
-      new PickTempInstr(temp_index() + 2,
-                        instantiator->AsUse()->definition()->temp_index());
+      new PickTempInstr(instantiator->AsUse()->definition()->temp_index());
   AddInstruction(duplicate_instantiator);
   BindInstr* extract_type_arguments =
-      new BindInstr(temp_index() + 2,
-                    new ExtractConstructorTypeArgumentsComp(
+      new BindInstr(new ExtractConstructorTypeArgumentsComp(
                         node, new UseVal(duplicate_instantiator)));
   AddInstruction(extract_type_arguments);
   AddInstruction(new TuckTempInstr(placeholder->temp_index(),
                                    extract_type_arguments->temp_index()));
   BindInstr* extract_instantiator =
-      new BindInstr(temp_index() + 1,
-                    new ExtractConstructorInstantiatorComp(
+      new BindInstr(new ExtractConstructorInstantiatorComp(
                         node,
                         instantiator,
                         new UseVal(extract_type_arguments)));
   AddInstruction(extract_instantiator);
   args->Add(new UseVal(placeholder));
   args->Add(new UseVal(extract_instantiator));
 }
 
 
 void ValueGraphVisitor::VisitConstructorCallNode(ConstructorCallNode* node) {
   if (node->constructor().IsFactory()) {
     EffectGraphVisitor::VisitConstructorCallNode(node);
     return;
   }
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n+1    <- Pick(t_n)
   //   t_n+2    <- ctor-arg
   //   t_n+3... <- constructor arguments start here
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
 
   Definition* allocate = BuildObjectAllocation(node);
-  PickTempInstr* duplicate =
-      new PickTempInstr(temp_index(), allocate->temp_index());
+  PickTempInstr* duplicate = new PickTempInstr(allocate->temp_index());
   AddInstruction(duplicate);
-  AllocateTempIndex();
   BuildConstructorCall(node, new UseVal(duplicate));
   ReturnValue(new UseVal(allocate));
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
@@ skipping 92 matching lines @@
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->value(),
                                        store_value,
                                        node->local().type(),
-                                       node->local().name(),
-                                       temp_index());
+                                       node->local().name());
   }
   StoreLocalComp* store =
       new StoreLocalComp(node->local(), store_value, owner()->context_level());
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner(), temp_index());
@@ skipping 13 matching lines @@
   ValueGraphVisitor for_value(owner(), for_instance.temp_index());
   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(),
                                        store_value,
                                        type,
-                                       dst_name,
-                                       for_instance.temp_index());
+                                       dst_name);
   }
   StoreInstanceFieldComp* store =
       new StoreInstanceFieldComp(node, for_instance.value(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadStaticFieldNode(LoadStaticFieldNode* node) {
   LoadStaticFieldComp* load = new LoadStaticFieldComp(node->field());
   ReturnComputation(load);
 }
 
 
 void EffectGraphVisitor::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   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(),
                                        store_value,
                                        type,
-                                       dst_name,
-                                       temp_index());
+                                       dst_name);
   }
   StoreStaticFieldComp* store =
       new StoreStaticFieldComp(node->field(), store_value);
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadIndexedNode(LoadIndexedNode* node) {
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
@@ skipping 32 matching lines @@
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
   return (node == owner()->parsed_function().node_sequence()) &&
          (owner()->parsed_function().saved_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
-  BindInstr* context = new BindInstr(temp_index(), new CurrentContextComp());
+  BindInstr* context = new BindInstr(new CurrentContextComp());
   AddInstruction(context);
   BindInstr* parent =
-      new BindInstr(temp_index(),
-                    new NativeLoadFieldComp(
+      new BindInstr(new NativeLoadFieldComp(
                         new UseVal(context), Context::parent_offset()));
   AddInstruction(parent);
   AddInstruction(new DoInstr(new StoreContextComp(new UseVal(parent))));
 }
 
 
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   int previous_context_level = owner()->context_level();
   if (num_context_variables > 0) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
     // Allocate context computation (uses current CTX)
     BindInstr* allocated_context =
-        new BindInstr(temp_index(),
-                      new AllocateContextComp(node->token_index(),
+        new BindInstr(new AllocateContextComp(node->token_index(),
                                               owner()->try_index(),
                                               num_context_variables));
     AddInstruction(allocated_context);
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
-      BindInstr* current_context =
-          new BindInstr(temp_index() + 1, new CurrentContextComp());
+      BindInstr* current_context = new BindInstr(new CurrentContextComp());
       AddInstruction(current_context);
       StoreLocalComp* store_local = new StoreLocalComp(
           *owner()->parsed_function().saved_context_var(),
           new UseVal(current_context),
           0);
       AddInstruction(new DoInstr(store_local));
       BindInstr* null_context =
-          new BindInstr(temp_index() + 1,
-                        new ConstantVal(Object::ZoneHandle()));
+          new BindInstr(new ConstantVal(Object::ZoneHandle()));
       AddInstruction(null_context);
       StoreContextComp* store_context =
           new StoreContextComp(new UseVal(null_context));
       AddInstruction(new DoInstr(store_context));
     }
 
     ChainContextComp* chain_context =
         new ChainContextComp(new UseVal(allocated_context));
     AddInstruction(new DoInstr(chain_context));
     owner()->set_context_level(scope->context_level());
@@ skipping 14 matching lines @@
           const String& temp_name = String::ZoneHandle(String::Concat(
               parameter.name(), String::Handle(String::NewSymbol("-orig"))));
           LocalVariable* temp_local = new LocalVariable(
               0,  // Token index.
               temp_name,
               Type::ZoneHandle(Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
           BindInstr* load =
-              new BindInstr(temp_index(),
-                            new LoadLocalComp(*temp_local,
+              new BindInstr(new LoadLocalComp(*temp_local,
                                               owner()->context_level()));
           AddInstruction(load);
           StoreLocalComp* store_local = new StoreLocalComp(
               parameter,
               new UseVal(load),
               owner()->context_level());
           AddInstruction(new DoInstr(store_local));
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
           // the function.
           BindInstr* null_constant =
-              new BindInstr(temp_index(),
-                            new ConstantVal(Object::ZoneHandle()));
+              new BindInstr(new ConstantVal(Object::ZoneHandle()));
           AddInstruction(null_constant);
           StoreLocalComp* clear_local = new StoreLocalComp(
               *temp_local,
               new UseVal(null_constant),
               owner()->context_level());
           AddInstruction(new DoInstr(clear_local));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     const int num_params =
         owner()->parsed_function().function().NumberOfParameters();
     for (int pos = 0; pos < num_params; pos++) {
       const LocalVariable& parameter = *scope->VariableAt(pos);
       ASSERT(parameter.owner() == scope);
       if (!CanSkipTypeCheck(NULL, parameter.type())) {
         BindInstr* load =
-            new BindInstr(temp_index(),
-                          new LoadLocalComp(parameter,
+            new BindInstr(new LoadLocalComp(parameter,
                                             owner()->context_level()));
         AddInstruction(load);
         BuildAssertAssignable(parameter.token_index(),
                               new UseVal(load),
                               parameter.type(),
-                              parameter.name(),
-                              temp_index());
+                              parameter.name());
       }
     }
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) {
@@ skipping 706 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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