Eliminate class UseVal.

runtime/vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/hash_map.h"
 #include "vm/il_printer.h"
@@ skipping 136 matching lines @@
 static bool HasOnlyTwoDouble(const ICData& ic_data) {
   return (ic_data.NumberOfChecks() == 1) &&
       ICDataHasReceiverArgumentClassIds(ic_data, kDoubleCid, kDoubleCid);
 }
 
 
 static void RemovePushArguments(InstanceCallComp* comp) {
   // Remove original push arguments.
   for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     PushArgumentInstr* push = comp->ArgumentAt(i);
-    push->ReplaceUsesWith(push->value()->AsUse()->definition());
+    push->ReplaceUsesWith(push->value()->definition());
     push->RemoveFromGraph();
   }
 }
 
 
 // Returns true if all targets are the same.
 // TODO(srdjan): if targets are native use their C_function to compare.
 static bool HasOneTarget(const ICData& ic_data) {
   ASSERT(ic_data.NumberOfChecks() > 0);
   const Function& first_target = Function::Handle(ic_data.GetTargetAt(0));
@@ skipping 49 matching lines @@
       // Stores are only specialized for Array and GrowableObjectArray,
       // not for ImmutableArray.
       if (op_kind == Token::kASSIGN_INDEX) return false;
       // Fall through.
     case kArrayCid:
     case kGrowableObjectArrayCid: {
       Value* array = comp->ArgumentAt(0)->value();
       Value* index = comp->ArgumentAt(1)->value();
       // Insert class check and index smi checks and attach a copy of the
       // original environment because the operation can still deoptimize.
-      AddCheckClass(instr, comp, array->CopyValue());
+      AddCheckClass(instr, comp, array->Copy());
       InsertBefore(instr,
-                   new CheckSmiComp(index->CopyValue(), comp),
+                   new CheckSmiComp(index->Copy(), comp),
                    instr->env(),
                    BindInstr::kUnused);
       // Insert array bounds check.
       InsertBefore(instr,
-                   new CheckArrayBoundComp(array->CopyValue(),
-                                           index->CopyValue(),
+                   new CheckArrayBoundComp(array->Copy(),
+                                           index->Copy(),
                                            class_id,
                                            comp),
                    instr->env(),
                    BindInstr::kUnused);
       Computation* array_op = NULL;
       if (op_kind == Token::kINDEX) {
         array_op = new LoadIndexedComp(array, index, class_id);
       } else {
         Value* value = comp->ArgumentAt(2)->value();
         array_op = new StoreIndexedComp(array, index, value, class_id);
@@ skipping 95 matching lines @@
       // Check that either left or right are not a smi.  Result or a
       // binary operation with two smis is a smi not a double.
       InsertBefore(instr,
                    new CheckEitherNonSmiComp(left, right, comp),
                    instr->env(),
                    BindInstr::kUnused);
 
       // Unbox operands.
       BindInstr* unbox_left = InsertBefore(
           instr,
-          new UnboxDoubleComp(left->CopyValue(), comp),
+          new UnboxDoubleComp(left->Copy(), comp),
           instr->env(),
           BindInstr::kUsed);
       BindInstr* unbox_right = InsertBefore(
           instr,
-          new UnboxDoubleComp(right->CopyValue(), comp),
+          new UnboxDoubleComp(right->Copy(), comp),
           instr->env(),
           BindInstr::kUsed);
 
       UnboxedDoubleBinaryOpComp* double_bin_op =
           new UnboxedDoubleBinaryOpComp(op_kind,
-                                        new UseVal(unbox_left),
-                                        new UseVal(unbox_right));
+                                        new Value(unbox_left),
+                                        new Value(unbox_right));
       double_bin_op->set_ic_data(comp->ic_data());
       instr->set_computation(double_bin_op);
 
       if (instr->is_used()) {
         // Box result.
-        UseVal* use_val = new UseVal(instr);
+        Value* value = new Value(instr);
         BindInstr* bind = InsertAfter(instr,
-                                      new BoxDoubleComp(use_val, comp),
+                                      new BoxDoubleComp(value, comp),
                                       NULL,
                                       BindInstr::kUsed);
         instr->ReplaceUsesWith(bind);
       }
 
       RemovePushArguments(comp);
     } else {
       BinaryDoubleOpComp* double_bin_op = new BinaryDoubleOpComp(op_kind, comp);
       double_bin_op->set_ic_data(comp->ic_data());
       instr->set_computation(double_bin_op);
     }
   } else if (operands_type == kMintCid) {
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
     BinaryMintOpComp* bin_op = new BinaryMintOpComp(op_kind,
                                                     comp,
                                                     left,
                                                     right);
     bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
   } else {
     ASSERT(operands_type == kSmiCid);
     Value* left = comp->ArgumentAt(0)->value();
     Value* right = comp->ArgumentAt(1)->value();
     // Insert two smi checks and attach a copy of the original
     // environment because the smi operation can still deoptimize.
     InsertBefore(instr,
-                 new CheckSmiComp(left->CopyValue(), comp),
+                 new CheckSmiComp(left->Copy(), comp),
                  instr->env(),
                  BindInstr::kUnused);
     InsertBefore(instr,
-                 new CheckSmiComp(right->CopyValue(), comp),
+                 new CheckSmiComp(right->Copy(), comp),
                  instr->env(),
                  BindInstr::kUnused);
     BinarySmiOpComp* bin_op = new BinarySmiOpComp(op_kind,
                                                   comp,
                                                   left,
                                                   right);
     bin_op->set_ic_data(comp->ic_data());
     instr->set_computation(bin_op);
     RemovePushArguments(comp);
   }
   return true;
 }
 
 
 bool FlowGraphOptimizer::TryReplaceWithUnaryOp(BindInstr* instr,
                                                InstanceCallComp* comp,
                                                Token::Kind op_kind) {
   if (comp->ic_data()->NumberOfChecks() != 1) {
     // TODO(srdjan): Not yet supported.
     return false;
   }
   ASSERT(comp->ArgumentCount() == 1);
   Computation* unary_op = NULL;
   if (HasOneSmi(*comp->ic_data())) {
     Value* value = comp->ArgumentAt(0)->value();
     InsertBefore(instr,
-                 new CheckSmiComp(value->CopyValue(), comp),
+                 new CheckSmiComp(value->Copy(), comp),
                  instr->env(),
                  BindInstr::kUnused);
     unary_op = new UnarySmiOpComp(op_kind,
                                   (op_kind == Token::kNEGATE) ? comp : NULL,
                                   value);
   } else if (HasOneDouble(*comp->ic_data()) && (op_kind == Token::kNEGATE)) {
     unary_op = new NumberNegateComp(comp, comp->ArgumentAt(0)->value());
   }
   if (unary_op == NULL) return false;
 
@@ skipping 37 matching lines @@
     if (!HasOneTarget(ic_data)) {
       // TODO(srdjan): Implement for mutiple targets.
       return false;
     }
     // Inline implicit instance getter.
     const String& field_name =
         String::Handle(Field::NameFromGetter(comp->function_name()));
     const Field& field = Field::Handle(GetField(class_ids[0], field_name));
     ASSERT(!field.IsNull());
 
-    AddCheckClass(instr, comp, comp->ArgumentAt(0)->value()->CopyValue());
+    AddCheckClass(instr, comp, comp->ArgumentAt(0)->value()->Copy());
     // Detach environment from the original instruction because it can't
     // deoptimize.
     instr->set_env(NULL);
     LoadInstanceFieldComp* load =
         new LoadInstanceFieldComp(field, comp->ArgumentAt(0)->value());
     instr->set_computation(load);
     RemovePushArguments(comp);
     return true;
   }
 
