Eliminate class UseVal.

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 49 matching lines @@
       current->set_previous(previous);
       previous = current;
     }
   }
 }
 
 
 #ifdef DEBUG
 // Debugging code to verify the construction of use lists.
 
-static intptr_t MembershipCount(UseVal* use, UseVal* list) {
+static intptr_t MembershipCount(Value* use, Value* list) {
   intptr_t count = 0;
   while (list != NULL) {
     if (list == use) ++count;
     list = list->next_use();
   }
   return count;
 }
 
 
 static void ResetUseListsInInstruction(Instruction* instr) {
   Definition* defn = instr->AsDefinition();
   if (defn != NULL) {
     defn->set_input_use_list(NULL);
     defn->set_env_use_list(NULL);
   }
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
-    UseVal* use = instr->InputAt(i)->AsUse();
-    if (use == NULL) continue;
+    Value* use = instr->InputAt(i);
     use->set_instruction(NULL);
     use->set_use_index(-1);
     use->set_next_use(NULL);
   }
   if (instr->env() != NULL) {
     for (intptr_t i = 0; i < instr->env()->values().length(); ++i) {
-      UseVal* use = instr->env()->values()[i]->AsUse();
-      if (use == NULL) continue;
+      Value* use = instr->env()->values()[i];
       use->set_instruction(NULL);
       use->set_use_index(-1);
       use->set_next_use(NULL);
     }
   }
 }
 
 
 bool FlowGraph::ResetUseLists() {
   // Reset global constants.
   ResetUseListsInInstruction(graph_entry_->constant_null());
 
   // Reset definitions referenced from the start environment.
   for (intptr_t i = 0; i < graph_entry_->start_env()->values().length(); ++i) {
-    UseVal* env_use = graph_entry_->start_env()->values()[i]->AsUse();
-    if (env_use != NULL) ResetUseListsInInstruction(env_use->definition());
+    Value* env_use = graph_entry_->start_env()->values()[i];
+    ResetUseListsInInstruction(env_use->definition());
   }
 
   // Reset phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
     if (join != NULL && join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) ResetUseListsInInstruction(phi);
       }
     }
     for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
       ResetUseListsInInstruction(it.Current());
     }
   }
   return true;  // Return true so we can ASSERT the reset code.
 }
 
 
 static void ValidateUseListsInInstruction(Instruction* instr) {
   ASSERT(instr != NULL);
   ASSERT(!instr->IsJoinEntry());
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
-    UseVal* use = instr->InputAt(i)->AsUse();
-    if (use == NULL) continue;
+    Value* use = instr->InputAt(i);
     ASSERT(use->use_index() == i);
     ASSERT(1 == MembershipCount(use, use->definition()->input_use_list()));
   }
   Environment* env = instr->env();
   if (env != NULL) {
     for (intptr_t i = 0; i < env->values().length(); ++i) {
-      UseVal* use = env->values()[i]->AsUse();
-      if (use == NULL) continue;
+      Value* use = env->values()[i];
       ASSERT(use->use_index() == i);
       ASSERT(1 == MembershipCount(use, use->definition()->env_use_list()));
     }
   }
   Definition* defn = instr->AsDefinition();
   if (defn != NULL) {
-    for (UseVal* use = defn->input_use_list();
+    for (Value* use = defn->input_use_list();
          use != NULL;
          use = use->next_use()) {
       ASSERT(defn == use->definition());
       ASSERT(use == use->instruction()->InputAt(use->use_index()));
     }
-    for (UseVal* use = defn->env_use_list();
+    for (Value* use = defn->env_use_list();
          use != NULL;
          use = use->next_use()) {
       ASSERT(defn == use->definition());
       ASSERT(use == use->instruction()->env()->values()[use->use_index()]);
     }
   }
 }
 
 
 bool FlowGraph::ValidateUseLists() {
   // Validate global constants.
   ValidateUseListsInInstruction(graph_entry_->constant_null());
 
   // Validate definitions referenced from the start environment.
   for (intptr_t i = 0; i < graph_entry_->start_env()->values().length(); ++i) {
-    UseVal* env_use = graph_entry_->start_env()->values()[i]->AsUse();
-    if (env_use != NULL) ValidateUseListsInInstruction(env_use->definition());
+    Value* env_use = graph_entry_->start_env()->values()[i];
+    ValidateUseListsInInstruction(env_use->definition());
   }
 
   // Validate phis in join entries and the instructions in each block.
   for (intptr_t i = 0; i < preorder_.length(); ++i) {
     BlockEntryInstr* entry = preorder_[i];
     JoinEntryInstr* join = entry->AsJoinEntry();
     if (join != NULL && join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi != NULL) ValidateUseListsInInstruction(phi);
@@ skipping 13 matching lines @@
   DEBUG_ASSERT(defn->input_use_list() == NULL);
   DEBUG_ASSERT(defn->env_use_list() == NULL);
   defn->set_input_use_list(NULL);
   defn->set_env_use_list(NULL);
 }
 
 
 static void RecordInputUses(Instruction* instr) {
   ASSERT(instr != NULL);
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
-    UseVal* use = instr->InputAt(i)->AsUse();
-    if (use == NULL) continue;
+    Value* use = instr->InputAt(i);
     DEBUG_ASSERT(use->instruction() == NULL);
     DEBUG_ASSERT(use->use_index() == -1);
     DEBUG_ASSERT(use->next_use() == NULL);
     DEBUG_ASSERT(0 == MembershipCount(use,
                                       use->definition()->input_use_list()));
     use->set_instruction(instr);
     use->set_use_index(i);
     use->AddToInputUseList();
   }
 }
 
 
 static void RecordEnvUses(Instruction* instr) {
   ASSERT(instr != NULL);
   if (instr->env() == NULL) return;
   for (intptr_t i = 0; i < instr->env()->values().length(); ++i) {
-    UseVal* use = instr->env()->values()[i]->AsUse();
-    if (use == NULL) continue;
+    Value* use = instr->env()->values()[i];
     DEBUG_ASSERT(use->instruction() == NULL);
     DEBUG_ASSERT(use->use_index() == -1);
     DEBUG_ASSERT(use->next_use() == NULL);
     DEBUG_ASSERT(0 == MembershipCount(use, use->definition()->env_use_list()));
     use->set_instruction(instr);
     use->set_use_index(i);
     use->AddToEnvUseList();
   }
 }
 
@@ skipping 22 matching lines @@
   if (block->last_instruction()->SuccessorCount() == 1 &&
       block->last_instruction()->SuccessorAt(0)->IsJoinEntry()) {
     JoinEntryInstr* join =
         block->last_instruction()->SuccessorAt(0)->AsJoinEntry();
     intptr_t pred_index = join->IndexOfPredecessor(block);
     ASSERT(pred_index >= 0);
     if (join->phis() != NULL) {
       for (intptr_t i = 0; i < join->phis()->length(); ++i) {
         PhiInstr* phi = (*join->phis())[i];
         if (phi == NULL) continue;
-        UseVal* use = phi->InputAt(pred_index)->AsUse();
-        if (use == NULL) continue;
+        Value* use = phi->InputAt(pred_index);
         DEBUG_ASSERT(use->instruction() == NULL);
         DEBUG_ASSERT(use->use_index() == -1);
         DEBUG_ASSERT(use->next_use() == NULL);
         DEBUG_ASSERT(0 == MembershipCount(use,
                                           use->definition()->input_use_list()));
         use->set_instruction(phi);
         use->set_use_index(pred_index);
         use->AddToInputUseList();
       }
     }
@@ skipping 257 matching lines @@
     // gets a full copy of the environment. Later we optimize this by
     // eliminating unnecessary environments.
     current->set_env(new Environment(*env, non_copied_parameter_count_));
 
     // 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);
-      if (!v->IsUse()) continue;
       // Update expression stack.
       ASSERT(env->length() > variable_count());
 
       Definition* input_defn = env->Last();
       env->RemoveLast();
 
-      BindInstr* as_bind = v->AsUse()->definition()->AsBind();
+      BindInstr* as_bind = v->definition()->AsBind();
       if ((as_bind != NULL) &&
           (as_bind->computation()->IsLoadLocal() ||
            as_bind->computation()->IsStoreLocal())) {
         // Remove the load/store from the graph.
         as_bind->RemoveFromGraph();
         // Assert we are not referencing nulls in the initial environment.
         ASSERT(input_defn->ssa_temp_index() != -1);
-        current->SetInputAt(i, new UseVal(input_defn));
+        current->SetInputAt(i, new Value(input_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();
       if ((load != NULL) || (store != NULL)) {
         intptr_t index;
         if (store != NULL) {
           index = store->local().BitIndexIn(non_copied_parameter_count_);
           // Update renaming environment.
-          ASSERT(store->value()->IsUse());
-          (*env)[index] = store->value()->AsUse()->definition();
+          (*env)[index] = store->value()->definition();
         } else {
           // The graph construction ensures we do not have an unused LoadLocal
           // computation.
           ASSERT(bind->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);
@@ skipping 37 matching lines @@
       block_entry->last_instruction()->SuccessorAt(0)->IsJoinEntry()) {
     JoinEntryInstr* successor =
         block_entry->last_instruction()->SuccessorAt(0)->AsJoinEntry();
     intptr_t pred_index = successor->IndexOfPredecessor(block_entry);
     ASSERT(pred_index >= 0);
     if (successor->phis() != NULL) {
       for (intptr_t i = 0; i < successor->phis()->length(); ++i) {
         PhiInstr* phi = (*successor->phis())[i];
         if (phi != NULL) {
           // Rename input operand.
-          phi->SetInputAt(pred_index, new UseVal((*env)[i]));
+          phi->SetInputAt(pred_index, new Value((*env)[i]));
         }
       }
     }
   }
 }
 
 
 void FlowGraph::MarkLivePhis(GrowableArray<PhiInstr*>* live_phis) {
   while (!live_phis->is_empty()) {
     PhiInstr* phi = live_phis->Last();
     live_phis->RemoveLast();
     for (intptr_t i = 0; i < phi->InputCount(); i++) {
       Value* val = phi->InputAt(i);
-      if (!val->IsUse()) continue;
-      PhiInstr* used_phi = val->AsUse()->definition()->AsPhi();
+      PhiInstr* used_phi = val->definition()->AsPhi();
       if ((used_phi != NULL) && !used_phi->is_alive()) {
         used_phi->mark_alive();
         live_phis->Add(used_phi);
       }
     }
   }
 }
 
 
 void FlowGraph::Bailout(const char* reason) const {
   const char* kFormat = "FlowGraph Bailout: %s %s";
   const char* function_name = parsed_function_.function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(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