Make Value not a subclass of Computation.

runtime/vm/flow_graph_builder.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_builder.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 98 matching lines @@
   ASSERT(is_open());
   if (is_empty()) {
     entry_ = new GotoInstr(join);
   } else {
     exit()->Goto(join);
   }
   exit_ = NULL;
 }
 
 
+MaterializeComp* EffectGraphVisitor::Constant(const Object& value) {
+  return new MaterializeComp(new ConstantVal(value));
+}
+
+
 // Appends a graph fragment to a block entry instruction.  Returns the entry
 // instruction if the fragment was empty or else the exit of the fragment if
 // it was non-empty (so NULL if the fragment is closed).
 //
 // Note that the fragment is no longer a valid fragment after calling this
 // function -- the fragment is closed at its entry because the entry has a
 // predecessor in the graph.
 static Instruction* AppendFragment(BlockEntryInstr* entry,
                                    const EffectGraphVisitor& fragment) {
   if (fragment.is_empty()) return entry;
@@ skipping 135 matching lines @@
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     value = Bind(new AssertBooleanComp(condition_token_pos(),
                                        owner()->try_index(),
                                        value));
   }
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  Value* constant_true = Bind(new ConstantVal(bool_true));
+  Value* constant_true = Bind(Constant(bool_true));
   BranchInstr* branch = new BranchInstr(condition_token_pos(),
                                         owner()->try_index(),
                                         value,
                                         constant_true,
                                         Token::kEQ_STRICT);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void TestGraphVisitor::MergeBranchWithComparison(ComparisonComp* comp) {
   ASSERT(!FLAG_enable_type_checks);
   BranchInstr* branch = new BranchInstr(condition_token_pos(),
                                         owner()->try_index(),
                                         comp->left(),
                                         comp->right(),
                                         comp->kind());
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
 
 
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateComp* comp) {
   ASSERT(!FLAG_enable_type_checks);
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  Value* constant_true = Bind(new ConstantVal(bool_true));
+  Value* constant_true = Bind(Constant(bool_true));
   BranchInstr* branch = new BranchInstr(condition_token_pos(),
                                         owner()->try_index(),
                                         comp->value(),
                                         constant_true,
                                         Token::kNE_STRICT);
   AddInstruction(branch);
   CloseFragment();
   true_successor_address_ = branch->true_successor_address();
   false_successor_address_ = branch->false_successor_address();
 }
@@ skipping 74 matching lines @@
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
-  ReturnComputation(new ConstantVal(node->literal()));
+  ReturnComputation(Constant(node->literal()));
 }
 
 
 // Type nodes only occur as the right-hand side of instanceof comparisons,
 // and they are handled specially in that context.
 void EffectGraphVisitor::VisitTypeNode(TypeNode* node) { UNREACHABLE(); }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is Dynamic or if the compile type of the value is a subtype
@@ skipping 131 matching lines @@
 
     ValueGraphVisitor for_right(owner(), temp_index());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       right_value =
           for_right.Bind(new AssertBooleanComp(node->right()->token_pos(),
                                                owner()->try_index(),
                                                right_value));
     }
-    Value* constant_true = for_right.Bind(new ConstantVal(bool_true));
+    Value* constant_true = for_right.Bind(Constant(bool_true));
     Value* compare =
         for_right.Bind(new StrictCompareComp(Token::kEQ_STRICT,
                                              right_value,
                                              constant_true));
     for_right.Do(BuildStoreLocal(
         *owner()->parsed_function().expression_temp_var(),
         compare));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index());