@@ skipping 116 matching lines @@
     }
     const intptr_t kMaxChecks = 4;
     if (comp->ic_data()->NumberOfChecks() <= kMaxChecks) {
       const ICData& unary_checks =
           ICData::ZoneHandle(comp->ic_data()->AsUnaryClassChecks());
       bool call_with_checks;
       // TODO(srdjan): Add check class comp for mixed smi/non-smi.
       if (HasOneTarget(unary_checks) &&
           (unary_checks.GetReceiverClassIdAt(0) != kSmiCid)) {
         // Type propagation has not run yet, we cannot eliminate the check.
-        AddCheckClass(instr, comp, comp->ArgumentAt(0)->value()->CopyValue());
+        AddCheckClass(instr, comp, comp->ArgumentAt(0)->value()->Copy());
         // Call can still deoptimize, do not detach environment from instr.
         call_with_checks = false;
       } else {
         call_with_checks = true;
       }
       PolymorphicInstanceCallComp* call =
           new PolymorphicInstanceCallComp(comp, call_with_checks);
       call->set_ic_data(&unary_checks);
       instr->set_computation(call);
     }
@@ skipping 37 matching lines @@
     // Not an implicit setter.
     // TODO(srdjan): Inline special setters.
     return false;
   }
   // Inline implicit instance setter.
   const String& field_name =
       String::Handle(Field::NameFromSetter(comp->function_name()));
   const Field& field = Field::Handle(GetField(class_id, field_name));
   ASSERT(!field.IsNull());
 
-  AddCheckClass(instr, comp, comp->ArgumentAt(0)->value()->CopyValue());
+  AddCheckClass(instr, comp, comp->ArgumentAt(0)->value()->Copy());
   // Detach environment from the original instruction because it can't
   // deoptimize.
   instr->set_env(NULL);
   StoreInstanceFieldComp* store = new StoreInstanceFieldComp(
       field,
       comp->ArgumentAt(0)->value(),
       comp->ArgumentAt(1)->value());
   instr->set_computation(store);
   RemovePushArguments(comp);
   return true;
@@ skipping 63 matching lines @@
 
 
 void FlowGraphTypePropagator::VisitAssertAssignable(AssertAssignableComp* comp,
                                                     BindInstr* instr) {
   if (FLAG_eliminate_type_checks &&
       !comp->is_eliminated() &&
       comp->value()->CompileTypeIsMoreSpecificThan(comp->dst_type())) {
     // TODO(regis): Remove is_eliminated_ field and support.
     comp->eliminate();
 
-    UseVal* use = comp->value()->AsUse();
+    Value* use = comp->value();
     ASSERT(use != NULL);
     Definition* result = use->definition();
     ASSERT(result != NULL);
     // Replace uses and remove the current instructions via the iterator.
     instr->ReplaceUsesWith(result);
     ASSERT(current_iterator()->Current() == instr);
     current_iterator()->RemoveCurrentFromGraph();
     if (FLAG_trace_optimization) {
       OS::Print("Replacing v%d with v%d\n",
                 instr->ssa_temp_index(),
@@ skipping 22 matching lines @@
   // type (bool) may still hold null at run time and therefore fail the test.
   if (FLAG_eliminate_type_checks &&
       !comp->is_eliminated() &&
       comp->value()->BindsToConstant() &&
       !comp->value()->BindsToConstantNull() &&
       comp->value()->CompileTypeIsMoreSpecificThan(
           Type::Handle(Type::BoolType()))) {
     // TODO(regis): Remove is_eliminated_ field and support.
     comp->eliminate();
 
-    UseVal* use = comp->value()->AsUse();
-    ASSERT(use != NULL);
+    Value* use = comp->value();
     Definition* result = use->definition();
     ASSERT(result != NULL);
     // Replace uses and remove the current instructions via the iterator.
     instr->ReplaceUsesWith(result);
     ASSERT(current_iterator()->Current() == instr);
     current_iterator()->RemoveCurrentFromGraph();
     if (FLAG_trace_optimization) {
       OS::Print("Replacing v%d with v%d\n",
                 instr->ssa_temp_index(),
                 result->ssa_temp_index());
@@ skipping 19 matching lines @@
 
   // We can only eliminate an 'instance of' test when the checked value is
   // a constant time constant. Indeed, a variable of the proper compile time
   // type may still hold null at run time and therefore fail the test.
   // We do not bother checking for Object destination type, since the graph
   // builder did already.
   if (FLAG_eliminate_type_checks &&
       comp->value()->BindsToConstant() &&
       !comp->value()->BindsToConstantNull() &&
       comp->value()->CompileTypeIsMoreSpecificThan(comp->type())) {
-    UseVal* use = comp->value()->AsUse();
-    ASSERT(use != NULL);
+    Value* use = comp->value();
     Definition* result = use->definition();
     ASSERT(result != NULL);
     // Replace uses and remove the current instructions via the iterator.
     instr->ReplaceUsesWith(result);
     ASSERT(current_iterator()->Current() == instr);
     current_iterator()->RemoveCurrentFromGraph();
     if (FLAG_trace_optimization) {
       OS::Print("Replacing v%d with v%d\n",
                 instr->ssa_temp_index(),
                 result->ssa_temp_index());
@@ skipping 12 matching lines @@
 }
 
 
 void FlowGraphTypePropagator::VisitGraphEntry(GraphEntryInstr* graph_entry) {
   if (graph_entry->start_env() == NULL) {
     return;
   }
   // Visit incoming parameters.
   for (intptr_t i = 0; i < graph_entry->start_env()->values().length(); i++) {
     Value* val = graph_entry->start_env()->values()[i];
-    if (val->IsUse()) {
-      ParameterInstr* param = val->AsUse()->definition()->AsParameter();
-      if (param != NULL) {
-        ASSERT(param->index() == i);
-        VisitParameter(param);
-      }
+    ParameterInstr* param = val->definition()->AsParameter();
+    if (param != NULL) {
+      ASSERT(param->index() == i);
+      VisitParameter(param);
     }
   }
 }
 
 
 void FlowGraphTypePropagator::VisitJoinEntry(JoinEntryInstr* join_entry) {
   if (join_entry->phis() != NULL) {
     for (intptr_t i = 0; i < join_entry->phis()->length(); ++i) {
       PhiInstr* phi = (*join_entry->phis())[i];
       if (phi != NULL) {
@@ skipping 167 matching lines @@
       DirectChainedHashMap<BindInstr*> child_map(*map);  // Copy map.
       OptimizeRecursive(child, &child_map);
     } else {
       OptimizeRecursive(child, map);  // Reuse map for the last child.
     }
   }
 }
 
 
 }  // namespace dart