Introduce Definition and Use types.

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 117 matching lines @@
     body_exit->SetSuccessor(join);
   }
 
   // 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,
-                                           intptr_t start_index) {
-  AddInstruction(new BindInstr(start_index, new CurrentContextComp()));
-  StoreLocalComp* store_context = new StoreLocalComp(
-      variable,
-      new TempVal(start_index),
-      owner()->context_level());
+void EffectGraphVisitor::BuildStoreContext(const LocalVariable& variable) {
+  BindInstr* context = new BindInstr(temp_index(), 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, intptr_t start_index) {
-  LoadLocalComp* load_saved_context =
-      new LoadLocalComp(variable, owner()->context_level());
-  AddInstruction(new BindInstr(start_index, load_saved_context));
-  StoreContextComp* store_context =
-      new StoreContextComp(new TempVal(start_index));
-  AddInstruction(new DoInstr(store_context));
+void EffectGraphVisitor::BuildLoadContext(const LocalVariable& variable) {
+  BindInstr* load_saved_context =
+      new BindInstr(temp_index(),
+                    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) {
-    AssertBooleanComp* assert_boolean =
-        new AssertBooleanComp(condition_node_id(),
-                              condition_token_index(),
-                              owner()->try_index(),
-                              value);
-    AddInstruction(new BindInstr(temp_index(), assert_boolean));
-    value = new TempVal(temp_index());
+    BindInstr* assert_boolean =
+        new BindInstr(temp_index(),
+                      new AssertBooleanComp(condition_node_id(),
+                                            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 ArgumentGraphVisitor::ReturnValue(Value* value) {
   value_ = value;
   if (value->IsConstant()) {
-    AddInstruction(new BindInstr(temp_index(), value));
-    value_ = new TempVal(AllocateTempIndex());
+    BindInstr* defn = new BindInstr(temp_index(), value);
+    AddInstruction(defn);
+    value_ = new UseVal(defn);
+    AllocateTempIndex();
   }
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
 // <Statement> ::= Return { value:                <Expression>
@@ skipping 31 matching lines @@
                                           dst_type,
                                           dst_name,
                                           temp_index());
     }
   }
 
   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(), 0);
+    BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
-
   AddInstruction(
       new ReturnInstr(node->id(), node->token_index(), return_value));
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
@@ skipping 297 matching lines @@
   if (CanSkipTypeCheck(value, dst_type)) {
     return value;
   }
 
   // Build the type check computation.
   Value* instantiator_type_arguments = NULL;
   if (!dst_type.IsInstantiated()) {
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_index, start_index + 1);
   }
-  AssertAssignableComp* assert_assignable =
-      new AssertAssignableComp(node_id,
-                               token_index,
-                               owner()->try_index(),
-                               value,
-                               instantiator_type_arguments,
-                               dst_type,
-                               dst_name);
-  AddInstruction(new BindInstr(start_index, assert_assignable));
-  return new TempVal(start_index);
+  BindInstr* assert_assignable =
+      new BindInstr(start_index,
+                    new AssertAssignableComp(node_id,
+                                             token_index,
+                                             owner()->try_index(),
+                                             value,
+                                             instantiator_type_arguments,
+                                             dst_type,
+                                             dst_name));
+  AddInstruction(assert_assignable);
+  return new UseVal(assert_assignable);
 }
 
 
 void EffectGraphVisitor::BuildInstanceOf(ComparisonNode* node) {
   ASSERT(Token::IsInstanceofOperator(node->kind()));
   EffectGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
 }
 
@@ skipping 96 matching lines @@
     Append(for_left_value);
     ValueGraphVisitor for_right_value(owner(), for_left_value.temp_index());
     node->right()->Visit(&for_right_value);
     Append(for_right_value);
     EqualityCompareComp* comp = new EqualityCompareComp(
         node->id(), node->token_index(), owner()->try_index(),
         for_left_value.value(), for_right_value.value());
     if (node->kind() == Token::kEQ) {
       ReturnComputation(comp);
     } else {
-      AddInstruction(new BindInstr(temp_index(), comp));
-      Value* eq_result = new TempVal(temp_index());
+      Definition* eq_result = new BindInstr(temp_index(), comp);
+      AddInstruction(eq_result);
       if (FLAG_enable_type_checks) {
-        AssertBooleanComp* assert_boolean =
-            new AssertBooleanComp(node->id(),
-                                  node->token_index(),
-                                  owner()->try_index(),
-                                  eq_result);
-        AddInstruction(new BindInstr(temp_index(), assert_boolean));
-        eq_result = new TempVal(temp_index());
+        eq_result =
+            new BindInstr(temp_index(),
+                          new AssertBooleanComp(node->id(),
+                                                node->token_index(),
+                                                owner()->try_index(),
+                                                new UseVal(eq_result)));
+        AddInstruction(eq_result);
       }
-      BooleanNegateComp* negate = new BooleanNegateComp(eq_result);
+      BooleanNegateComp* negate = new BooleanNegateComp(new UseVal(eq_result));
       ReturnComputation(negate);
     }
     return;
   }
 
   ArgumentGraphVisitor for_left_value(owner(), temp_index());
   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);