-      Value* constant_false = for_false.Bind(new ConstantVal(bool_false));
+      Value* constant_false = for_false.Bind(Constant(bool_false));
       for_false.Do(BuildStoreLocal(
           *owner()->parsed_function().expression_temp_var(),
           constant_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index());
-      Value* constant_true = for_true.Bind(new ConstantVal(bool_true));
+      Value* constant_true = for_true.Bind(Constant(bool_true));
       for_true.Do(BuildStoreLocal(
           *owner()->parsed_function().expression_temp_var(),
           constant_true));
       Join(for_test, for_true, for_right);
     }
     ReturnComputation(
         BuildLoadLocal(*owner()->parsed_function().expression_temp_var()));
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
@@ skipping 24 matching lines @@
     Value* loaded = Bind(BuildLoadLocal(expr_temp));
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, loaded);
   }
   *instantiator_result = instantiator;
   *instantiator_type_arguments_result = instantiator_type_arguments;
 }
 
 
 Value* EffectGraphVisitor::BuildNullValue() {
-  return Bind(new ConstantVal(Object::ZoneHandle()));
+  return Bind(Constant(Object::ZoneHandle()));
 }
 
 
 // Used for testing incoming arguments.
 AssertAssignableComp* EffectGraphVisitor::BuildAssertAssignable(
     intptr_t token_pos,
     Value* value,
     const AbstractType& dst_type,
     const String& dst_name) {
   // Build the type check computation.
@@ skipping 60 matching lines @@
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const bool negate_result = (node->kind() == Token::kISNOT);
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type = Type::Handle(Type::ObjectType());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type, NULL)) {
     // Must evaluate left side.
     EffectGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ReturnComputation(new ConstantVal(negate_result ? bool_false : bool_true));
+    ReturnComputation(Constant(negate_result ? bool_false : bool_true));
     return;
   }
 
   // Eliminate the test if it can be performed successfully at compile time.
   if ((node->left() != NULL) &&
       node->left()->IsLiteralNode() &&
       type.IsInstantiated()) {
     const Instance& literal_value = node->left()->AsLiteralNode()->literal();
     const Class& cls = Class::Handle(literal_value.clazz());
-    ConstantVal* result = NULL;
+    MaterializeComp* result = NULL;
     if (cls.IsNullClass()) {
       // A null object is only an instance of Object and Dynamic, which has
       // already been checked above (if the type is instantiated). So we can
       // return false here if the instance is null (and if the type is
       // instantiated).
-      result = new ConstantVal(negate_result ? bool_true : bool_false);
+      result = Constant(negate_result ? bool_true : bool_false);
     } else {
       if (literal_value.IsInstanceOf(type, TypeArguments::Handle(), NULL)) {
-        result = new ConstantVal(negate_result ? bool_false : bool_true);
+        result = Constant(negate_result ? bool_false : bool_true);
       } else {
-        result = new ConstantVal(negate_result ? bool_true : bool_false);
+        result = Constant(negate_result ? bool_true : bool_false);
       }
     }
     ReturnComputation(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   Value* instantiator = NULL;
@@ skipping 763 matching lines @@
                                            allocate_arguments);
   }
   return Bind(allocate_comp);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   Value* ctor_arg = Bind(
-      new ConstantVal(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
+      Constant(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
   PushArgumentInstr* push_ctor_arg = PushArgument(ctor_arg);
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   arguments->Add(push_alloc_value);
   arguments->Add(push_ctor_arg);
 
   BuildPushArguments(*node->arguments(), arguments);
   Do(new StaticCallComp(node->token_pos(),
                         owner()->try_index(),
@@ skipping 67 matching lines @@
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_pos, Heap::kNew));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalize);
     ASSERT(!type.IsMalformed());
     type_arguments = type.arguments();
     type_arguments = type_arguments.Canonicalize();
-    return Bind(new ConstantVal(type_arguments));
+    return Bind(Constant(type_arguments));
   }
   Function& outer_function =
       Function::Handle(owner()->parsed_function().function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // No instantiator for factories.
     ASSERT(instantiator == NULL);
     ASSERT(owner()->parsed_function().instantiator() != NULL);
@@ skipping 17 matching lines @@
       instantiator,
       type_arguments_instance_field_offset,
       Type::ZoneHandle()));  // Not an instance, no type.
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
-    return Bind(new ConstantVal(type_arguments));
+    return Bind(Constant(type_arguments));
   }
   // The type arguments are uninstantiated.
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, NULL);
   return Bind(new InstantiateTypeArgumentsComp(token_pos,
                                                owner()->try_index(),
                                                type_arguments,
                                                instantiator_value));
 }
 
 
 void EffectGraphVisitor::BuildConstructorTypeArguments(
     ConstructorCallNode* node,
     Value** type_arguments,
     Value** instantiator,
     ZoneGrowableArray<PushArgumentInstr*>* call_arguments) {
   const Class& cls = Class::ZoneHandle(node->constructor().Owner());
   ASSERT(cls.HasTypeArguments() && !node->constructor().IsFactory());
   if (node->type_arguments().IsNull() ||
       node->type_arguments().IsInstantiated()) {
-    Value* type_arguments_val = Bind(new ConstantVal(node->type_arguments()));
+    Value* type_arguments_val = Bind(Constant(node->type_arguments()));
     if (call_arguments != NULL) {
       ASSERT(type_arguments == NULL);
       call_arguments->Add(PushArgument(type_arguments_val));
     } else {
       ASSERT(type_arguments != NULL);
       *type_arguments = type_arguments_val;
     }
 
     // No instantiator required.
     Value* instantiator_val = Bind(
-        new ConstantVal(Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
+        Constant(Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
     if (call_arguments != NULL) {
       ASSERT(instantiator == NULL);
       call_arguments->Add(PushArgument(instantiator_val));
     } else {
       ASSERT(instantiator != NULL);
       *instantiator = instantiator_val;
     }
     return;
   }
   // The type arguments are uninstantiated. The generated pseudo code:
@@ skipping 480 matching lines @@
                                      num_context_variables));
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function is not a closure, do not link the current context as the
     // parent of the newly allocated context, as it is not accessible. Instead,
     // save it in a pre-allocated variable and restore it on exit.
     if (MustSaveRestoreContext(node)) {
       Value* current_context = Bind(new CurrentContextComp());
       Do(BuildStoreLocal(*owner()->parsed_function().saved_context_var(),
                          current_context));
-      Value* null_context = Bind(new ConstantVal(Object::ZoneHandle()));
+      Value* null_context = Bind(Constant(Object::ZoneHandle()));
       Do(new StoreContextComp(null_context));
     }
 
     Do(new ChainContextComp(allocated_context));
     owner()->set_context_level(scope->context_level());
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
     if (node == owner()->parsed_function().node_sequence()) {
       ASSERT(scope->context_level() == 1);
@@ skipping 13 matching lines @@
               temp_name,
               Type::ZoneHandle(Type::DynamicType()));  // Type.
           temp_local->set_index(param_frame_index);
 
           // Copy parameter from local frame to current context.
           Value* load = Bind(BuildLoadLocal(*temp_local));
           Do(BuildStoreLocal(parameter, load));
           // Write NULL to the source location to detect buggy accesses and
           // allow GC of passed value if it gets overwritten by a new value in
           // the function.
-          Value* null_constant = Bind(new ConstantVal(Object::ZoneHandle()));
+          Value* null_constant = Bind(Constant(Object::ZoneHandle()));
           Do(BuildStoreLocal(*temp_local, null_constant));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     const Function& function = owner()->parsed_function().function();
     const int num_params = function.NumberOfParameters();
@@ skipping 153 matching lines @@
   BuildThrowNode(node);
   CloseFragment();
 }
 
 
 // A throw cannot be part of an expression, however, the parser may replace
 // certain expression nodes with a throw. In that case generate a literal null
 // so that the fragment is not closed in the middle of an expression.
 void ValueGraphVisitor::VisitThrowNode(ThrowNode* node) {
   BuildThrowNode(node);
-  ReturnComputation(new ConstantVal(Instance::ZoneHandle()));
+  ReturnComputation(Constant(Instance::ZoneHandle()));
 }
 
 
 void EffectGraphVisitor::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   const intptr_t try_index = owner()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     owner()->set_try_index((try_index - 1));
@@ skipping 36 matching lines @@
   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