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

vm/intermediate_language_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 199 matching lines @@
 
 
 static void EmitAssertBoolean(Register reg,
                               intptr_t token_pos,
                               LocationSummary* locs,
                               FlowGraphCompiler* compiler) {
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   ASSERT(locs->always_calls());
   Label done;
-  __ CompareObject(reg, compiler->bool_true());
+  __ CompareObject(reg, Bool::True());
   __ j(EQUAL, &done, Assembler::kNearJump);
-  __ CompareObject(reg, compiler->bool_false());
+  __ CompareObject(reg, Bool::False());
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ pushq(reg);  // Push the source object.
   compiler->GenerateCallRuntime(token_pos,
                                 kConditionTypeErrorRuntimeEntry,
                                 locs);
   // We should never return here.
   __ int3();
   __ Bind(&done);
 }
@@ skipping 160 matching lines @@
 
   __ Bind(&check_identity);
   Label equality_done;
   if (compiler->is_optimizing()) {
     // No need to update IC data.
     Label is_true;
     __ popq(RAX);
     __ popq(RDX);
     __ cmpq(RAX, RDX);
     __ j(EQUAL, &is_true);
-    __ LoadObject(RAX, (kind == Token::kEQ) ? compiler->bool_false()
-                                            : compiler->bool_true());
+    __ LoadObject(RAX, (kind == Token::kEQ) ? Bool::False() : Bool::True());
     __ jmp(&equality_done);
     __ Bind(&is_true);
-    __ LoadObject(RAX, (kind == Token::kEQ) ? compiler->bool_true()
-                                            : compiler->bool_false());
+    __ LoadObject(RAX, (kind == Token::kEQ) ? Bool::True() : Bool::False());
     if (kind == Token::kNE) {
       // Skip not-equal result conversion.
       __ jmp(&equality_done);
     }
   } else {
     // Call stub, load IC data in register. The stub will update ICData if
     // necessary.
     Register ic_data_reg = locs->temp(0).reg();
     ASSERT(ic_data_reg == RBX);  // Stub depends on it.
     __ LoadObject(ic_data_reg, equality_ic_data);
     compiler->GenerateCall(token_pos,
                            &StubCode::EqualityWithNullArgLabel(),
                            PcDescriptors::kOther,
                            locs);
     __ Drop(2);
   }
   __ Bind(&check_ne);
   if (kind == Token::kNE) {
     Label false_label, true_label, done;
     // Negate the condition: true label returns false and vice versa.
-    __ CompareObject(RAX, compiler->bool_true());
+    __ CompareObject(RAX, Bool::True());
     __ j(EQUAL, &true_label, Assembler::kNearJump);
     __ Bind(&false_label);
-    __ LoadObject(RAX, compiler->bool_true());
+    __ LoadObject(RAX, Bool::True());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&true_label);
-    __ LoadObject(RAX, compiler->bool_false());
+    __ LoadObject(RAX, Bool::False());
     __ Bind(&done);
   }
   __ Bind(&equality_done);
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
                                           LocationSummary* locs,
                                           BranchInstr* branch,
@@ skipping 37 matching lines @@
       // Object.== is same as ===.
       __ Drop(2);
       __ cmpq(left, right);
       if (branch != NULL) {
         branch->EmitBranchOnCondition(compiler, cond);
       } else {
         // This case should be rare.
         Register result = locs->out().reg();
         Label load_true;
         __ j(cond, &load_true, Assembler::kNearJump);
-        __ LoadObject(result, compiler->bool_false());
+        __ LoadObject(result, Bool::False());
         __ jmp(&done);
         __ Bind(&load_true);
-        __ LoadObject(result, compiler->bool_true());
+        __ LoadObject(result, Bool::True());
       }
     } else {
       const int kNumberOfArguments = 2;
       const Array& kNoArgumentNames = Array::Handle();
       compiler->GenerateStaticCall(deopt_id,
                                    token_pos,
                                    target,
                                    kNumberOfArguments,
                                    kNoArgumentNames,
                                    locs);
       if (branch == NULL) {
         if (kind == Token::kNE) {
           Label false_label;
-          __ CompareObject(RAX, compiler->bool_true());
+          __ CompareObject(RAX, Bool::True());
           __ j(EQUAL, &false_label, Assembler::kNearJump);
-          __ LoadObject(RAX, compiler->bool_true());
+          __ LoadObject(RAX, Bool::True());
           __ jmp(&done);
           __ Bind(&false_label);
-          __ LoadObject(RAX, compiler->bool_false());
+          __ LoadObject(RAX, Bool::False());
           __ jmp(&done);
         }
       } else {
         if (branch->is_checked()) {
           EmitAssertBoolean(RAX, token_pos, locs, compiler);
         }
-        __ CompareObject(RAX, compiler->bool_true());
+        __ CompareObject(RAX, Bool::True());
         branch->EmitBranchOnCondition(compiler, cond);
       }
     }
     __ jmp(&done);
     __ Bind(&next_test);
   }
   // Fall through leads to deoptimization
   __ jmp(deopt);
   __ Bind(&done);
 }
