- Make Boolean 'true' and 'false' singleton VM isolate objects.

vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 2548 matching lines @@
 }
 
 
 void FlowGraphTypePropagator::VisitInstanceOf(InstanceOfInstr* instr) {
   bool is_null;
   bool is_instance = false;
   if (FLAG_eliminate_type_checks &&
       instr->value()->CanComputeIsNull(&is_null) &&
       (is_null ||
        instr->value()->CanComputeIsInstanceOf(instr->type(), &is_instance))) {
-    Definition* result = new ConstantInstr(Bool::ZoneHandle(Bool::Get(
-        instr->negate_result() ? !is_instance : is_instance)));
+    bool val = instr->negate_result() ? !is_instance : is_instance;
+    Definition* result = new ConstantInstr(val ? Bool::True() : Bool::False());
     result->set_ssa_temp_index(flow_graph_->alloc_ssa_temp_index());
     result->InsertBefore(instr);
     // Replace uses and remove the current instruction via the iterator.
     instr->ReplaceUsesWith(result);
     ASSERT(current_iterator()->Current() == instr);
     current_iterator()->RemoveCurrentFromGraph();
     if (FLAG_trace_optimization) {
       OS::Print("Replacing v%"Pd" with v%"Pd"\n",
                 instr->ssa_temp_index(),
                 result->ssa_temp_index());
@@ skipping 1096 matching lines @@
   instr->comparison()->Accept(this);
 
   // The successors may be reachable, but only if this instruction is.  (We
   // might be analyzing it because the constant value of one of its inputs
   // has changed.)
   if (reachable_->Contains(instr->GetBlock()->preorder_number())) {
     const Object& value = instr->comparison()->constant_value();
     if (IsNonConstant(value)) {
       SetReachable(instr->true_successor());
       SetReachable(instr->false_successor());
-    } else if (value.raw() == Bool::True()) {
+    } else if (value.raw() == Bool::True().raw()) {
       SetReachable(instr->true_successor());
     } else if (!IsUnknown(value)) {  // Any other constant.
       SetReachable(instr->false_successor());
     }
   }
 }
 
 
 // --------------------------------------------------------------------------
 // Analysis of non-definition instructions.  They do not have values so they
@@ skipping 125 matching lines @@
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
 
   if (IsNonConstant(left) || IsNonConstant(right)) {
     // TODO(vegorov): incorporate nullability information into the lattice.
     if ((left.IsNull() && (instr->right()->ResultCid() != kDynamicCid)) ||
         (right.IsNull() && (instr->left()->ResultCid() != kDynamicCid))) {
       bool result = left.IsNull() ? (instr->right()->ResultCid() == kNullCid)
                                   : (instr->left()->ResultCid() == kNullCid);
       if (instr->kind() == Token::kNE_STRICT) result = !result;
-      SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
+      SetValue(instr, result ? Bool::True() : Bool::False());
     } else {
       SetValue(instr, non_constant_);
     }
   } else if (IsConstant(left) && IsConstant(right)) {
     bool result = (left.raw() == right.raw());
     if (instr->kind() == Token::kNE_STRICT) result = !result;
-    SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
+    SetValue(instr, result ? Bool::True() : Bool::False());
   }
 }
 
 
 static bool CompareIntegers(Token::Kind kind,
                             const Integer& left,
                             const Integer& right) {
   const int result = left.CompareWith(right);
   switch (kind) {
     case Token::kEQ: return (result == 0);
@@ skipping 12 matching lines @@
 void ConstantPropagator::VisitEqualityCompare(EqualityCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     if (left.IsInteger() && right.IsInteger()) {
       const bool result = CompareIntegers(instr->kind(),
                                           Integer::Cast(left),
                                           Integer::Cast(right));
-      SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
+      SetValue(instr, result ? Bool::True() : Bool::False());
     } else {
       SetValue(instr, non_constant_);
     }
   }
 }
 
 
 void ConstantPropagator::VisitRelationalOp(RelationalOpInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
   if (IsNonConstant(left) || IsNonConstant(right)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(left) && IsConstant(right)) {
     if (left.IsInteger() && right.IsInteger()) {
       const bool result = CompareIntegers(instr->kind(),
                                           Integer::Cast(left),
                                           Integer::Cast(right));
-      SetValue(instr, Bool::ZoneHandle(Bool::Get(result)));
+      SetValue(instr, result ? Bool::True() : Bool::False());
     } else {
       SetValue(instr, non_constant_);
     }
   }
 }
 
 
 void ConstantPropagator::VisitNativeCall(NativeCallInstr* instr) {
   SetValue(instr, non_constant_);
 }
@@ skipping 34 matching lines @@
 void ConstantPropagator::VisitStoreStaticField(StoreStaticFieldInstr* instr) {
   SetValue(instr, instr->value()->definition()->constant_value());
 }
 
 
 void ConstantPropagator::VisitBooleanNegate(BooleanNegateInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
-    SetValue(instr, Bool::ZoneHandle(Bool::Get(value.raw() != Bool::True())));
+    bool val = value.raw() != Bool::True().raw();
+    SetValue(instr, val ? Bool::True() : Bool::False());
   }
 }
 
 
 void ConstantPropagator::VisitInstanceOf(InstanceOfInstr* instr) {
   const Object& value = instr->value()->definition()->constant_value();
   if (IsNonConstant(value)) {
     SetValue(instr, non_constant_);
   } else if (IsConstant(value)) {
     // TODO(kmillikin): Handle instanceof on constants.
@@ skipping 420 matching lines @@
 
   if (FLAG_trace_constant_propagation) {
     OS::Print("\n==== After constant propagation ====\n");
     FlowGraphPrinter printer(*graph_);
     printer.PrintBlocks();
   }
 }
 
 
 }  // namespace dart