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

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 346 matching lines @@
 
 BlockEntryInstr* TestGraphVisitor::CreateFalseSuccessor() const {
   return CreateSuccessorFor(false_successor_addresses_);
 }
 
 
 void TestGraphVisitor::ReturnValue(Value* value) {
   if (FLAG_enable_type_checks) {
     value = Bind(new AssertBooleanInstr(condition_token_pos(), value));
   }
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  Value* constant_true = Bind(new ConstantInstr(bool_true));
+  Value* constant_true = Bind(new ConstantInstr(Bool::True()));
   StrictCompareInstr* comp =
       new StrictCompareInstr(Token::kEQ_STRICT, value, constant_true);
   BranchInstr* branch = new BranchInstr(comp);
   AddInstruction(branch);
   CloseFragment();
 
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
@@ skipping 16 matching lines @@
   }
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::MergeBranchWithNegate(BooleanNegateInstr* neg) {
   ASSERT(!FLAG_enable_type_checks);
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  Value* constant_true = Bind(new ConstantInstr(bool_true));
+  Value* constant_true = Bind(new ConstantInstr(Bool::True()));
   BranchInstr* branch = new BranchInstr(
       new StrictCompareInstr(Token::kNE_STRICT, neg->value(), constant_true));
   AddInstruction(branch);
   CloseFragment();
   true_successor_addresses_.Add(branch->true_successor_address());
   false_successor_addresses_.Add(branch->false_successor_address());
 }
 
 
 void TestGraphVisitor::ReturnDefinition(Definition* definition) {
@@ skipping 277 matching lines @@
 
 // Special handling for AND/OR.
 void ValueGraphVisitor::VisitBinaryOpNode(BinaryOpNode* node) {
   // Operators "&&" and "||" cannot be overloaded therefore do not call
   // operator.
   if ((node->kind() == Token::kAND) || (node->kind() == Token::kOR)) {
     // Implement short-circuit logic: do not evaluate right if evaluation
     // of left is sufficient.
     // AND:  left ? right === true : false;
     // OR:   left ? true : right === true;
-    const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-    const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
     TestGraphVisitor for_test(owner(),
                               temp_index(),
                               loop_depth(),
                               node->left()->token_pos());
     node->left()->Visit(&for_test);
 
     ValueGraphVisitor for_right(owner(), temp_index(), loop_depth());
     node->right()->Visit(&for_right);
     Value* right_value = for_right.value();
     if (FLAG_enable_type_checks) {
       right_value =
           for_right.Bind(new AssertBooleanInstr(node->right()->token_pos(),
                                                 right_value));
     }
-    Value* constant_true = for_right.Bind(new ConstantInstr(bool_true));
+    Value* constant_true = for_right.Bind(new ConstantInstr(Bool::True()));
     Value* compare =
         for_right.Bind(new StrictCompareInstr(Token::kEQ_STRICT,
                                               right_value,
                                               constant_true));
     for_right.Do(BuildStoreExprTemp(compare));
 
     if (node->kind() == Token::kAND) {
       ValueGraphVisitor for_false(owner(), temp_index(), loop_depth());
-      Value* constant_false = for_false.Bind(new ConstantInstr(bool_false));
+      Value* constant_false = for_false.Bind(new ConstantInstr(Bool::False()));
       for_false.Do(BuildStoreExprTemp(constant_false));
       Join(for_test, for_right, for_false);
     } else {
       ASSERT(node->kind() == Token::kOR);
       ValueGraphVisitor for_true(owner(), temp_index(), loop_depth());
-      Value* constant_true = for_true.Bind(new ConstantInstr(bool_true));
+      Value* constant_true = for_true.Bind(new ConstantInstr(Bool::True()));
       for_true.Do(BuildStoreExprTemp(constant_true));
       Join(for_test, for_true, for_right);
     }
     ReturnDefinition(BuildLoadExprTemp());
     return;
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
@@ skipping 115 matching lines @@
   if (!CanSkipTypeCheck(node->token_pos(), for_value.value(), type, dst_name)) {
     Append(for_value);
     Do(BuildAssertAssignable(
         node->token_pos(), for_value.value(), type, dst_name));
   }
 }
 
 
 void ValueGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   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(), loop_depth());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
-    ReturnDefinition(new ConstantInstr(negate_result ? bool_false : bool_true));
+    ReturnDefinition(new ConstantInstr(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());
     ConstantInstr* 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 ConstantInstr(negate_result ? bool_true : bool_false);
+      result = new ConstantInstr(negate_result ? Bool::True() : Bool::False());
     } else {
       if (literal_value.IsInstanceOf(type, TypeArguments::Handle(), NULL)) {
-        result = new ConstantInstr(negate_result ? bool_false : bool_true);
+        result = new ConstantInstr(negate_result ?
+                                   Bool::False() : Bool::True());
       } else {
-        result = new ConstantInstr(negate_result ? bool_true : bool_false);
+        result = new ConstantInstr(negate_result ?
+                                   Bool::True() : Bool::False());
       }
     }
     ReturnDefinition(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index(), loop_depth());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
   PushArgumentInstr* push_left = PushArgument(for_left_value.value());
@@ skipping 10 matching lines @@
   const String& name = String::ZoneHandle(Symbols::New("_instanceOf"));
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(5);
   arguments->Add(push_left);
   arguments->Add(push_instantiator);
   arguments->Add(push_type_args);
   ASSERT(!node->right()->AsTypeNode()->type().IsNull());
   Value* type_arg = Bind(
       new ConstantInstr(node->right()->AsTypeNode()->type()));
   arguments->Add(PushArgument(type_arg));
-  const Bool& negate = Bool::ZoneHandle(node->kind() == Token::kISNOT ?
-      Bool::True() : Bool::False());
+  const Bool& negate = (node->kind() == Token::kISNOT) ? Bool::True() :
+                                                         Bool::False();
   Value* negate_arg = Bind(new ConstantInstr(negate));
   arguments->Add(PushArgument(negate_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new InstanceCallInstr(node->token_pos(),
                                                   name,
                                                   node->kind(),
                                                   arguments,
                                                   Array::ZoneHandle(),
                                                   kNumArgsChecked);
   ReturnDefinition(call);
@@ skipping 2126 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