Make constants computations instead of values.

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"
@@ skipping 32 matching lines @@
   return AttributesEqual(other);
 }
 
 
 bool UseVal::Equals(Value* other) const {
   return other->IsUse()
       && definition() == other->AsUse()->definition();
 }
 
 
-bool ConstantVal::Equals(Value* other) const {
-  return other->IsConstant()
-      && value().raw() == other->AsConstant()->value().raw();
-}
-
-
-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;
-}
-
-
 // Returns true if the value represents a constant.
 bool UseVal::BindsToConstant() const {
   BindInstr* bind = definition()->AsBind();
-  if (bind == NULL) {
-    return false;
-  }
-  return bind->computation()->AsMaterialize() != NULL;
+  return (bind != NULL) && (bind->computation()->AsConstant() != NULL);
 }
 
 
 // Returns true if the value represents constant null.
 bool UseVal::BindsToConstantNull() const {
   BindInstr* bind = definition()->AsBind();
   if (bind == NULL) {
     return false;
   }
-  MaterializeComp* constant = bind->computation()->AsMaterialize();
-  if (constant != NULL) {
-    return constant->constant_val()->value().IsNull();
-  }
-  return false;
+  ConstantComp* constant = bind->computation()->AsConstant();
+  return (constant != NULL) && constant->value().IsNull();
 }
 
 
 const Object& UseVal::BoundConstant() const {
   ASSERT(BindsToConstant());
   BindInstr* bind = definition()->AsBind();
   ASSERT(bind != NULL);
-  MaterializeComp* constant = bind->computation()->AsMaterialize();
+  ConstantComp* constant = bind->computation()->AsConstant();
   ASSERT(constant != NULL);
-  return constant->constant_val()->value();
+  return constant->value();
 }
 
 
