Change Bool::Get to return a handle instead of a pointer to a raw object.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 2521 matching lines @@
   Bool& prev = Bool::Handle();
   Class& cls = Class::Handle();
   for (int i = 0; i < ic_data.NumberOfChecks(); i++) {
     cls = class_table.At(ic_data.GetReceiverClassIdAt(i));
     if (cls.HasTypeArguments()) return Bool::null();
     const bool is_subtype = cls.IsSubtypeOf(TypeArguments::Handle(),
                                             type_class,
                                             TypeArguments::Handle(),
                                             NULL);
     if (prev.IsNull()) {
-      prev = is_subtype ? Bool::True().raw() : Bool::False().raw();
+      prev = Bool::Get(is_subtype).raw();
     } else {
       if (is_subtype != prev.value()) return Bool::null();
     }
   }
   return prev.raw();
 }
 
 
 // TODO(srdjan): Use ICData to check if always true or false.
 void FlowGraphOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeTestOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator = call->ArgumentAt(1);
   Definition* type_args = call->ArgumentAt(2);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
   const bool negate =
       Bool::Cast(call->ArgumentAt(4)->AsConstant()->value()).value();
   const ICData& unary_checks =
       ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
   if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
     Bool& as_bool = Bool::ZoneHandle(InstanceOfAsBool(unary_checks, type));
     if (!as_bool.IsNull()) {
       AddReceiverCheck(call);
       if (negate) {
-        as_bool = Bool::Get(!as_bool.value());
+        as_bool = Bool::Get(!as_bool.value()).raw();
       }
       ConstantInstr* bool_const = flow_graph()->GetConstant(as_bool);
       for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
         PushArgumentInstr* push = call->PushArgumentAt(i);
         push->ReplaceUsesWith(push->value()->definition());
         push->RemoveFromGraph();
       }
       call->ReplaceUsesWith(bool_const);
       ASSERT(current_iterator()->Current() == call);
       current_iterator()->RemoveCurrentFromGraph();
@@ skipping 3412 matching lines @@
   }
 }
 
 
 void ConstantPropagator::VisitStrictCompare(StrictCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
 
   if (instr->left()->definition() == instr->right()->definition()) {
     // Fold x === x, and x !== x to true/false.
-    SetValue(instr,
-             (instr->kind() == Token::kEQ_STRICT)
-               ? Bool::True()
-               : Bool::False());
+    SetValue(instr, Bool::Get(instr->kind() == Token::kEQ_STRICT));
     return;
   }
 
   if (IsNonConstant(left) || IsNonConstant(right)) {
     // TODO(vegorov): incorporate nullability information into the lattice.
     if ((left.IsNull() && instr->right()->Type()->HasDecidableNullability()) ||
         (right.IsNull() && instr->left()->Type()->HasDecidableNullability())) {
       bool result = left.IsNull() ? instr->right()->Type()->IsNull()
                                   : instr->left()->Type()->IsNull();
       if (instr->kind() == Token::kNE_STRICT) result = !result;
-      SetValue(instr, result ? Bool::True() : Bool::False());
+      SetValue(instr, Bool::Get(result));
     } 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, result ? Bool::True() : Bool::False());
+    SetValue(instr, Bool::Get(result));
   }
 }
 
 
 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 11 matching lines @@
 
 void ConstantPropagator::VisitEqualityCompare(EqualityCompareInstr* instr) {
   const Object& left = instr->left()->definition()->constant_value();
   const Object& right = instr->right()->definition()->constant_value();
 
   if (instr->left()->definition() == instr->right()->definition()) {
     // Fold x == x, and x != x to true/false for numbers and checked strict
     // comparisons.
     if (instr->IsCheckedStrictEqual() ||
         RawObject::IsIntegerClassId(instr->operation_cid())) {
-      return SetValue(instr,
-                      (instr->kind() == Token::kEQ)
-                          ? Bool::True()
-                          : Bool::False());
+      return SetValue(instr, Bool::Get(instr->kind() == Token::kEQ));
     }
   }
 
   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, result ? Bool::True() : Bool::False());
+      SetValue(instr, Bool::Get(result));
     } else if (left.IsString() && right.IsString()) {
       const bool result = String::Cast(left).Equals(String::Cast(right));
-      SetValue(instr,
-               ((instr->kind() == Token::kEQ) == result)
-                   ? Bool::True()
-                   : Bool::False());
+      SetValue(instr, Bool::Get((instr->kind() == Token::kEQ) == result));
     } 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, result ? Bool::True() : Bool::False());
+      SetValue(instr, Bool::Get(result));
     } else {
       SetValue(instr, non_constant_);
     }
   }
 }
 
 
 void ConstantPropagator::VisitNativeCall(NativeCallInstr* instr) {
   SetValue(instr, non_constant_);
 }
@@ skipping 39 matching lines @@
   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)) {
     bool val = value.raw() != Bool::True().raw();
-    SetValue(instr, val ? Bool::True() : Bool::False());
+    SetValue(instr, Bool::Get(val));
   }
 }
 
 
 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 1380 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart