Eliminate class UseVal.

runtime/vm/flow_graph_allocator.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_allocator.h"
 
 #include "vm/bit_vector.h"
 #include "vm/intermediate_language.h"
 #include "vm/il_printer.h"
 #include "vm/flow_graph.h"
@@ skipping 83 matching lines @@
       postorder_.Last()->AsGraphEntry()->constant_null();
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* block = block_order_[i];
     if (block->IsJoinEntry()) block->AsJoinEntry()->RemoveDeadPhis();
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       Instruction* current = it.Current();
       if (current->CanDeoptimize()) {
         ASSERT(current->env() != NULL);
         GrowableArray<Value*>* values = current->env()->values_ptr();
         for (intptr_t i = 0; i < values->length(); i++) {
-          UseVal* use = (*values)[i]->AsUse();
-          if (use == NULL) continue;
-
+          Value* use = (*values)[i];
           Definition* def = use->definition();
           PushArgumentInstr* push_argument = def->AsPushArgument();
           if ((push_argument != NULL) && push_argument->WasEliminated()) {
-            (*values)[i] = push_argument->value()->CopyValue();
+            (*values)[i] = push_argument->value()->Copy();
             continue;
           }
 
           PhiInstr* phi = def->AsPhi();
           if ((phi != NULL) && !phi->is_alive()) {
-            (*values)[i] = new UseVal(constant_null);
+            (*values)[i] = new Value(constant_null);
             continue;
           }
         }
       } else {
         current->set_env(NULL);
       }
     }
   }
 }
 