+bool ConstantComp::AttributesEqual(Computation* other) const {
+  ConstantComp* other_constant = other->AsConstant();
+  return (other_constant != NULL) &&
+      (value().raw() == other_constant->value().raw());
+}
+
+
+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;
+}
+
+
+GraphEntryInstr::GraphEntryInstr(TargetEntryInstr* normal_entry)
+    : BlockEntryInstr(),
+      normal_entry_(normal_entry),
+      catch_entries_(),
+      start_env_(NULL),
+      constant_null_(new BindInstr(BindInstr::kUsed,

[Florian Schneider, 2012/08/29 11:07:48]

Maybe break after the first '(' here helps?

+                         new ConstantComp(Object::ZoneHandle()))),
+      spill_slot_count_(0) {
+}
+
+
 MethodRecognizer::Kind MethodRecognizer::RecognizeKind(
     const Function& function) {
   // Only core and math library methods can be recognized.
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
   const Library& math_lib = Library::Handle(Library::MathLibrary());
   const Class& function_class = Class::Handle(function.Owner());
   if ((function_class.library() != core_lib.raw()) &&
       (function_class.library() != core_impl_lib.raw()) &&
       (function_class.library() != math_lib.raw())) {
@@ skipping 286 matching lines @@
     UseVal* current = env_use_list_;
     env_use_list_ = env_use_list_->next_use();
     current->set_definition(other);
     current->AddToEnvUseList();
   }
 }
 
 
 void Definition::ReplaceUsesWith(Value* value) {
   ASSERT(value != NULL);
-  if (value->IsUse()) {
-    ReplaceUsesWith(value->AsUse()->definition());
-    return;
-  }
-  ASSERT(value->IsConstant());
-  while (input_use_list_ != NULL) {
-    Instruction* instr = input_use_list_->instruction();
-    instr->SetInputAt(input_use_list_->use_index(), value);
-    input_use_list_ = input_use_list_->next_use();
-  }
-  while (env_use_list_ != NULL) {
-    Environment* env = env_use_list_->instruction()->env();
-    ASSERT(env != NULL);
-    env->values()[env_use_list_->use_index()] = value;
-    env_use_list_ = env_use_list_->next_use();
-  }
+  ASSERT(value->IsUse());
+  ReplaceUsesWith(value->AsUse()->definition());
+  return;

[Florian Schneider, 2012/08/29 11:07:48]

No need for a return here.

[Kevin Millikin (Google), 2012/08/29 12:43:44]

Actually, this whole function seems kind of pointless now.  I'll just get rid of
it.

 }
 
 
 bool Definition::SetPropagatedCid(intptr_t cid) {
   if (cid == kIllegalCid) {
     return false;
   }
   if (propagated_cid_ == kIllegalCid) {
     // First setting, nothing has changed.
     propagated_cid_ = cid;
@@ skipping 239 matching lines @@
   ASSERT(index == 0);
   return successor();
 }
 
 
 void Instruction::Goto(JoinEntryInstr* entry) {
   set_next(new GotoInstr(entry));
 }
 
 
-RawAbstractType* ConstantVal::CompileType() const {
-  if (value().IsNull()) {
-    return Type::NullType();
-  }
-  if (value().IsInstance()) {
-    return Instance::Cast(value()).GetType();
-  } else {
-    ASSERT(value().IsAbstractTypeArguments());
-    return AbstractType::null();
-  }
-}
-
-
-intptr_t ConstantVal::ResultCid() const {
-  if (value().IsNull()) {
-    return kNullCid;
-  }
-  if (value().IsInstance()) {
-    return Class::Handle(value().clazz()).id();
-  } else {
-    ASSERT(value().IsAbstractTypeArguments());
-    return kDynamicCid;
-  }
-}
-
-
 RawAbstractType* UseVal::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 {
   return definition()->GetPropagatedCid();
 }
 
 
 
-RawAbstractType* MaterializeComp::CompileType() const {
-  return constant_val()->CompileType();
+RawAbstractType* ConstantComp::CompileType() const {
+  if (value().IsNull()) {
+    return Type::NullType();
+  }
+  if (value().IsInstance()) {
+    return Instance::Cast(value()).GetType();
+  } else {
+    ASSERT(value().IsAbstractTypeArguments());
+    return AbstractType::null();
+  }
 }
 
 
-intptr_t MaterializeComp::ResultCid() const {
-  return constant_val()->ResultCid();
+intptr_t ConstantComp::ResultCid() const {
+  if (value().IsNull()) {
+    return kNullCid;
+  }
+  if (value().IsInstance()) {
+    return Class::Handle(value().clazz()).id();
+  } else {
+    ASSERT(value().IsAbstractTypeArguments());
+    return kDynamicCid;
+  }
 }
 
 
 RawAbstractType* AssertAssignableComp::CompileType() const {
   const AbstractType& value_compile_type =
       AbstractType::Handle(value()->CompileType());
   if (!value_compile_type.IsNull() &&
       value_compile_type.IsMoreSpecificThan(dst_type(), NULL)) {
     return value_compile_type.raw();
   }
@@ skipping 749 matching lines @@
   // In SSA mode, we need an explicit push. Nothing to do in non-SSA mode
   // where PushArgument is handled by BindInstr::EmitNativeCode.
   // TODO(fschneider): Avoid special-casing for SSA mode here.
   if (compiler->is_optimizing()) {
     ASSERT(locs()->in(0).IsRegister());
     __ PushRegister(locs()->in(0).reg());
   }
 }
 
 
-// Helper to either use the constant value of a definition or the definition.
-static Value* UseDefinition(Definition* defn) {
-  if (defn->IsBind() && defn->AsBind()->computation()->IsMaterialize()) {
-    return defn->AsBind()->computation()->AsMaterialize()->constant_val();
-  } else {
-    return new UseVal(defn);
-  }
-}
-
-
 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(UseDefinition(definitions[i]));
+    values_.Add(new UseVal(definitions[i]));
   }
 }
 
 
 Environment* Environment::Copy() 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) {
     values_copy->Add(values()[i]->CopyValue());
   }
   return copy;
 }
 
 
 #undef __
 
 }  // namespace dart