Setup the pool pointer when entering Dart from C++ so the intrinsic functions may rely on it being …

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 897 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;
+  const intptr_t kReceiverOffset = 2;

[rmacnak, 2013/09/18 21:04:24]

Perhaps constants like these deserve to be defined once and used across the
intrinsics? Naming them might be an issue because the offsets of arguments
varies depending on whether the function is a method or static function.

[siva, 2013/09/19 00:45:37]

I prefer leaving the constants in each intrinsic, it is local and matches with
the code below and is easier to verify.

On 2013/09/18 21:04:24, Ryan Macnak wrote:

+  const intptr_t kArgumentOffset = 1;
+

[siva, 2013/09/19 00:45:37]

I think we should also add a comment that these intrinsics should only use
Bool::True, Bool::False and Object::null as the PP that we have setup in the
invocation stub will only be able to access these objects.

   // For integer receiver '===' check first.
-  // Entering a dart frame so we can use the PP for loading True and False.
-  __ EnterDartFrame(0);
-  __ movq(RAX, Address(RSP, + 4 * kWordSize));
-  __ movq(RCX, Address(RSP, + 5 * kWordSize));
+  __ movq(RAX, Address(RSP, + kArgumentOffset * kWordSize));
+  __ movq(RCX, Address(RSP, + kReceiverOffset * 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(), PP);
-  __ LeaveFrameWithPP();
   __ ret();
   __ Bind(&true_label);
   __ LoadObject(RAX, Bool::True(), PP);
-  __ LeaveFrameWithPP();
   __ ret();
 
   // At least one of the arguments was not Smi.
   Label receiver_not_smi;
   __ Bind(&check_for_mint);
-  __ movq(RAX, Address(RSP, + 5 * kWordSize));  // Receiver.
+  __ movq(RAX, Address(RSP, + kReceiverOffset * kWordSize));
   __ 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, + 4 * kWordSize));
+  __ movq(RAX, Address(RSP, + kArgumentOffset * kWordSize));
   __ CompareClassId(RAX, kDoubleCid);
   __ j(EQUAL, &fall_through);
   __ LoadObject(RAX, Bool::False(), 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, + 4 * kWordSize));  // Right argument.
+  __ movq(RAX, Address(RSP, + kArgumentOffset * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through);
   // Smi == Mint -> false.
   __ LoadObject(RAX, Bool::False(), 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 364 matching lines @@
   __ movl(RCX, addr_0);
   __ 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;
-  // 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);
-  __ movq(RAX, Address(RSP, + 4 * kWordSize));
-  __ cmpq(RAX, Address(RSP, + 5 * kWordSize));
+  const intptr_t kReceiverOffset = 2;
+  const intptr_t kArgumentOffset = 1;
+
+  __ movq(RAX, Address(RSP, + kArgumentOffset * kWordSize));
+  __ cmpq(RAX, Address(RSP, + kReceiverOffset * kWordSize));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
-  __ movq(RAX, Immediate(reinterpret_cast<int64_t>(Bool::False().raw())));
   __ LoadObject(RAX, Bool::False(), PP);
-  __ LeaveFrameWithPP();
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(RAX, Bool::True(), 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 267 matching lines @@
 
   __ Bind(&fall_through);
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64