Implement postfix indexed increment.

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 102 matching lines @@
   // 3. Set the exit to the graph to be empty or a fresh target node
   // depending on whether the false branch of the test is reachable.
   if (test_fragment.can_be_false()) {
     exit_ = *test_fragment.false_successor_address() = new TargetEntryInstr();
   } else {
     exit_ = NULL;
   }
 }
 
 
-void TestGraphVisitor::BranchOnValue(Value* value) {
+void TestGraphVisitor::ReturnValue(Value* value) {
   BranchInstr* branch = new BranchInstr(value);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void ArgumentGraphVisitor::ReturnValue(Value* value) {
   value_ = value;
@@ skipping 47 matching lines @@
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   ReturnValue(new ConstantVal(node->literal()));
 }
 
 void TestGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  BranchOnValue(new ConstantVal(node->literal()));
+  ReturnValue(new ConstantVal(node->literal()));
 }
 
 
 // Type nodes only occur as the right-hand side of instanceof comparisons,
 // and they are handled specially in that context.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
@@ skipping 21 matching lines @@
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ArgumentGraphVisitor for_right_value(owner(), for_left_value.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, name, arguments, Array::ZoneHandle(), 2);
+      new InstanceCallComp(node->id(), node->token_index(), name,

[srdjan, 2012/03/05 21:44:38]

FYI: In the old compiler node->id() is used for deoptimization purposes (deopt
points identifier) and for inline cache data mapping (code -> node). The new
compiler will probably have its own id-s, i.e., we may want to skip passing and
storing the AST's node-ids. It is OK to still pass them around, so that we can
compare and generate code that has the id-s added.

+                           arguments, Array::ZoneHandle(), 2);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStringConcatNode(StringConcatNode* node) {
   Bailout("EffectGraphVisitor::VisitStringConcatNode");
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
@@ skipping 23 matching lines @@
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   ArgumentGraphVisitor for_right_value(owner(), for_left_value.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, name, arguments, Array::ZoneHandle(), 2);
+      new InstanceCallComp(node->id(), node->token_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) {
     Bailout("EffectGraphVisitor::VisitUnaryOpNode NOT");
   }
   ArgumentGraphVisitor for_value(owner(), temp_index());
   node->operand()->Visit(&for_value);
   Append(for_value);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_value.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol((node->kind() == Token::kSUB)
                                                ? Token::Str(Token::kNEGATE)
                                                : node->Name()));
   InstanceCallComp* call =
-      new InstanceCallComp(node, name, arguments, Array::ZoneHandle(), 1);
+      new InstanceCallComp(node->id(), node->token_index(), name,
+                           arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpLocalNode");
 }
 
 
 void EffectGraphVisitor::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpInstanceFieldNode");
 }
 
 
 void EffectGraphVisitor::VisitIncrOpStaticFieldNode(
     IncrOpStaticFieldNode* node) {
   Bailout("EffectGraphVisitor::VisitIncrOpStaticFieldNode");
 }
 
 
 void EffectGraphVisitor::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
-  Bailout("EffectGraphVisitor::VisitIncrOpIndexedNode");
+  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)));
+    ArgumentGraphVisitor for_array(owner(), temp_index() + 1);
+    node->array()->Visit(&for_array);
+    Append(for_array);
+    ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
+    node->index()->Visit(&for_index);
+    Append(for_index);
+
+    // Duplicate the receiver and index values, load the value.
+    //   t3 <- Copy(t1)
+    //   t4 <- Copy(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)));
+    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)));
+    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);
+    AddInstruction(new BindInstr(next_index, add));
+
+    // Perform the store.
+    //  InstanceCallComp([]=, t1, t2, t3)
+    //  ... value is t0 ...
+    arguments = new ZoneGrowableArray<Value*>(3);
+    arguments->Add(for_array.value());
+    arguments->Add(for_index.value());
+    arguments->Add(new TempVal(next_index));
+    const String& store_name =
+        String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
+    InstanceCallComp* store =
+        new InstanceCallComp(node->store_id(), node->token_index(), store_name,
+                             arguments, Array::ZoneHandle(), 1);
+    AddInstruction(new DoInstr(store));
+
+    ReturnValue(new TempVal(AllocateTempIndex()));
+  }
 }
 
 
 void EffectGraphVisitor::VisitConditionalExprNode(ConditionalExprNode* node) {
   Bailout("EffectGraphVisitor::VisitConditionalExprNode");
 }
 
 
 // <Statement> ::= If { condition: <Expression>
 //                      true_branch: <Sequence>
@@ skipping 86 matching lines @@
   int length = arguments->length();
   ZoneGrowableArray<Value*>* values = new ZoneGrowableArray<Value*>(length + 1);
 
   ArgumentGraphVisitor 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);
   InstanceCallComp* call =
-      new InstanceCallComp(node, node->function_name(), values,
+      new InstanceCallComp(node->id(), node->token_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);
@@ skipping 20 matching lines @@
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ArgumentGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(1);
   arguments->Add(for_receiver.value());
   const String& name =
       String::ZoneHandle(Field::GetterSymbol(node->field_name()));
   InstanceCallComp* call =
-      new InstanceCallComp(node, name, arguments, Array::ZoneHandle(), 1);
+      new InstanceCallComp(node->id(), node->token_index(), name,
+                           arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitInstanceSetterNode(InstanceSetterNode* node) {
   ArgumentGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   ArgumentGraphVisitor for_value(owner(), for_receiver.temp_index());
   node->value()->Visit(&for_value);
@@ skipping 90 matching lines @@
   Append(for_array);
   ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
   Append(for_index);
   ZoneGrowableArray<Value*>* arguments = new ZoneGrowableArray<Value*>(2);
   arguments->Add(for_array.value());
   arguments->Add(for_index.value());
   const String& name =
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kINDEX)));
   InstanceCallComp* call =
-      new InstanceCallComp(node, name, arguments, Array::ZoneHandle(), 1);
+      new InstanceCallComp(node->id(), node->token_index(), name,
+                           arguments, Array::ZoneHandle(), 1);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ArgumentGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   ArgumentGraphVisitor for_index(owner(), for_array.temp_index());
   node->index_expr()->Visit(&for_index);
@@ skipping 104 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 127 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