Eliminate class UseVal.

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/locations.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/scopes.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, enable_type_checks);
 
 
 intptr_t Computation::Hashcode() const {
   intptr_t result = computation_kind();
   for (intptr_t i = 0; i < InputCount(); ++i) {
-    UseVal* val = InputAt(i)->AsUse();
-    intptr_t j = val != NULL
-        ? val->definition()->ssa_temp_index()
-        : -1;
+    Value* value = InputAt(i);
+    intptr_t j = value->definition()->ssa_temp_index();
     result = result * 31 + j;
   }
   return result;
 }
 
 
 bool Computation::Equals(Computation* other) const {
   if (computation_kind() != other->computation_kind()) return false;
   for (intptr_t i = 0; i < InputCount(); ++i) {
     if (!InputAt(i)->Equals(other->InputAt(i))) return false;
   }
   return AttributesEqual(other);
 }
 
 
-bool UseVal::Equals(Value* other) const {
-  return other->IsUse()
-      && definition() == other->AsUse()->definition();
+bool Value::Equals(Value* other) const {
+  return definition() == other->definition();
 }
 
 
 bool CheckClassComp::AttributesEqual(Computation* other) const {
   CheckClassComp* other_check = other->AsCheckClass();
   if (other_check == NULL) return false;
   if (ic_data()->NumberOfChecks() != other->ic_data()->NumberOfChecks()) {
     return false;
   }
   for (intptr_t i = 0; i < ic_data()->NumberOfChecks(); ++i) {
     // TODO(fschneider): Make sure ic_data are sorted to hit more cases.
     if (ic_data()->GetReceiverClassIdAt(i) !=
         other->ic_data()->GetReceiverClassIdAt(i)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool CheckArrayBoundComp::AttributesEqual(Computation* other) const {
   CheckArrayBoundComp* other_check = other->AsCheckArrayBound();
   if (other_check == NULL) return false;
   return array_type() == other_check->array_type();
 }
 
 
 // Returns true if the value represents a constant.
-bool UseVal::BindsToConstant() const {
+bool Value::BindsToConstant() const {
   BindInstr* bind = definition()->AsBind();
   return (bind != NULL) && (bind->computation()->AsConstant() != NULL);
 }
 
 
 // Returns true if the value represents constant null.
-bool UseVal::BindsToConstantNull() const {
+bool Value::BindsToConstantNull() const {
   BindInstr* bind = definition()->AsBind();
   if (bind == NULL) {
     return false;
   }
   ConstantComp* constant = bind->computation()->AsConstant();
   return (constant != NULL) && constant->value().IsNull();
 }
 
 
-const Object& UseVal::BoundConstant() const {
+const Object& Value::BoundConstant() const {
   ASSERT(BindsToConstant());
   BindInstr* bind = definition()->AsBind();
   ASSERT(bind != NULL);
   ConstantComp* constant = bind->computation()->AsConstant();
   ASSERT(constant != NULL);
   return constant->value();
 }
 
 
 bool ConstantComp::AttributesEqual(Computation* other) const {
@@ skipping 281 matching lines @@
   }
 }
 
 
 void Instruction::RecordAssignedVars(BitVector* assigned_vars,
                                      intptr_t fixed_parameter_count) {
   // Nothing to do for the base class.
 }
 
 
-void UseVal::AddToInputUseList() {
+void Value::AddToInputUseList() {
   set_next_use(definition()->input_use_list());
   definition()->set_input_use_list(this);
 }
 
 
-void UseVal::AddToEnvUseList() {
+void Value::AddToEnvUseList() {
   set_next_use(definition()->env_use_list());
   definition()->set_env_use_list(this);
 }
 
 
 void Definition::ReplaceUsesWith(Definition* other) {
   ASSERT(other != NULL);
   ASSERT(this != other);
   while (input_use_list_ != NULL) {
-    UseVal* current = input_use_list_;
+    Value* current = input_use_list_;
     input_use_list_ = input_use_list_->next_use();
     current->set_definition(other);
     current->AddToInputUseList();
   }
   while (env_use_list_ != NULL) {
-    UseVal* current = env_use_list_;
+    Value* current = env_use_list_;
     env_use_list_ = env_use_list_->next_use();
     current->set_definition(other);
     current->AddToEnvUseList();
   }
 }
 
 
 bool Definition::SetPropagatedCid(intptr_t cid) {
   if (cid == kIllegalCid) {
     return false;
@@ skipping 243 matching lines @@
   ASSERT(index == 0);
   return successor();
 }
 
 
 void Instruction::Goto(JoinEntryInstr* entry) {
   set_next(new GotoInstr(entry));
 }
 
 
-RawAbstractType* UseVal::CompileType() const {
+RawAbstractType* Value::CompileType() const {
   if (definition()->HasPropagatedType()) {
     return definition()->PropagatedType();
   }
   // The compile type may be requested when building the flow graph, i.e. before
   // type propagation has occurred. To avoid repeatedly computing the compile
   // type of the definition, we store it as initial propagated type.
   AbstractType& type = AbstractType::Handle(definition()->CompileType());
   definition()->SetPropagatedType(type);
   return type.raw();
 }
 
 
-intptr_t UseVal::ResultCid() const {
+intptr_t Value::ResultCid() const {
   return definition()->GetPropagatedCid();
 }
 
 
 
 RawAbstractType* ConstantComp::CompileType() const {
   if (value().IsNull()) {
     return Type::NullType();
   }
   if (value().IsInstance()) {
@@ skipping 375 matching lines @@
 }
 
 
 // Optimizations that eliminate or simplify individual computations.
 Definition* Computation::TryReplace(BindInstr* instr) const {
   return instr;
 }
 
 
 Definition* StrictCompareComp::TryReplace(BindInstr* instr) const {
-  UseVal* left_use = left()->AsUse();
-  UseVal* right_use = right()->AsUse();
-  if ((right_use == NULL) || (left_use == NULL)) return instr;
-  if (!right_use->BindsToConstant()) return instr;
-  const Object& right_constant = right_use->BoundConstant();
-  Definition* left = left_use->definition();
+  if (!right()->BindsToConstant()) return instr;
+  const Object& right_constant = right()->BoundConstant();
+  Definition* left_defn = left()->definition();
   // TODO(fschneider): Handle other cases: e === false and e !== true/false.
   // Handles e === true.
   if ((kind() == Token::kEQ_STRICT) &&
       (right_constant.raw() == Bool::True()) &&
-      (left_use->ResultCid() == kBoolCid)) {
+      (left()->ResultCid() == kBoolCid)) {
     // Remove the constant from the graph.
-    BindInstr* right = right_use->definition()->AsBind();
-    if (right != NULL) {
-      right->RemoveFromGraph();
+    BindInstr* right_defn = right()->definition()->AsBind();
+    if (right_defn != NULL) {
+      right_defn->RemoveFromGraph();
     }
     // Return left subexpression as the replacement for this instruction.
-    return left;
+    return left_defn;
   }
   return instr;
 }
 
 
 Definition* CheckClassComp::TryReplace(BindInstr* instr) const {
   const intptr_t v_cid = value()->ResultCid();
   const intptr_t num_checks = ic_data()->NumberOfChecks();
   if ((num_checks == 1) &&
       (v_cid == ic_data()->GetReceiverClassIdAt(0))) {
@@ skipping 392 matching lines @@
   }
 }
 
 
 Environment::Environment(const GrowableArray<Definition*>& definitions,
                          intptr_t fixed_parameter_count)
     : values_(definitions.length()),
       locations_(NULL),
       fixed_parameter_count_(fixed_parameter_count) {
   for (intptr_t i = 0; i < definitions.length(); ++i) {
-    values_.Add(new UseVal(definitions[i]));
+    values_.Add(new Value(definitions[i]));
   }
 }
 
 
 // Copies the environment and updates the environment use lists.
 void Environment::CopyTo(Instruction* instr) const {
   Environment* copy = new Environment(values().length(),
                                       fixed_parameter_count());
   GrowableArray<Value*>* values_copy = copy->values_ptr();
   for (intptr_t i = 0; i < values().length(); ++i) {
-    Value* value = values()[i]->CopyValue();
+    Value* value = values()[i]->Copy();
     values_copy->Add(value);
-    UseVal* use = value->AsUse();
-    if (use != NULL) {
-      use->set_instruction(instr);
-      use->set_use_index(i);
-      use->AddToEnvUseList();
-    }
+    value->set_instruction(instr);
+    value->set_use_index(i);
+    value->AddToEnvUseList();
   }
   instr->set_env(copy);
 }
 
 
 #undef __
 
 }  // namespace dart