@@ skipping 13 matching lines @@
       // Handle definitions.
       Definition* current_def = current->AsDefinition();
       if ((current_def != NULL) && current_def->HasSSATemp()) {
         kill->Add(current_def->ssa_temp_index());
         live_in->Remove(current_def->ssa_temp_index());
       }
 
       // Handle uses.
       for (intptr_t j = 0; j < current->InputCount(); j++) {
         Value* input = current->InputAt(j);
-        if (input->IsUse()) {
-          const intptr_t use = input->AsUse()->definition()->ssa_temp_index();
-          live_in->Add(use);
-        }
+        const intptr_t use = input->definition()->ssa_temp_index();
+        live_in->Add(use);
       }
 
       // Add uses from the deoptimization environment.
       if (current->env() != NULL) {
         const GrowableArray<Value*>& values = current->env()->values();
         for (intptr_t j = 0; j < values.length(); j++) {
-          UseVal* use_val = values[j]->AsUse();
-          if ((use_val != NULL) && !use_val->definition()->IsPushArgument()) {
-            live_in->Add(use_val->definition()->ssa_temp_index());
+          Value* value = values[j];
+          if (!value->definition()->IsPushArgument()) {
+            live_in->Add(value->definition()->ssa_temp_index());
           }
         }
       }
     }
 
     // Handle phis.
     if (block->IsJoinEntry()) {
       JoinEntryInstr* join = block->AsJoinEntry();
       if (join->phis() != NULL) {
         for (intptr_t j = 0; j < join->phis()->length(); j++) {
           PhiInstr* phi = (*join->phis())[j];
           if (phi == NULL) continue;
 
           kill->Add(phi->ssa_temp_index());
           live_in->Remove(phi->ssa_temp_index());
 
           // If phi-operand is not defined by a predecessor it must be marked
           // live-in for a predecessor.
           for (intptr_t k = 0; k < phi->InputCount(); k++) {
             Value* val = phi->InputAt(k);
-            if (val->IsUse()) {
-              BlockEntryInstr* pred = block->PredecessorAt(k);
-              const intptr_t use = val->AsUse()->definition()->ssa_temp_index();
-              if (!kill_[pred->postorder_number()]->Contains(use)) {
-                live_in_[pred->postorder_number()]->Add(use);
-              }
+            BlockEntryInstr* pred = block->PredecessorAt(k);
+            const intptr_t use = val->definition()->ssa_temp_index();
+            if (!kill_[pred->postorder_number()]->Contains(use)) {
+              live_in_[pred->postorder_number()]->Add(use);
             }
           }
         }
       }
     }
   }
 
   // Process incoming parameters.
   GraphEntryInstr* graph_entry = postorder_.Last()->AsGraphEntry();
   for (intptr_t i = 0; i < graph_entry->start_env()->values().length(); i++) {
     Value* val = graph_entry->start_env()->values()[i];
-    if (val->IsUse()) {
-      intptr_t vreg = val->AsUse()->definition()->ssa_temp_index();
-      kill_[graph_entry->postorder_number()]->Add(vreg);
-      live_in_[graph_entry->postorder_number()]->Remove(vreg);
-    }
+    intptr_t vreg = val->definition()->ssa_temp_index();
+    kill_[graph_entry->postorder_number()]->Add(vreg);
+    live_in_[graph_entry->postorder_number()]->Remove(vreg);
   }
 
   // Process global constants.
   intptr_t vreg = graph_entry->constant_null()->ssa_temp_index();
   kill_[graph_entry->postorder_number()]->Add(vreg);
   live_in_[graph_entry->postorder_number()]->Remove(vreg);
 
   // Update initial live_in sets to match live_out sets. Has to be
   // done in a separate path because of backwards branches.
   for (intptr_t i = 0; i < block_count; i++) {
@@ skipping 311 matching lines @@
     }
 
     ConnectIncomingPhiMoves(block);
   }
 
   // Process incoming parameters.  Do this after all other instructions so
   // that safepoints for all calls have already been found.
   GraphEntryInstr* graph_entry = postorder_.Last()->AsGraphEntry();
   for (intptr_t i = 0; i < graph_entry->start_env()->values().length(); i++) {
     Value* val = graph_entry->start_env()->values()[i];
-    ASSERT(val->IsUse());
-    ParameterInstr* param = val->AsUse()->definition()->AsParameter();
+    ParameterInstr* param = val->definition()->AsParameter();
     if (param == NULL) continue;
 
     // Handle the parameters specially.  They are spilled on entry.
     LiveRange* range = GetLiveRange(param->ssa_temp_index());
     range->AddUseInterval(graph_entry->start_pos(), graph_entry->end_pos());
     range->DefineAt(graph_entry->start_pos());
 
     // Assert that copied and non-copied parameters are mutually exclusive.
     // This might change in the future and, if so, the index will be wrong.
     ASSERT(flow_graph_.copied_parameter_count() == 0 ||
@@ skipping 95 matching lines @@
 
   // Record the corresponding phi input use for each phi.
   ZoneGrowableArray<PhiInstr*>* phis = join->phis();
   intptr_t move_idx = 0;
   for (intptr_t phi_idx = 0; phi_idx < phis->length(); phi_idx++) {
     PhiInstr* phi = (*phis)[phi_idx];
     if (phi == NULL) continue;
 
     Value* val = phi->InputAt(pred_idx);
     MoveOperands* move = parallel_move->MoveOperandsAt(move_idx);
-    ASSERT(val->IsUse());
     // Expected shape of live ranges:
     //
     //                 g  g'
     //      value    --*
     //
 
-    LiveRange* range =
-        GetLiveRange(val->AsUse()->definition()->ssa_temp_index());
+    LiveRange* range = GetLiveRange(val->definition()->ssa_temp_index());
 
     range->AddUseInterval(block->start_pos(), pos);
     range->AddHintedUse(pos, move->src_slot(), move->dest_slot());
 
     move->set_src(Location::PrefersRegister());
     move_idx++;
   }
 
   // Begin backward iteration with the instruction before the parallel
   // move.
@@ skipping 70 matching lines @@
   if (values.length() == 0) return;
 
   const intptr_t block_start_pos = block->start_pos();
   const intptr_t use_pos = current->lifetime_position() + 1;
 
   Location* locations =
       Isolate::Current()->current_zone()->Alloc<Location>(values.length());
 
   for (intptr_t i = 0; i < values.length(); ++i) {
     Value* value = values[i];
-    ASSERT(value->IsUse());
     locations[i] = Location::Any();
-    Definition* def = value->AsUse()->definition();
+    Definition* def = value->definition();
 
     if (def->IsPushArgument()) {
       // Frame size is unknown until after allocation.
       locations[i] = Location::NoLocation();
       continue;
     }
 
     const intptr_t vreg = def->ssa_temp_index();
     LiveRange* range = GetLiveRange(vreg);
     range->AddUseInterval(block_start_pos, use_pos);
@@ skipping 49 matching lines @@
   // Add uses from the deoptimization environment.
   if (current->env() != NULL) ProcessEnvironmentUses(block, current);
 
   // Process inputs.
   // Skip the first input if output is specified with kSameAsFirstInput policy,
   // they will be processed together at the very end.
   for (intptr_t j = output_same_as_first_input ? 1 : 0;
        j < current->InputCount();
        j++) {
     Value* input = current->InputAt(j);
-    ASSERT(input->IsUse());  // Can not be a constant currently.
-    const intptr_t vreg = input->AsUse()->definition()->ssa_temp_index();
+    const intptr_t vreg = input->definition()->ssa_temp_index();
     LiveRange* range = GetLiveRange(vreg);
 
     Location* in_ref = locs->in_slot(j);
 
     if (in_ref->IsMachineRegister()) {
       // Input is expected in a fixed register. Expected shape of
       // live ranges:
       //
       //                 j' i  i'
       //      value    --*
@@ skipping 138 matching lines @@
            locs->in(0).Equals(Location::RequiresXmmRegister()));
 
     // Create move that will copy value between input and output.
     locs->set_out(Location::RequiresRegister());
     MoveOperands* move = AddMoveAt(pos,
                                    Location::RequiresRegister(),
                                    Location::Any());
 
     // Add uses to the live range of the input.
     Value* input = current->InputAt(0);
-    ASSERT(input->IsUse());  // Can not be a constant currently.
-    LiveRange* input_range = GetLiveRange(
-      input->AsUse()->definition()->ssa_temp_index());
+    LiveRange* input_range =
+        GetLiveRange(input->definition()->ssa_temp_index());
     input_range->AddUseInterval(block->start_pos(), pos);
     input_range->AddUse(pos, move->src_slot());
 
     // Shorten output live range to the point of definition and add both input
     // and output uses slots to be filled by allocator.
     range->DefineAt(pos);
     range->AddHintedUse(pos, out, move->src_slot());
     range->AddUse(pos, move->dest_slot());
     range->AddUse(pos, locs->in_slot(0));
   } else {
@@ skipping 1159 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart