Simplify constant pool usage in x64 code generator (by removing extra argument

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 54 matching lines @@
   // This snippet of inlined code uses the following registers:
   // RAX, RCX, R13
   // and the newly allocated object is returned in RAX.
   const intptr_t kTypeArgumentsOffset = 2 * kWordSize;
   const intptr_t kArrayOffset = 1 * kWordSize;
   Label fall_through;
 
   // Try allocating in new space.
   const Class& cls = Class::Handle(
       Isolate::Current()->object_store()->growable_object_array_class());
-  __ TryAllocate(cls, &fall_through, Assembler::kFarJump, RAX, kNoRegister);
+  __ TryAllocate(cls, &fall_through, Assembler::kFarJump, RAX);
 
   // Store backing array object in growable array object.
   __ movq(RCX, Address(RSP, kArrayOffset));  // data argument.
   // RAX is new, no barrier needed.
   __ InitializeFieldNoBarrier(
       RAX,
       FieldAddress(RAX, GrowableObjectArray::data_offset()),
       RCX);
 
   // RAX: new growable array object start as a tagged pointer.
@@ skipping 28 matching lines @@
   __ cmpq(RCX, FieldAddress(RDX, Array::length_offset()));
   __ j(EQUAL, &fall_through);  // Must grow data.
   // len = len + 1;
   __ IncrementSmiField(FieldAddress(RAX, GrowableObjectArray::length_offset()),
                        1);
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // Value
   ASSERT(kSmiTagShift == 1);
   __ StoreIntoObject(RDX,
                      FieldAddress(RDX, RCX, TIMES_4, Array::data_offset()),
                      RAX);
-  __ LoadObject(RAX, Object::null_object(), PP);
+  __ LoadObject(RAX, Object::null_object());
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 #define TYPED_ARRAY_ALLOCATION(type_name, cid, max_len, scale_factor)          \
   Label fall_through;                                                          \
   const intptr_t kArrayLengthStackOffset = 1 * kWordSize;                      \
   __ MaybeTraceAllocation(cid, &fall_through, false);                          \
   __ movq(RDI, Address(RSP, kArrayLengthStackOffset));  /* Array length. */    \
@@ skipping 441 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(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
   __ Bind(&true_label);
-  __ LoadObject(RAX, Bool::True(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_lessThan(Assembler* assembler) {
   CompareIntegers(assembler, LESS);
 }
 
 
@@ skipping 26 matching lines @@
 
   // For integer receiver '===' check first.
   __ 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);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
   __ Bind(&true_label);
-  __ LoadObject(RAX, Bool::True(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ ret();
 
   // At least one of the arguments was not Smi.
   Label receiver_not_smi;
   __ Bind(&check_for_mint);
   __ 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, + kArgumentOffset * kWordSize));
   __ CompareClassId(RAX, kDoubleCid);
   __ j(EQUAL, &fall_through);
-  __ LoadObject(RAX, Bool::False(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ 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, + kArgumentOffset * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through);
   // Smi == Mint -> false.
-  __ LoadObject(RAX, Bool::False(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
   // TODO(srdjan): Implement Mint == Mint comparison.
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Integer_equal(Assembler* assembler) {
   Integer_equalToInteger(assembler);
 }
@@ skipping 577 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(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ ret();
   __ Bind(&is_smi);
   __ SmiUntag(RAX);
   __ cvtsi2sdq(XMM1, RAX);
   __ jmp(&double_op);
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_greaterThan(Assembler* assembler) {
@@ skipping 35 matching lines @@
     case Token::kSUB: __ subsd(XMM0, XMM1); break;
     case Token::kMUL: __ mulsd(XMM0, XMM1); break;
     case Token::kDIV: __ divsd(XMM0, XMM1); break;
     default: UNREACHABLE();
   }
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class,
                  &fall_through,
                  Assembler::kFarJump,
-                 RAX,  // Result register.
-                 kNoRegister);  // Pool pointer might not be loaded.
+                 RAX);  // Result register.
   __ movsd(FieldAddress(RAX, Double::value_offset()), XMM0);
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::Double_add(Assembler* assembler) {
   DoubleArithmeticOperations(assembler, Token::kADD);
 }
 
@@ skipping 23 matching lines @@
   __ SmiUntag(RAX);
   __ cvtsi2sdq(XMM1, RAX);
   __ movq(RAX, Address(RSP, + 2 * kWordSize));
   __ movsd(XMM0, FieldAddress(RAX, Double::value_offset()));
   __ mulsd(XMM0, XMM1);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class,
                  &fall_through,
                  Assembler::kFarJump,
-                 RAX,  // Result register.
-                 kNoRegister);  // Pool pointer might not be loaded.
+                 RAX);  // Result register.
   __ movsd(FieldAddress(RAX, Double::value_offset()), XMM0);
   __ ret();
   __ Bind(&fall_through);
 }
 
 
 // Left is double right is integer (Bigint, Mint or Smi)
 void Intrinsifier::DoubleFromInteger(Assembler* assembler) {
   Label fall_through;
   __ movq(RAX, Address(RSP, +1 * kWordSize));
   __ testq(RAX, Immediate(kSmiTagMask));
   __ j(NOT_ZERO, &fall_through);
   // Is Smi.
   __ SmiUntag(RAX);
   __ cvtsi2sdq(XMM0, RAX);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class,
                  &fall_through,
                  Assembler::kFarJump,
-                 RAX,  // Result register.
-                 kNoRegister);  // Pool pointer might not be loaded.
+                 RAX);  // Result register.
   __ movsd(FieldAddress(RAX, Double::value_offset()), XMM0);
   __ ret();
   __ 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(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ 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(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ ret();
   __ Bind(&is_false);
-  __ LoadObject(RAX, Bool::False(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ 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 18 matching lines @@
   TestLastArgumentIsDouble(assembler, &is_smi, &fall_through);
   // Argument is double and is in RAX.
   __ movsd(XMM1, FieldAddress(RAX, Double::value_offset()));
   __ Bind(&double_op);
   __ sqrtsd(XMM0, XMM1);
   const Class& double_class = Class::Handle(
       Isolate::Current()->object_store()->double_class());
   __ TryAllocate(double_class,
                  &fall_through,
                  Assembler::kFarJump,
-                 RAX,  // Result register.
-                 kNoRegister);  // Pool pointer might not be loaded.
+                 RAX);  // Result register.
   __ movsd(FieldAddress(RAX, Double::value_offset()), XMM0);
   __ ret();
   __ Bind(&is_smi);
   __ SmiUntag(RAX);
   __ cvtsi2sdq(XMM1, RAX);
   __ jmp(&double_op);
   __ Bind(&fall_through);
 }
 
 
@@ skipping 35 matching lines @@
 
 // Identity comparison.
 void Intrinsifier::ObjectEquals(Assembler* assembler) {
   Label is_true;
   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);
-  __ LoadObject(RAX, Bool::False(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ ret();
 }
 
 
 // Return type quickly for simple types (not parameterized and not signature).
 void Intrinsifier::ObjectRuntimeType(Assembler* assembler) {
   Label fall_through;
   __ movq(RAX, Address(RSP, + 1 * kWordSize));
   __ LoadClassIdMayBeSmi(RCX, RAX);
 
   // RCX: untagged cid of instance (RAX).
-  __ LoadClassById(RDI, RCX, PP);
+  __ LoadClassById(RDI, RCX);
   // RDI: class of instance (RAX).
   __ movq(RCX, FieldAddress(RDI, Class::signature_function_offset()));
-  __ CompareObject(RCX, Object::null_object(), PP);
+  __ CompareObject(RCX, Object::null_object());
   __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
 
   __ movzxw(RCX, FieldAddress(RDI, Class::num_type_arguments_offset()));
   __ cmpq(RCX, Immediate(0));
   __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
   __ movq(RAX, FieldAddress(RDI, Class::canonical_types_offset()));
-  __ CompareObject(RAX, Object::null_object(), PP);
+  __ CompareObject(RAX, Object::null_object());
   __ j(EQUAL, &fall_through, Assembler::kNearJump);  // Not yet set.
   __ ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::String_getHashCode(Assembler* assembler) {
   Label fall_through;
   __ movq(RAX, Address(RSP, + 1 * kWordSize));  // String object.
@@ skipping 47 matching lines @@
   __ j(ABOVE_EQUAL, &fall_through, Assembler::kNearJump);
   __ CompareClassId(RAX, kOneByteStringCid);
   __ j(NOT_EQUAL, &try_two_byte_string, Assembler::kNearJump);
   __ SmiUntag(RCX);
   __ movzxb(RCX, FieldAddress(RAX, RCX, TIMES_1, OneByteString::data_offset()));
   __ cmpq(RCX, Immediate(Symbols::kNumberOfOneCharCodeSymbols));
   __ j(GREATER_EQUAL, &fall_through);
   const ExternalLabel symbols_label(
       reinterpret_cast<uword>(Symbols::PredefinedAddress()));
   __ pushq(PP);
-  __ LoadPoolPointer(PP);
+  __ LoadPoolPointer();
   assembler->set_constant_pool_allowed(true);
-  __ LoadExternalLabel(RAX, &symbols_label, kNotPatchable, PP);
+  __ LoadExternalLabel(RAX, &symbols_label, kNotPatchable);
   assembler->set_constant_pool_allowed(false);
   __ popq(PP);
   __ movq(RAX, Address(RAX,
                        RCX,
                        TIMES_8,
                        Symbols::kNullCharCodeSymbolOffset * kWordSize));
   __ ret();
 
   __ Bind(&try_two_byte_string);
   __ CompareClassId(RAX, kTwoByteStringCid);
   __ j(NOT_EQUAL, &fall_through, Assembler::kNearJump);
   ASSERT(kSmiTagShift == 1);
   __ movzxw(RCX, FieldAddress(RAX, RCX, TIMES_1, OneByteString::data_offset()));
   __ cmpq(RCX, Immediate(Symbols::kNumberOfOneCharCodeSymbols));
   __ j(GREATER_EQUAL, &fall_through);
   __ pushq(PP);
-  __ LoadPoolPointer(PP);
+  __ LoadPoolPointer();
   assembler->set_constant_pool_allowed(true);
-  __ LoadExternalLabel(RAX, &symbols_label, kNotPatchable, PP);
+  __ LoadExternalLabel(RAX, &symbols_label, kNotPatchable);
   assembler->set_constant_pool_allowed(false);
   __ popq(PP);
   __ movq(RAX, Address(RAX,
                        RCX,
                        TIMES_8,
                        Symbols::kNullCharCodeSymbolOffset * kWordSize));
   __ ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::StringBaseIsEmpty(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(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ 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 251 matching lines @@
     __ movzxw(RDX,
         FieldAddress(RCX, RDI, TIMES_2, TwoByteString::data_offset()));
   } else {
     UNIMPLEMENTED();
   }
   __ cmpq(RBX, RDX);
   __ j(NOT_EQUAL, &is_false, Assembler::kNearJump);
   __ jmp(&loop, Assembler::kNearJump);
 
   __ Bind(&is_true);
-  __ LoadObject(RAX, Bool::True(), PP);
+  __ LoadObject(RAX, Bool::True());
   __ ret();
 
   __ Bind(&is_false);
-  __ LoadObject(RAX, Bool::False(), PP);
+  __ LoadObject(RAX, Bool::False());
   __ ret();
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::OneByteString_equality(Assembler* assembler) {
   StringEquality(assembler, kOneByteStringCid);
 }
 
@@ skipping 13 matching lines @@
   // Incoming registers:
   // RAX: Function. (Will be loaded with the specialized matcher function.)
   // RCX: Unknown. (Must be GC safe on tail call.)
   // R10: Arguments descriptor. (Will be preserved.)
 
   // Load the specialized function pointer into RAX. Leverage the fact the
   // string CIDs as well as stored function pointers are in sequence.
   __ movq(RBX, Address(RSP, kRegExpParamOffset));
   __ movq(RDI, Address(RSP, kStringParamOffset));
   __ LoadClassId(RDI, RDI);
-  __ SubImmediate(RDI, Immediate(kOneByteStringCid), PP);
+  __ SubImmediate(RDI, Immediate(kOneByteStringCid));
   __ movq(RAX, FieldAddress(RBX, RDI, TIMES_8,
                             JSRegExp::function_offset(kOneByteStringCid)));
 
   // Registers are now set up for the lazy compile stub. It expects the function
   // in RAX, the argument descriptor in R10, and IC-Data in RCX.
   static const intptr_t arg_count = RegExpMacroAssembler::kParamCount;
   __ LoadObject(R10,
-      Array::ZoneHandle(ArgumentsDescriptor::New(arg_count)), PP);
+      Array::ZoneHandle(ArgumentsDescriptor::New(arg_count)));
   __ xorq(RCX, RCX);
 
   // Tail-call the function.
   __ movq(RDI, FieldAddress(RAX, Function::instructions_offset()));
   __ addq(RDI, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RDI);
 }
 
 
 // On stack: user tag (+1), return-address (+0).
@@ skipping 25 matching lines @@
   __ LoadIsolate(RAX);
   __ movq(RAX, Address(RAX, Isolate::current_tag_offset()));
   __ ret();
 }
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64