@@ skipping 32 matching lines @@
       __ j(EQUAL, &identity_compare);
     }
   }
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   if (branch == NULL) {
     Label done, is_equal;
     Register result = locs.out().reg();
     __ j(EQUAL, &is_equal, Assembler::kNearJump);
     // Not equal.
-    __ LoadObject(result, (kind == Token::kEQ) ? compiler->bool_false()
-                                               : compiler->bool_true());
+    __ LoadObject(result, (kind == Token::kEQ) ? Bool::False() : Bool::True());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&is_equal);
-    __ LoadObject(result, (kind == Token::kEQ) ? compiler->bool_true()
-                                               : compiler->bool_false());
+    __ LoadObject(result, (kind == Token::kEQ) ? Bool::True() : Bool::False());
     __ Bind(&done);
   } else {
     Condition cond = TokenKindToSmiCondition(kind);
     branch->EmitBranchOnCondition(compiler, cond);
   }
 }
 
 
 // First test if receiver is NULL, in which case === is applied.
 // If type feedback was provided (lists of <class-id, target>), do a
@@ skipping 19 matching lines @@
   // Comparison with NULL is "===".
   __ Bind(&identity_compare);
   __ cmpq(left, right);
   Condition cond = TokenKindToSmiCondition(kind);
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, cond);
   } else {
     Register result = locs->out().reg();
     Label load_true;
     __ j(cond, &load_true, Assembler::kNearJump);
-    __ LoadObject(result, compiler->bool_false());
+    __ LoadObject(result, Bool::False());
     __ jmp(&done);
     __ Bind(&load_true);
-    __ LoadObject(result, compiler->bool_true());
+    __ LoadObject(result, Bool::True());
   }
   __ jmp(&done);
   __ Bind(&non_null_compare);  // Receiver is not null.
   __ pushq(left);
   __ pushq(right);
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
                                 deopt_id, token_pos);
   __ Bind(&done);
 }
 
@@ skipping 16 matching lines @@
   } else {
     __ cmpq(left.reg(), right.reg());
   }
 
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, true_condition);
   } else {
     Register result = locs.out().reg();
     Label done, is_true;
     __ j(true_condition, &is_true);
-    __ LoadObject(result, compiler->bool_false());
+    __ LoadObject(result, Bool::False());
     __ jmp(&done);
     __ Bind(&is_true);
-    __ LoadObject(result, compiler->bool_true());
+    __ LoadObject(result, Bool::True());
     __ Bind(&done);
   }
 }
 
 
 static Condition TokenKindToDoubleCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return BELOW;
@@ skipping 96 matching lines @@
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs(),
                              *ic_data());
   if (branch->is_checked()) {
     EmitAssertBoolean(RAX, token_pos(), locs(), compiler);
   }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
-  __ CompareObject(RAX, compiler->bool_true());
+  __ CompareObject(RAX, Bool::True());
   branch->EmitBranchOnCondition(compiler, branch_condition);
 }
 
 
 LocationSummary* RelationalOpInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 2;
   const intptr_t kNumTemps = 0;
   if (operands_class_id() == kDoubleCid) {
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 101 matching lines @@
                                        BranchInstr* branch) {
   if (operands_class_id() == kSmiCid) {
     EmitSmiComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
-  __ CompareObject(RAX, compiler->bool_true());
+  __ CompareObject(RAX, Bool::True());
   branch->EmitBranchOnCondition(compiler, EQUAL);
 }
 
 
 LocationSummary* NativeCallInstr::MakeLocationSummary() const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 3;
   LocationSummary* locs =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
   locs->set_temp(0, Location::RegisterLocation(RAX));
@@ skipping 1551 matching lines @@
 
 void ShiftMintOpInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   UNIMPLEMENTED();
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64