Turn CopyTemp and SetTemp into instructions.

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/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
 #include "vm/os.h"
@@ skipping 311 matching lines @@
 void EffectGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (node->prefix()) {
     Bailout("IncrOpIndexed prefix");
   } else {
     // Leave a placeholder, evaluate receiver and index.
     //   t0 <- #0
     //   t1 <- ... receiver ...
     //   t2 <- ... index ...
     const Smi& placeholder = Smi::ZoneHandle(Smi::New(0));
-    AddInstruction(new BindInstr(temp_index(), new ConstantVal(placeholder)));
+    const int placeholder_index = temp_index();
+    AddInstruction(new BindInstr(placeholder_index,
+                                 new ConstantVal(placeholder)));
+
     ArgumentGraphVisitor for_array(owner(), temp_index() + 1);
     node->array()->Visit(&for_array);
     Append(for_array);
+    ASSERT(for_array.value()->IsTemp());
+    const int array_index = for_array.value()->AsTemp()->index();
+
     ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
     node->index()->Visit(&for_index);
     Append(for_index);
+    ASSERT(for_index.value()->IsTemp());
+    const int index_index = for_index.value()->AsTemp()->index();
 
     // Duplicate the receiver and index values, load the value.
-    //   t3 <- Copy(t1)
-    //   t4 <- Copy(t2)
+    //   t3 <- Pick(t1)
+    //   t4 <- Pick(t2)
     //   t3 <- InstanceCall([], t3, t4)
     int next_index = for_index.temp_index();
-    AddInstruction(new BindInstr(next_index, new CopyTempComp(-1)));
-    AddInstruction(new BindInstr(next_index + 1, new CopyTempComp(-1)));
+    AddInstruction(new PickTempInstr(next_index, array_index));
+    AddInstruction(new PickTempInstr(next_index + 1, index_index));
     ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
     arguments->Add(new TempVal(next_index));
     arguments->Add(new TempVal(next_index + 1));
     const String& load_name =
         String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
     InstanceCallComp* load =
         new InstanceCallComp(node->load_id(), node->token_index(), load_name,
                              arguments, Array::ZoneHandle(), 1);
     AddInstruction(new BindInstr(next_index, load));
 
     // Preserve the original value and then increment.
     //   t0 := t3
     //   t4 <- #1
     //   t3 <- InstanceCall(op, t3, t4)
-    AddInstruction(new DoInstr(new SetTempComp(-3)));
+    AddInstruction(new TuckTempInstr(placeholder_index, next_index));
     const Smi& one = Smi::ZoneHandle(Smi::New(1));
     AddInstruction(new BindInstr(next_index + 1, new ConstantVal(one)));
     arguments = new ZoneGrowableArray<Value*>(2);
     arguments->Add(new TempVal(next_index));
     arguments->Add(new TempVal(next_index + 1));
     const String& op_name = String::ZoneHandle(String::NewSymbol(
         (node->kind() == Token::kINCR) ? "+" : "-"));
     InstanceCallComp* add =
         new InstanceCallComp(node->operator_id(), node->token_index(), op_name,
                              arguments, Array::ZoneHandle(), 2);
@@ skipping 427 matching lines @@
 void FlowGraphPrinter::VisitTemp(TempVal* val) {
   OS::Print("t%d", val->index());
 }
 
 
 void FlowGraphPrinter::VisitConstant(ConstantVal* val) {
   OS::Print("#%s", val->instance().ToCString());
 }
 
 
-void FlowGraphPrinter::VisitCopyTemp(CopyTempComp* comp) {
-  OS::Print("CopyTemp(%d)", comp->index());
-}
-
-
-void FlowGraphPrinter::VisitSetTemp(SetTempComp* comp) {
-  OS::Print("SetTemp(%d)", comp->index());
-}
-
-
 void FlowGraphPrinter::VisitAssertAssignable(AssertAssignableComp* comp) {
   OS::Print("AssertAssignable(");
   comp->value()->Accept(this);
   OS::Print(", %s)", comp->type().ToCString());
 }
 
 
 void FlowGraphPrinter::VisitInstanceCall(InstanceCallComp* comp) {
   OS::Print("InstanceCall(%s", comp->function_name().ToCString());
   for (int i = 0; i < comp->ArgumentCount(); ++i) {
@@ skipping 97 matching lines @@
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", instr->block_number());
 }
 
 
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
   OS::Print("%2d: [target]", instr->block_number());
 }
 
 
+void FlowGraphPrinter::VisitPickTemp(PickTempInstr* instr) {
+  OS::Print("    t%d <- Pick(t%d)", instr->destination(), instr->source());
+}
+
+
+void FlowGraphPrinter::VisitTuckTemp(TuckTempInstr* instr) {
+  OS::Print("    t%d := t%d", instr->destination(), instr->source());
+}
+
+
 void FlowGraphPrinter::VisitDo(DoInstr* instr) {
   OS::Print("    ");
   instr->computation()->Accept(this);
 }
 
 
 void FlowGraphPrinter::VisitBind(BindInstr* instr) {
   OS::Print("    t%d <-", instr->temp_index());
   instr->computation()->Accept(this);
 }
@@ skipping 42 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