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

vm/intrinsifier_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.
 //
 // The intrinsic code below is executed before a method has built its frame.
 // The return address is on the stack and the arguments below it.
 // Registers EDX (arguments descriptor) and ECX (function) must be preserved.
 // Each intrinsification method returns true if the corresponding
 // Dart method was intrinsified.
 
@@ skipping 1057 matching lines @@
   __ j(NOT_EQUAL, not_smi_or_mint);
   // Mint.
   __ pushl(FieldAddress(reg, Mint::value_offset() + kWordSize));
   __ pushl(FieldAddress(reg, Mint::value_offset()));
   __ Bind(&done);
 }
 
 
 static bool CompareIntegers(Assembler* assembler, Condition true_condition) {
   Label try_mint_smi, is_true, is_false, drop_two_fall_through, fall_through;
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   TestBothArgumentsSmis(assembler, &try_mint_smi);
   // EAX contains the right argument.
   __ cmpl(Address(ESP, + 2 * kWordSize), EAX);
   __ j(true_condition, &is_true, Assembler::kNearJump);
   __ Bind(&is_false);
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
 
   // 64-bit comparison
   Condition hi_true_cond, hi_false_cond, lo_false_cond;
   switch (true_condition) {
     case LESS:
     case LESS_EQUAL:
       hi_true_cond = LESS;
       hi_false_cond = GREATER;
       lo_false_cond = (true_condition == LESS) ? ABOVE_EQUAL : ABOVE;
@@ skipping 59 matching lines @@
 
 bool Intrinsifier::Integer_greaterEqualThan(Assembler* assembler) {
   return CompareIntegers(assembler, GREATER_EQUAL);
 }
 
 
 // This is called for Smi, Mint and Bigint receivers. The right argument
 // can be Smi, Mint, Bigint or double.
 bool Intrinsifier::Integer_equalToInteger(Assembler* assembler) {
   Label fall_through, true_label, check_for_mint;
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   // For integer receiver '===' check first.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ cmpl(EAX, Address(ESP, + 2 * kWordSize));
   __ j(EQUAL, &true_label, Assembler::kNearJump);
   __ movl(EBX, Address(ESP, + 2 * kWordSize));
   __ orl(EAX, EBX);
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &check_for_mint, Assembler::kNearJump);
   // Both arguments are smi, '===' is good enough.
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&true_label);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
 
   // At least one of the arguments was not Smi.
   Label receiver_not_smi;
   __ Bind(&check_for_mint);
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Receiver.
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &receiver_not_smi);
 
   // Left (receiver) is Smi, return false if right is not Double.
   // Note that an instance of Mint or Bigint never contains a value that can be
   // represented by Smi.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Right argument.
   __ CompareClassId(EAX, kDoubleCid, EDI);
   __ j(EQUAL, &fall_through);
-  __ LoadObject(EAX, bool_false);  // Smi == Mint -> false.
+  __ LoadObject(EAX, Bool::False());  // Smi == Mint -> false.
   __ ret();
 
   __ Bind(&receiver_not_smi);
   // EAX:: receiver.
   __ CompareClassId(EAX, kMintCid, EDI);
   __ j(NOT_EQUAL, &fall_through);
   // Receiver is Mint, return false if right is Smi.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Right argument.
   __ testl(EAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through);
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Integer_equal(Assembler* assembler) {
   return Integer_equalToInteger(assembler);
@@ skipping 50 matching lines @@
   __ j(NOT_EQUAL, not_double_smi, Assembler::kNearJump);
   // Fall through if double.
 }
 
 
 // Both arguments on stack, arg0 (left) is a double, arg1 (right) is of unknown
 // type. Return true or false object in the register EAX. Any NaN argument
 // returns false. Any non-double arg1 causes control flow to fall through to the
 // slow case (compiled method body).
 static bool CompareDoubles(Assembler* assembler, Condition true_condition) {
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label fall_through, is_false, is_true, is_smi, double_op;
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Both arguments are double, right operand is in EAX.
   __ movsd(XMM1, FieldAddress(EAX, Double::value_offset()));
   __ Bind(&double_op);
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Left argument.
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ comisd(XMM0, XMM1);
   __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN -> false;
   __ j(true_condition, &is_true, Assembler::kNearJump);
   // Fall through false.
   __ Bind(&is_false);
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
   __ Bind(&is_smi);
   __ SmiUntag(EAX);
   __ cvtsi2sd(XMM1, EAX);
   __ jmp(&double_op);
   __ Bind(&fall_through);
   return false;
 }
 
 
@@ skipping 120 matching lines @@
                                Assembler::kNearJump,
                                EAX);  // Result register.
   __ movsd(FieldAddress(EAX, Double::value_offset()), XMM0);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::Double_getIsNaN(Assembler* assembler) {
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label is_true;
   __ movl(EAX, Address(ESP, +1 * kWordSize));
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ comisd(XMM0, XMM0);
   __ j(PARITY_EVEN, &is_true, Assembler::kNearJump);  // NaN -> true;
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
   return true;  // Method is complete, no slow case.
 }
 
 
 bool Intrinsifier::Double_getIsNegative(Assembler* assembler) {
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label is_false, is_true, is_zero;
   __ movl(EAX, Address(ESP, +1 * kWordSize));
   __ movsd(XMM0, FieldAddress(EAX, Double::value_offset()));
   __ xorpd(XMM1, XMM1);  // 0.0 -> XMM1.
   __ comisd(XMM0, XMM1);
   __ j(PARITY_EVEN, &is_false, Assembler::kNearJump);  // NaN -> false.
   __ j(EQUAL, &is_zero, Assembler::kNearJump);  // Check for negative zero.
   __ j(ABOVE_EQUAL, &is_false, Assembler::kNearJump);  // >= 0 -> false.
   __ Bind(&is_true);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
   __ Bind(&is_false);
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_zero);
   // Check for negative zero (get the sign bit).
   __ movmskpd(EAX, XMM0);
   __ testl(EAX, Immediate(1));
   __ j(NOT_ZERO, &is_true, Assembler::kNearJump);
   __ jmp(&is_false, Assembler::kNearJump);
   return true;  // Method is complete, no slow case.
 }
 
@@ skipping 93 matching lines @@
 
 bool Intrinsifier::Math_cos(Assembler* assembler) {
   EmitTrigonometric(assembler, kCosine);
   return false;  // Compile method for slow case.
 }
 
 
 // Identity comparison.
 bool Intrinsifier::Object_equal(Assembler* assembler) {
   Label is_true;
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ cmpl(EAX, Address(ESP, + 2 * kWordSize));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
   return true;
 }
 
 
 static const char* kFixedSizeArrayIteratorClassName = "_FixedSizeArrayIterator";
 
 
 // Class 'FixedSizeArrayIterator':
 //   T next() {
@@ skipping 41 matching lines @@
   return false;
 }
 
 
 // Class 'FixedSizeArrayIterator':
 //   bool get hasNext {
 //     return _length > _pos;
 //   }
 bool Intrinsifier::FixedSizeArrayIterator_getHasNext(Assembler* assembler) {
   Label fall_through, is_true;
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   intptr_t length_offset =
       GetOffsetForField(kFixedSizeArrayIteratorClassName, "_length");
   intptr_t pos_offset =
       GetOffsetForField(kFixedSizeArrayIteratorClassName, "_pos");
   __ movl(EAX, Address(ESP, + 1 * kWordSize));     // Receiver.
   __ movl(EBX, FieldAddress(EAX, length_offset));  // Field _length.
   __ movl(EAX, FieldAddress(EAX, pos_offset));    // Field _pos.
   __ movl(EDI, EAX);
   __ orl(EDI, EBX);
   __ testl(EDI, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through, Assembler::kNearJump);  // Non-smi _length.
   __ cmpl(EBX, EAX);     // _length > _pos.
   __ j(GREATER, &is_true, Assembler::kNearJump);
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::String_getHashCode(Assembler* assembler) {
   Label fall_through;
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // String object.
   __ movl(EAX, FieldAddress(EAX, String::hash_offset()));
@@ skipping 31 matching lines @@
   __ movzxb(EAX, FieldAddress(EAX, EBX, TIMES_1, OneByteString::data_offset()));
   __ SmiTag(EAX);
   __ ret();
   __ Bind(&fall_through);
   return false;
 }
 
 
 bool Intrinsifier::String_getIsEmpty(Assembler* assembler) {
   Label is_true;
-  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
-  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   // Get length.
   __ movl(EAX, Address(ESP, + 1 * kWordSize));  // String object.
   __ movl(EAX, FieldAddress(EAX, String::length_offset()));
   __ cmpl(EAX, Immediate(Smi::RawValue(0)));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
-  __ LoadObject(EAX, bool_false);
+  __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(EAX, bool_true);
+  __ LoadObject(EAX, Bool::True());
   __ ret();
   return true;
 }
 
 #undef __
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32