Reapply "Remove classes Computation and BindInstr."

runtime/vm/flow_graph.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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 534 matching lines @@
 
     // 2a. Handle uses:
     // Update expression stack environment for each use.
     // For each use of a LoadLocal or StoreLocal: Replace it with the value
     // from the environment.
     for (intptr_t i = current->InputCount() - 1; i >= 0; --i) {
       Value* v = current->InputAt(i);
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
-      Definition* input_defn = env->Last();
+      Definition* reaching_defn = env->Last();
       env->RemoveLast();
 
-      BindInstr* as_bind = v->definition()->AsBind();
-      if ((as_bind != NULL) &&
-          (as_bind->computation()->IsLoadLocal() ||
-           as_bind->computation()->IsStoreLocal())) {
+      Definition* input_defn = v->definition();
+      if (input_defn->IsLoadLocal() || input_defn->IsStoreLocal()) {
         // Remove the load/store from the graph.
-        as_bind->RemoveFromGraph();
+        input_defn->RemoveFromGraph();
         // Assert we are not referencing nulls in the initial environment.
-        ASSERT(input_defn->ssa_temp_index() != -1);
-        current->SetInputAt(i, new Value(input_defn));
+        ASSERT(reaching_defn->ssa_temp_index() != -1);
+        current->SetInputAt(i, new Value(reaching_defn));
       }
     }
 
     // Drop pushed arguments for calls.
     for (intptr_t j = 0; j < current->ArgumentCount(); j++) {
       env->RemoveLast();
     }
 
     // 2b. Handle LoadLocal and StoreLocal.
     // For each LoadLocal: Remove it from the graph.
     // For each StoreLocal: Remove it from the graph and update the environment.
-    BindInstr* bind = current->AsBind();
-    if (bind != NULL) {
-      LoadLocalComp* load = bind->computation()->AsLoadLocal();
-      StoreLocalComp* store = bind->computation()->AsStoreLocal();
+    Definition* definition = current->AsDefinition();
+    if (definition != NULL) {
+      LoadLocalInstr* load = definition->AsLoadLocal();
+      StoreLocalInstr* store = definition->AsStoreLocal();
       if ((load != NULL) || (store != NULL)) {
         intptr_t index;
         if (store != NULL) {
           index = store->local().BitIndexIn(non_copied_parameter_count_);
           // Update renaming environment.
           (*env)[index] = store->value()->definition();
         } else {
           // The graph construction ensures we do not have an unused LoadLocal
           // computation.
-          ASSERT(bind->is_used());
+          ASSERT(definition->is_used());
           index = load->local().BitIndexIn(non_copied_parameter_count_);
 
           PhiInstr* phi = (*env)[index]->AsPhi();
           if ((phi != NULL) && !phi->is_alive()) {
             phi->mark_alive();
             live_phis->Add(phi);
           }
         }
         // Update expression stack or remove from graph.
-        if (bind->is_used()) {
+        if (definition->is_used()) {
           env->Add((*env)[index]);
           // We remove load/store instructions when we find their use in 2a.
         } else {
           it.RemoveCurrentFromGraph();
         }
       } else {
         // Not a load or store.
-        if (bind->is_used()) {
+        if (definition->is_used()) {
           // Assign fresh SSA temporary and update expression stack.
-          bind->set_ssa_temp_index(alloc_ssa_temp_index());
-          env->Add(bind);
+          definition->set_ssa_temp_index(alloc_ssa_temp_index());
+          env->Add(definition);
         }
       }
     }
 
     // 2c. Handle pushed argument.
     PushArgumentInstr* push = current->AsPushArgument();
     if (push != NULL) {
       env->Add(push);
     }
   }
@@ skipping 71 matching lines @@
 
 
 // Inline a flow graph at a call site.
 //
 // Assumes the callee graph was computed with BuildGraphForInlining and
 // transformed to SSA with ComputeSSAForInlining, and that the use lists have
 // been correctly computed.
 //
 // After inlining the caller graph will correctly have adjusted the pre/post
 // orders, the dominator tree and the use lists.
-void FlowGraph::InlineCall(BindInstr* caller_instr,
-                           StaticCallComp* caller_comp,
-                           FlowGraph* callee_graph) {
+void FlowGraph::InlineCall(StaticCallInstr* call, FlowGraph* callee_graph) {
   ASSERT(callee_graph->exits() != NULL);
   ASSERT(callee_graph->graph_entry()->SuccessorCount() == 1);
   ASSERT(callee_graph->max_virtual_register_number() >
          max_virtual_register_number());
 
   // TODO(zerny): Implement support for callee graphs with control flow.
   ASSERT(callee_graph->preorder().length() == 2);
 
   // Adjust the SSA temp index by the callee graph's index.
   current_ssa_temp_index_ = callee_graph->max_virtual_register_number();
 
   TargetEntryInstr* callee_entry = callee_graph->graph_entry()->normal_entry();
   ZoneGrowableArray<ReturnInstr*>* callee_exits = callee_graph->exits();
 
   // 1. Insert the callee graph into the caller graph.
   if (callee_exits->length() == 1) {
     ReturnInstr* exit = (*callee_exits)[0];
     // TODO(zerny): Support one exit graph containing control flow.
     ASSERT(callee_entry == GetBlockEntry(exit));
     // For just one exit, replace the uses and remove the call from the graph.
-    caller_instr->ReplaceUsesWith(exit->value()->definition());
-    Link(caller_instr->previous(), callee_entry->next());
-    Link(exit->previous(), caller_instr->next());
+    call->ReplaceUsesWith(exit->value()->definition());
+    Link(call->previous(), callee_entry->next());
+    Link(exit->previous(), call->next());
   } else {
     // TODO(zerny): Support multiple exits.
     UNREACHABLE();
   }
 
   // TODO(zerny): Adjust pre/post orders.
   // TODO(zerny): Update dominator tree.
 
   // Remove original arguments to the call.
-  for (intptr_t i = 0; i < caller_comp->ArgumentCount(); ++i) {
-    PushArgumentInstr* push = caller_comp->ArgumentAt(i);
+  for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
+    PushArgumentInstr* push = call->ArgumentAt(i);
     push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
 }
 
 
 }  // namespace dart