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

vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "lib/error.h"
@@ skipping 188 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);
 
   __ pushl(reg);  // Push the source object.
   compiler->GenerateCallRuntime(token_pos,
                                 kConditionTypeErrorRuntimeEntry,
                                 locs);
   // We should never return here.
   __ int3();
   __ Bind(&done);
 }
@@ skipping 170 matching lines @@
 
   __ Bind(&check_identity);
   Label equality_done;
   if (compiler->is_optimizing()) {
     // No need to update IC data.
     Label is_true;
     __ popl(EAX);
     __ popl(EDX);
     __ cmpl(EAX, EDX);
     __ j(EQUAL, &is_true);
-    __ LoadObject(EAX, (kind == Token::kEQ) ? compiler->bool_false()
-                                            : compiler->bool_true());
+    __ LoadObject(EAX, (kind == Token::kEQ) ? Bool::False() : Bool::True());
     __ jmp(&equality_done);
     __ Bind(&is_true);
-    __ LoadObject(EAX, (kind == Token::kEQ) ? compiler->bool_true()
-                                            : compiler->bool_false());
+    __ LoadObject(EAX, (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 == ECX);  // 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(EAX, compiler->bool_true());
+    __ CompareObject(EAX, Bool::True());
     __ j(EQUAL, &true_label, Assembler::kNearJump);
     __ Bind(&false_label);
-    __ LoadObject(EAX, compiler->bool_true());
+    __ LoadObject(EAX, Bool::True());
     __ jmp(&done, Assembler::kNearJump);
     __ Bind(&true_label);
-    __ LoadObject(EAX, compiler->bool_false());
+    __ LoadObject(EAX, Bool::False());
     __ Bind(&done);
   }
   __ Bind(&equality_done);
 }
 
 
 static void EmitEqualityAsPolymorphicCall(FlowGraphCompiler* compiler,
                                           const ICData& orig_ic_data,
                                           LocationSummary* locs,
                                           BranchInstr* branch,
@@ skipping 36 matching lines @@
     if (target.Owner() == object_store->object_class()) {
       // Object.== is same as ===.
       __ Drop(2);
       __ cmpl(left, right);
       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());
       }
     } 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(EAX, compiler->bool_true());
+          __ CompareObject(EAX, Bool::True());
           __ j(EQUAL, &false_label, Assembler::kNearJump);
-          __ LoadObject(EAX, compiler->bool_true());
+          __ LoadObject(EAX, Bool::True());
           __ jmp(&done);
           __ Bind(&false_label);
-          __ LoadObject(EAX, compiler->bool_false());
+          __ LoadObject(EAX, Bool::False());
           __ jmp(&done);
         }
       } else {
         if (branch->is_checked()) {
           EmitAssertBoolean(EAX, token_pos, locs, compiler);
         }
-        __ CompareObject(EAX, compiler->bool_true());
+        __ CompareObject(EAX, 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);
   __ cmpl(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);
   __ cmpl(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.
   __ pushl(left);
   __ pushl(right);
   EmitEqualityAsPolymorphicCall(compiler, ic_data, locs, branch, kind,
                                 deopt_id, token_pos);
   __ Bind(&done);
 }
 
@@ skipping 16 matching lines @@
   } else {
     __ cmpl(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 TokenKindToMintCondition(Token::Kind kind) {
   switch (kind) {
     case Token::kEQ: return EQUAL;
     case Token::kNE: return NOT_EQUAL;
     case Token::kLT: return LESS;
@@ skipping 21 matching lines @@
 
   Condition true_condition = TokenKindToMintCondition(kind);
   __ cmpl(temp, Immediate(-1));
 
   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 void EmitUnboxedMintComparisonOp(FlowGraphCompiler* compiler,
                                         const LocationSummary& locs,
                                         Token::Kind kind,
                                         BranchInstr* branch) {
   XmmRegister left = locs.in(0).xmm_reg();
@@ skipping 41 matching lines @@
   // If upper is equal, compare lower half.
   __ pextrd(left_tmp, left, Immediate(0));
   __ pextrd(right_tmp, right, Immediate(0));
   __ cmpl(left_tmp, right_tmp);
   if (branch != NULL) {
     branch->EmitBranchOnCondition(compiler, lo_cond);
   } else {
     Label done;
     __ j(lo_cond, &is_true);
     __ Bind(&is_false);
-    __ 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 102 matching lines @@
   EmitEqualityAsInstanceCall(compiler,
                              deopt_id(),
                              token_pos(),
                              Token::kEQ,  // kNE reverse occurs at branch.
                              locs(),
                              *ic_data());
   if (branch->is_checked()) {
     EmitAssertBoolean(EAX, token_pos(), locs(), compiler);
   }
   Condition branch_condition = (kind() == Token::kNE) ? NOT_EQUAL : EQUAL;
-  __ CompareObject(EAX, compiler->bool_true());
+  __ CompareObject(EAX, 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() == kMintCid) {
     const intptr_t kNumTemps = 2;
     LocationSummary* locs =
@@ skipping 119 matching lines @@
   }
   if (operands_class_id() == kMintCid) {
     EmitUnboxedMintComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   if (operands_class_id() == kDoubleCid) {
     EmitDoubleComparisonOp(compiler, *locs(), kind(), branch);
     return;
   }
   EmitNativeCode(compiler);
-  __ CompareObject(EAX, compiler->bool_true());
+  __ CompareObject(EAX, 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(EAX));
@@ skipping 1772 matching lines @@
   __ pcmpeqq(XMM0, XMM0);  // Generate all 1's.
   __ pxor(value, XMM0);
 }
 
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64