Make constants computations instead of values.

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 72 matching lines @@
   blocked_cpu_registers_[FPREG] = true;
 
   // XMM0 is used as scratch by optimized code and parallel move resolver.
   blocked_xmm_registers_[XMM0] = true;
 }
 
 
 // Remove environments from the instructions which can't deoptimize.
 // Replace dead phis uses with null values in environments.
 void FlowGraphAllocator::EliminateEnvironmentUses() {
-  ConstantVal* null_value = new ConstantVal(Object::ZoneHandle());
-
+  Definition* constant_null =
+      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;
 
           Definition* def = use->definition();
-
           PushArgumentInstr* push_argument = def->AsPushArgument();
           if ((push_argument != NULL) && push_argument->WasEliminated()) {
             (*values)[i] = push_argument->value()->CopyValue();
             continue;
           }
 
           PhiInstr* phi = def->AsPhi();
           if ((phi != NULL) && !phi->is_alive()) {
-            (*values)[i] = null_value;
+            (*values)[i] = new UseVal(constant_null);
             continue;
           }
         }
       } else {
         current->set_env(NULL);
       }
     }
   }
 }
 
@@ skipping 60 matching lines @@
                 live_in_[pred->postorder_number()]->Add(use);
               }
             }
           }
         }
       }
     }
   }
 
   // Process incoming parameters.
-  GraphEntryInstr* graph_entry = postorder_[block_count - 1]->AsGraphEntry();
+  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()) {
-      const intptr_t vreg = val->AsUse()->definition()->ssa_temp_index();
+      intptr_t vreg = val->AsUse()->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++) {
     UpdateLiveIn(*postorder_[i]);
   }
 }
 
 
 bool FlowGraphAllocator::UpdateLiveOut(const BlockEntryInstr& instr) {
   BitVector* live_out = live_out_[instr.postorder_number()];
@@ skipping 271 matching lines @@
   for (intptr_t i = 0; i < live_ranges_.length(); i++) {
     if (live_ranges_[i] != NULL) {
       live_ranges_[i]->Print();
     }
   }
 }
 
 
 void FlowGraphAllocator::BuildLiveRanges() {
   const intptr_t block_count = postorder_.length();
-  ASSERT(postorder_[block_count - 1]->IsGraphEntry());
+  ASSERT(postorder_.Last()->IsGraphEntry());
   for (intptr_t i = 0; i < (block_count - 1); i++) {
     BlockEntryInstr* block = postorder_[i];
 
     // For every SSA value that is live out of this block, create an interval
     // that covers the whole block.  It will be shortened if we encounter a
     // definition of this value in this block.
     for (BitVector::Iterator it(live_out_[i]); !it.Done(); it.Advance()) {
       LiveRange* range = GetLiveRange(it.Current());
       range->AddUseInterval(block->start_pos(), block->end_pos());
     }
 
     // Connect outgoing phi-moves that were created in NumberInstructions
     // and find last instruction that contributes to liveness.
     Instruction* current = ConnectOutgoingPhiMoves(block);
 
     // Now process all instructions in reverse order.
     while (current != block) {
       // Skip parallel moves that we insert while processing instructions.
       if (!current->IsParallelMove()) {
         ProcessOneInstruction(block, current);
       }
       current = current->previous();
     }
 
     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_[block_count - 1]->AsGraphEntry();
+  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()) {
-      ParameterInstr* param = val->AsUse()->definition()->AsParameter();
+    ASSERT(val->IsUse());
+    ParameterInstr* param = val->AsUse()->definition()->AsParameter();
+    if (param == NULL) continue;
 
-      LiveRange* range = GetLiveRange(param->ssa_temp_index());
-      range->AddUseInterval(graph_entry->start_pos(), graph_entry->end_pos());
-      range->DefineAt(graph_entry->start_pos());
+    // 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 ||
-             flow_graph_.non_copied_parameter_count() == 0);
-      // Slot index for the leftmost copied parameter is 0.
-      intptr_t slot_index = param->index();
-      // Slot index for the rightmost fixed parameter is -1.
-      slot_index -= flow_graph_.non_copied_parameter_count();
+    // 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 ||
+           flow_graph_.non_copied_parameter_count() == 0);
+    // Slot index for the leftmost copied parameter is 0.
+    intptr_t slot_index = param->index();
+    // Slot index for the rightmost fixed parameter is -1.
+    slot_index -= flow_graph_.non_copied_parameter_count();
 
-      range->set_assigned_location(Location::StackSlot(slot_index));
-      range->set_spill_slot(Location::StackSlot(slot_index));
-      if (flow_graph_.copied_parameter_count() > 0) {
-        ASSERT(spill_slots_.length() == slot_index);
-        spill_slots_.Add(range->End());
-      }
+    range->set_assigned_location(Location::StackSlot(slot_index));
+    range->set_spill_slot(Location::StackSlot(slot_index));
+    if (flow_graph_.copied_parameter_count() > 0) {
+      ASSERT(spill_slots_.length() == slot_index);
+      spill_slots_.Add(range->End());
+    }
 
