Uses an object pool on x64

runtime/vm/intrinsifier_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 99 matching lines @@
   __ movq(RDI, Address(RSP, kArrayLengthOffset));  // Array Length.
   __ StoreIntoObjectNoBarrier(RAX,
                               FieldAddress(RAX, Array::length_offset()),
                               RDI);
 
   // Initialize all array elements to raw_null.
   // RAX: new object start as a tagged pointer.
   // RCX: new object end address.
   // RDI: iterator which initially points to the start of the variable
   // data area to be initialized.
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<intptr_t>(Object::null()));
+  __ LoadObjectFromPool(R12, Object::Handle(Object::null()),
+      Assembler::kNotPatchable, PP);
   __ leaq(RDI, FieldAddress(RAX, sizeof(RawArray)));
   Label done;
   Label init_loop;
   __ Bind(&init_loop);
   __ cmpq(RDI, RCX);
   __ j(ABOVE_EQUAL, &done, Assembler::kNearJump);
-  __ movq(Address(RDI, 0), raw_null);
+  __ movq(Address(RDI, 0), R12);
   __ addq(RDI, Immediate(kWordSize));
   __ jmp(&init_loop, Assembler::kNearJump);
   __ Bind(&done);
   __ ret();  // returns the newly allocated object in RAX.
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Array_getLength(Assembler* assembler) {
@@ skipping 246 matching lines @@
   __ j(EQUAL, &fall_through);  // Must grow data.
   const Immediate& value_one =
       Immediate(reinterpret_cast<int64_t>(Smi::New(1)));
   // len = len + 1;
   __ addq(FieldAddress(RAX, GrowableObjectArray::length_offset()), value_one);
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // Value
   ASSERT(kSmiTagShift == 1);
   __ StoreIntoObject(RDX,
                      FieldAddress(RDX, RCX, TIMES_4, Array::data_offset()),
                      RAX);
-  const Immediate& raw_null =
-      Immediate(reinterpret_cast<int64_t>(Object::null()));
-  __ movq(RAX, raw_null);
+  __ LoadObjectFromPool(RAX, Object::Handle(Object::null()),
+      Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 #define TYPED_ARRAY_ALLOCATION(type_name, cid, max_len, scale_factor)          \
   Label fall_through;                                                          \
   const intptr_t kArrayLengthStackOffset = 1 * kWordSize;                      \
   __ movq(RDI, Address(RSP, kArrayLengthStackOffset));  /* Array length. */    \
   /* Check that length is a positive Smi. */                                   \
@@ skipping 464 matching lines @@
   __ Bind(&fall_through);
 }
 
 
 static void CompareIntegers(Assembler* assembler, Condition true_condition) {
   Label fall_through, true_label;
   TestBothArgumentsSmis(assembler, &fall_through);
   // RAX contains the right argument.
   __ cmpq(Address(RSP, + 2 * kWordSize), RAX);
   __ j(true_condition, &true_label, Assembler::kNearJump);
-  __ LoadObject(RAX, Bool::False());
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&true_label);
-  __ LoadObject(RAX, Bool::True());
+  __ LoadObjectFromPool(RAX, Bool::True(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 
 void Intrinsifier::Integer_lessThan(Assembler* assembler) {
   return CompareIntegers(assembler, LESS);
 }
 
@@ skipping 16 matching lines @@
 void 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.
 void Intrinsifier::Integer_equalToInteger(Assembler* assembler) {
   Label fall_through, true_label, check_for_mint;
   // For integer receiver '===' check first.
-  __ movq(RAX, Address(RSP, + 1 * kWordSize));
-  __ movq(RCX, Address(RSP, + 2 * kWordSize));
+  // Entering a dart frame so we can use the PP for loading True and False.
+  __ EnterDartFrame(0, PP, kNoRegister);
+  __ movq(RAX, Address(RSP, + 4 * kWordSize));
+  __ movq(RCX, Address(RSP, + 5 * kWordSize));
   __ cmpq(RAX, RCX);
   __ j(EQUAL, &true_label, Assembler::kNearJump);
   __ orq(RAX, RCX);
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &check_for_mint, Assembler::kNearJump);
   // Both arguments are smi, '===' is good enough.
-  __ LoadObject(RAX, Bool::False());
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
+  __ LeaveFrameWithPP();
   __ ret();
   __ Bind(&true_label);
-  __ LoadObject(RAX, Bool::True());
+  __ LoadObjectFromPool(RAX, Bool::True(), Assembler::kNotPatchable, PP);
+  __ LeaveFrameWithPP();
   __ ret();
 
   // At least one of the arguments was not Smi.
   Label receiver_not_smi;
   __ Bind(&check_for_mint);
-  __ movq(RAX, Address(RSP, + 2 * kWordSize));  // Receiver.
+  __ movq(RAX, Address(RSP, + 5 * kWordSize));  // Receiver.
   __ testq(RAX, 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.
-  __ movq(RAX, Address(RSP, + 1 * kWordSize));
+  __ movq(RAX, Address(RSP, + 4 * kWordSize));
   __ CompareClassId(RAX, kDoubleCid);
   __ j(EQUAL, &fall_through);
-  __ LoadObject(RAX, Bool::False());
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
+  __ LeaveFrameWithPP();
   __ ret();
 
   __ Bind(&receiver_not_smi);
   // RAX:: receiver.
   __ CompareClassId(RAX, kMintCid);
   __ j(NOT_EQUAL, &fall_through);
   // Receiver is Mint, return false if right is Smi.
-  __ movq(RAX, Address(RSP, + 1 * kWordSize));  // Right argument.
+  __ movq(RAX, Address(RSP, + 4 * kWordSize));  // Right argument.
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through);
-  __ LoadObject(RAX, Bool::False());  // Smi == Mint -> false.
+  // Smi == Mint -> false.
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
+  __ LeaveFrameWithPP();
   __ ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
+  __ LeaveFrameWithPP();
 }
 
 
 void Intrinsifier::Integer_equal(Assembler* assembler) {
   return Integer_equalToInteger(assembler);
 }
 
 
 void Intrinsifier::Integer_sar(Assembler* assembler) {
   Label fall_through, shift_count_ok;
@@ skipping 54 matching lines @@
   // Both arguments are double, right operand is in RAX.
   __ movsd(XMM1, FieldAddress(RAX, Double::value_offset()));
   __ Bind(&double_op);
   __ movq(RAX, Address(RSP, + 2 * kWordSize));  // Left argument.
   __ movsd(XMM0, FieldAddress(RAX, 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(RAX, Bool::False());
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True());
+  __ LoadObjectFromPool(RAX, Bool::True(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&is_smi);
   __ SmiUntag(RAX);
   __ cvtsi2sd(XMM1, RAX);
   __ jmp(&double_op);
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_greaterThan(Assembler* assembler) {
@@ skipping 113 matching lines @@
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_getIsNaN(Assembler* assembler) {
   Label is_true;
   __ movq(RAX, Address(RSP, +1 * kWordSize));
   __ movsd(XMM0, FieldAddress(RAX, Double::value_offset()));
   __ comisd(XMM0, XMM0);
   __ j(PARITY_EVEN, &is_true, Assembler::kNearJump);  // NaN -> true;
-  __ LoadObject(RAX, Bool::False());
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True());
+  __ LoadObjectFromPool(RAX, Bool::True(), Assembler::kNotPatchable, PP);
   __ ret();
 }
 
 
 void Intrinsifier::Double_getIsNegative(Assembler* assembler) {
   Label is_false, is_true, is_zero;
   __ movq(RAX, Address(RSP, +1 * kWordSize));
   __ movsd(XMM0, FieldAddress(RAX, 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(RAX, Bool::True());
+  __ LoadObjectFromPool(RAX, Bool::True(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&is_false);
-  __ LoadObject(RAX, Bool::False());
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&is_zero);
   // Check for negative zero (get the sign bit).
   __ movmskpd(RAX, XMM0);
   __ testq(RAX, Immediate(1));
   __ j(NOT_ZERO, &is_true, Assembler::kNearJump);
   __ jmp(&is_false, Assembler::kNearJump);
 }
 
 
@@ skipping 127 matching lines @@
   __ imulq(RCX, RAX);
   __ movl(RDX, addr_1);
   __ addq(RDX, RCX);
   __ movl(addr_0, RDX);
   __ shrq(RDX, Immediate(32));
   __ movl(addr_1, RDX);
   __ ret();
 }
 
 
-
 // Identity comparison.
 void Intrinsifier::Object_equal(Assembler* assembler) {
   Label is_true;
-  __ movq(RAX, Address(RSP, + 1 * kWordSize));
-  __ cmpq(RAX, Address(RSP, + 2 * kWordSize));
+  // This intrinsic is used from the API even when we have not entered any
+  // Dart frame, yet, so the PP would otherwise be null in this case unless
+  // we enter a Dart frame here.
+  __ EnterDartFrame(0, PP, kNoRegister);
+  __ movq(RAX, Address(RSP, + 4 * kWordSize));
+  __ cmpq(RAX, Address(RSP, + 5 * kWordSize));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
-  __ LoadObject(RAX, Bool::False());
+  __ movq(RAX, Immediate(reinterpret_cast<int64_t>(Bool::False().raw())));
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
+  __ LeaveFrameWithPP();
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True());
+  __ LoadObjectFromPool(RAX, Bool::True(), Assembler::kNotPatchable, PP);
+  __ LeaveFrameWithPP();
   __ ret();
 }
 
 
 void Intrinsifier::String_getHashCode(Assembler* assembler) {
   Label fall_through;
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // String object.
   __ movq(RAX, FieldAddress(RAX, String::hash_offset()));
   __ cmpq(RAX, Immediate(0));
   __ j(EQUAL, &fall_through, Assembler::kNearJump);
@@ skipping 39 matching lines @@
 }
 
 
 void Intrinsifier::String_getIsEmpty(Assembler* assembler) {
   Label is_true;
   // Get length.
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // String object.
   __ movq(RAX, FieldAddress(RAX, String::length_offset()));
   __ cmpq(RAX, Immediate(Smi::RawValue(0)));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
-  __ LoadObject(RAX, Bool::False());
+  __ LoadObjectFromPool(RAX, Bool::False(), Assembler::kNotPatchable, PP);
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True());
+  __ LoadObjectFromPool(RAX, Bool::True(), Assembler::kNotPatchable, PP);
   __ ret();
 }
 
 
 void Intrinsifier::OneByteString_getHashCode(Assembler* assembler) {
   Label compute_hash;
   __ movq(RBX, Address(RSP, + 1 * kWordSize));  // OneByteString object.
   __ movq(RAX, FieldAddress(RBX, String::hash_offset()));
   __ cmpq(RAX, Immediate(0));
   __ j(EQUAL, &compute_hash, Assembler::kNearJump);
@@ skipping 204 matching lines @@
 
   __ Bind(&fall_through);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64