@@ skipping 10 matching lines @@
 
 
 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) {
-      AssertBooleanComp* assert_boolean =
-          new AssertBooleanComp(node->operand()->id(),
-                                node->operand()->token_index(),
-                                owner()->try_index(),
-                                value);
-      AddInstruction(new BindInstr(temp_index(), assert_boolean));
-      value = new TempVal(temp_index());
+      BindInstr* assert_boolean =
+          new BindInstr(temp_index(),
+                        new AssertBooleanComp(node->operand()->id(),
+                                              node->operand()->token_index(),
+                                              owner()->try_index(),
+                                              value));
+      AddInstruction(assert_boolean);
+      value = new UseVal(assert_boolean);
     }
     BooleanNegateComp* negate = new BooleanNegateComp(value);
     ReturnComputation(negate);
     return;
   }
   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());
@@ skipping 915 matching lines @@
       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();
-    AddInstruction(new BindInstr(start_index, new ConstantVal(type_arguments)));
-    return new TempVal(start_index);
+    BindInstr* args =
+        new BindInstr(temp_index(), 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());

[srdjan, 2012/04/24 22:02:18]

Why temp_index() instead of start_index, it seems wrong?  Also above.

[Kevin Millikin (Google), 2012/04/25 08:50:51]

Oops, that's a stray change that crept in here.  I'll set it back to
start_index.

Intermediate-term (but real soon now) I'd like to get rid of the explicit
indexes in the graph builder.  It should be possible to teach the visitor to
track stack height and set it automatically on instructions that need it (e.g.,
Bind) by making adding a definition to the graph increment the stack height and
using a defintion decrement.

   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();
@@ skipping 455 matching lines @@
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
     }
   }
 
   if (is_open()) {
     if (MustSaveRestoreContext(node)) {
       ASSERT(num_context_variables > 0);
-      BuildLoadContext(*owner()->parsed_function().saved_context_var(), 0);
+      BuildLoadContext(*owner()->parsed_function().saved_context_var());
     } else if (num_context_variables > 0) {
       UnchainContext();
     }
   }
 
   // No continue on sequence allowed.
   ASSERT((node->label() == NULL) ||
          (node->label()->join_for_continue() == NULL));
   // If this node sequence is labeled, a break out of the sequence will have
   // taken care of unchaining the context.
@@ skipping 13 matching lines @@
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restores CTX from local variable ':saved_context'.
   CatchEntryComp* catch_entry = new CatchEntryComp(node->exception_var(),
                                                    node->stacktrace_var());
   AddInstruction(new DoInstr(catch_entry));
-  BuildLoadContext(node->context_var(), temp_index());
+  BuildLoadContext(node->context_var());
 
   EffectGraphVisitor for_catch(owner(), temp_index());
   node->VisitChildren(&for_catch);
   Append(for_catch);
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
   intptr_t old_try_index = owner()->try_index();
   intptr_t try_index = owner()->AllocateTryIndex();
   owner()->set_try_index(try_index);
 
   // Preserve CTX into local variable '%saved_context'.
-  BuildStoreContext(node->context_var(), temp_index());
+  BuildStoreContext(node->context_var());
 
   EffectGraphVisitor for_try_block(owner(), temp_index());
   node->try_block()->Visit(&for_try_block);
   Append(for_try_block);
 
   // We are done generating code for the try block.
   owner()->set_try_index(old_try_index);
 
   CatchClauseNode* catch_block = node->catch_block();
   if (catch_block != NULL) {
@@ skipping 65 matching lines @@
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     owner()->set_try_index((try_index - 1));
   }
-  BuildLoadContext(node->context_var(), temp_index());
+  BuildLoadContext(node->context_var());
   EffectGraphVisitor for_finally_block(owner(), temp_index());
   node->finally_block()->Visit(&for_finally_block);
   Append(for_finally_block);
   if (try_index >= 0) {
     owner()->set_try_index(try_index);
   }
 }
 
 
 // Graph printing.
@@ skipping 55 matching lines @@
     OS::Print("\n");
   }
 }
 
 
 void FlowGraphPrinter::VisitTemp(TempVal* val) {
   OS::Print("t%d", val->index());
 }
 
 
+void FlowGraphPrinter::VisitUse(UseVal* val) {
+  OS::Print("s%d", val->definition()->temp_index());
+}
+
+
 void FlowGraphPrinter::VisitConstant(ConstantVal* val) {
   OS::Print("#%s", val->value().ToCString());
 }
 
 
 void FlowGraphPrinter::VisitAssertAssignable(AssertAssignableComp* comp) {
   OS::Print("AssertAssignable(");
   comp->value()->Accept(this);
   OS::Print(", %s, '%s'",
             String::Handle(comp->dst_type().Name()).ToCString(),
@@ skipping 267 matching lines @@
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
   OS::Print("%2d: [target", reverse_index(instr->postorder_number()));
   if (instr->HasTryIndex()) {
     OS::Print(" catch %d]", instr->try_index());
   } else {
     OS::Print("]");
   }
 }
 
 
-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);
 }
 
 
+void FlowGraphPrinter::VisitPickTemp(PickTempInstr* instr) {
+  OS::Print("    t%d <- Pick(t%d)", instr->temp_index(), instr->source());
+}
+
+
+void FlowGraphPrinter::VisitTuckTemp(TuckTempInstr* instr) {
+  OS::Print("    t%d := t%d", instr->destination(), instr->source());
+}
+
+
 void FlowGraphPrinter::VisitReturn(ReturnInstr* instr) {
   OS::Print("    return ");
   instr->value()->Accept(this);
 }
 
 
 void FlowGraphPrinter::VisitThrow(ThrowInstr* instr) {
   OS::Print("Throw(");
   instr->exception()->Accept(this);
   OS::Print(")");
@@ skipping 154 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