-      AssignSafepoints(range);
+    AssignSafepoints(range);
 
-      range->finger()->Initialize(range);
-      UsePosition* use = range->finger()->FirstRegisterBeneficialUse(
-          graph_entry->start_pos());
-      if (use != NULL) {
-        LiveRange* tail = SplitBetween(range,
-                                       graph_entry->start_pos(),
-                                       use->pos());
-
-        // All incomming parameters are tagged.
-        CompleteRange(tail, Location::kRegister);
-      }
-      ConvertAllUses(range);
-      if (flow_graph_.copied_parameter_count() > 0) {
-        MarkAsObjectAtSafepoints(range);
-      }
+    range->finger()->Initialize(range);
+    UsePosition* use =
+        range->finger()->FirstRegisterBeneficialUse(graph_entry->start_pos());
+    if (use != NULL) {
+      LiveRange* tail =
+          SplitBetween(range, graph_entry->start_pos(), use->pos());
+      // All incoming parameters are tagged.
+      CompleteRange(tail, Location::kRegister);
+    }
+    ConvertAllUses(range);
+    if (flow_graph_.copied_parameter_count() > 0) {
+      MarkAsObjectAtSafepoints(range);
     }
   }
+
+  // Process global constants.
+  BindInstr* null_defn = graph_entry->constant_null()->AsBind();
+  LiveRange* range = GetLiveRange(null_defn->ssa_temp_index());
+  range->AddUseInterval(graph_entry->start_pos(), graph_entry->end_pos());
+  range->DefineAt(graph_entry->start_pos());
+  range->set_assigned_location(
+      Location::Constant(null_defn->computation()->AsConstant()->value()));
+  range->finger()->Initialize(range);
+  UsePosition* use =
+      range->finger()->FirstRegisterBeneficialUse(graph_entry->start_pos());
+  if (use != NULL) {
+    LiveRange* tail = SplitBetween(range, graph_entry->start_pos(), use->pos());
+    CompleteRange(tail, Location::kRegister);
+  }
+  ConvertAllUses(range);
 }
 
+
 //
 // When describing shape of live ranges in comments below we are going to use
 // the following notation:
 //
 //    B    block entry
 //    g g' start and end of goto instruction
 //    i i' start and end of any other instruction
 //    j j' start and end of any other instruction
 
 //    -  body of a use interval
@@ skipping 37 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);
-    if (val->IsUse()) {
-      // Expected shape of live ranges:
-      //
-      //                 g  g'
-      //      value    --*
-      //
+    ASSERT(val->IsUse());
+    // Expected shape of live ranges:
+    //
+    //                 g  g'
+    //      value    --*
+    //
 
-      LiveRange* range = GetLiveRange(
-          val->AsUse()->definition()->ssa_temp_index());
+    LiveRange* range =
+        GetLiveRange(val->AsUse()->definition()->ssa_temp_index());
 
-      range->AddUseInterval(block->start_pos(), pos);
-      range->AddHintedUse(pos, move->src_slot(), move->dest_slot());
+    range->AddUseInterval(block->start_pos(), pos);
+    range->AddHintedUse(pos, move->src_slot(), move->dest_slot());
 
-      move->set_src(Location::PrefersRegister());
-    } else {
-      ASSERT(val->IsConstant());
-      move->set_src(Location::Constant(val->AsConstant()->value()));
-    }
+    move->set_src(Location::PrefersRegister());
     move_idx++;
   }
 
   // Begin backward iteration with the instruction before the parallel
   // move.
   return goto_instr->previous();
 }
 
 
 void FlowGraphAllocator::ConnectIncomingPhiMoves(BlockEntryInstr* block) {
@@ skipping 65 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];
-    if (value->IsUse()) {
-      locations[i] = Location::Any();
-      Definition* def = value->AsUse()->definition();
+    ASSERT(value->IsUse());
+    locations[i] = Location::Any();
+    Definition* def = value->AsUse()->definition();
 
-      if (def->IsPushArgument()) {
-        // Frame size is unknown until after allocation.
-        locations[i] = Location::NoLocation();
-        continue;
-      }
+    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);
-      range->AddUse(use_pos, &locations[i]);
-    } else {
-      ASSERT(value->IsConstant());
-      locations[i] = Location::NoLocation();
-    }
+    const intptr_t vreg = def->ssa_temp_index();
+    LiveRange* range = GetLiveRange(vreg);
+    range->AddUseInterval(block_start_pos, use_pos);
+    range->AddUse(use_pos, &locations[i]);
   }
 
   env->set_locations(locations);
 }
 
 
 static Location::Kind RegisterKindFromPolicy(Location loc) {
   if (loc.policy() == Location::kRequiresXmmRegister) {
     return Location::kXmmRegister;
   } else {
@@ skipping 1380 matching lines @@
     OS::Print("-- [after ssa allocator] ir [%s] -------------\n",
               function.ToFullyQualifiedCString());
     FlowGraphPrinter printer(flow_graph_, true);
     printer.PrintBlocks();
     OS::Print("----------------------------------------------\n");
   }
 }
 
 
 }  // namespace dart