Eliminates more large immediates from x64 code.

runtime/vm/stub_code_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"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 42 matching lines @@
   // to transition to Dart VM C++ code.
   __ movq(Address(RAX, Isolate::top_exit_frame_info_offset()), RSP);
 
   // Save current Context pointer into Isolate structure.
   __ movq(Address(RAX, Isolate::top_context_offset()), CTX);
 
   // Cache Isolate pointer into CTX while executing runtime code.
   __ movq(CTX, RAX);
 
   // Reserve space for arguments and align frame before entering C++ world.
-  __ AddImmediate(RSP, Immediate(-sizeof(NativeArguments)));
+  __ subq(RSP, Immediate(sizeof(NativeArguments)));
   if (OS::ActivationFrameAlignment() > 1) {
     __ andq(RSP, Immediate(~(OS::ActivationFrameAlignment() - 1)));
   }
 
   // Pass NativeArguments structure by value and call runtime.
   __ movq(Address(RSP, isolate_offset), CTX);  // Set isolate in NativeArgs.
   // There are no runtime calls to closures, so we do not need to set the tag
   // bits kClosureFunctionBit and kInstanceFunctionBit in argc_tag_.
   __ movq(Address(RSP, argc_tag_offset), R10);  // Set argc in NativeArguments.
   __ leaq(RAX, Address(RBP, R10, TIMES_8, 1 * kWordSize));  // Compute argv.
@@ skipping 68 matching lines @@
 
   // Save current Context pointer into Isolate structure.
   __ movq(Address(R8, Isolate::top_context_offset()), CTX);
 
   // Cache Isolate pointer into CTX while executing native code.
   __ movq(CTX, R8);
 
   // Reserve space for the native arguments structure passed on the stack (the
   // outgoing pointer parameter to the native arguments structure is passed in
   // RDI) and align frame before entering the C++ world.
-  __ AddImmediate(RSP, Immediate(-sizeof(NativeArguments)));
+  __ subq(RSP, Immediate(sizeof(NativeArguments)));
   if (OS::ActivationFrameAlignment() > 1) {
     __ andq(RSP, Immediate(~(OS::ActivationFrameAlignment() - 1)));
   }
 
   // Pass NativeArguments structure by value and call native function.
   __ movq(Address(RSP, isolate_offset), CTX);  // Set isolate in NativeArgs.
   __ movq(Address(RSP, argc_tag_offset), R10);  // Set argc in NativeArguments.
   __ movq(Address(RSP, argv_offset), RAX);  // Set argv in NativeArguments.
   __ leaq(RAX, Address(RBP, 2 * kWordSize));  // Compute return value addr.
   __ movq(Address(RSP, retval_offset), RAX);  // Set retval in NativeArguments.
@@ skipping 47 matching lines @@
 
   // Save current Context pointer into Isolate structure.
   __ movq(Address(R8, Isolate::top_context_offset()), CTX);
 
   // Cache Isolate pointer into CTX while executing native code.
   __ movq(CTX, R8);
 
   // Reserve space for the native arguments structure passed on the stack (the
   // outgoing pointer parameter to the native arguments structure is passed in
   // RDI) and align frame before entering the C++ world.
-  __ AddImmediate(RSP, Immediate(-sizeof(NativeArguments)));
+  __ subq(RSP, Immediate(sizeof(NativeArguments)));
   if (OS::ActivationFrameAlignment() > 1) {
     __ andq(RSP, Immediate(~(OS::ActivationFrameAlignment() - 1)));
   }
 
   // Pass NativeArguments structure by value and call native function.
   __ movq(Address(RSP, isolate_offset), CTX);  // Set isolate in NativeArgs.
   __ movq(Address(RSP, argc_tag_offset), R10);  // Set argc in NativeArguments.
   __ movq(Address(RSP, argv_offset), RAX);  // Set argv in NativeArguments.
   __ leaq(RAX, Address(RBP, 2 * kWordSize));  // Compute return value addr.
   __ movq(Address(RSP, retval_offset), RAX);  // Set retval in NativeArguments.
@@ skipping 17 matching lines @@
   __ ret();
 }
 
 
 // Input parameters:
 //   R10: arguments descriptor array.
 void StubCode::GenerateCallStaticFunctionStub(Assembler* assembler) {
   __ EnterStubFrame();
   __ pushq(R10);  // Preserve arguments descriptor array.
   // Setup space on stack for return value.
-  __ PushObject(Object::null_object());
+  __ PushObject(Object::null_object(), PP);
   __ CallRuntime(kPatchStaticCallRuntimeEntry, 0);
   __ popq(RAX);  // Get Code object result.
   __ popq(R10);  // Restore arguments descriptor array.
   // Remove the stub frame as we are about to jump to the dart function.
   __ LeaveFrame();
 
   __ movq(RBX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RBX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RBX);
 }
 
 
 // Called from a static call only when an invalid code has been entered
 // (invalid because its function was optimized or deoptimized).
 // R10: arguments descriptor array.
 void StubCode::GenerateFixCallersTargetStub(Assembler* assembler) {
   __ EnterStubFrame();
   __ pushq(R10);  // Preserve arguments descriptor array.
   // Setup space on stack for return value.
-  __ PushObject(Object::null_object());
+  __ PushObject(Object::null_object(), PP);
   __ CallRuntime(kFixCallersTargetRuntimeEntry, 0);
   __ popq(RAX);  // Get Code object.
   __ popq(R10);  // Restore arguments descriptor array.
   __ movq(RAX, FieldAddress(RAX, Code::instructions_offset()));
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ LeaveFrame();
   __ jmp(RAX);
   __ int3();
 }
 
@@ skipping 12 matching lines @@
   __ pushq(RAX);  // Array is in RAX and on top of stack.
   __ leaq(R12, Address(RBP, R10, TIMES_8, kParamEndSlotFromFp * kWordSize));
   __ leaq(RBX, FieldAddress(RAX, Array::data_offset()));
   // R12: address of first argument on stack.
   // RBX: address of first argument in array.
   Label loop, loop_condition;
   __ jmp(&loop_condition, Assembler::kNearJump);
   __ Bind(&loop);
   __ movq(RAX, Address(R12, 0));
   __ movq(Address(RBX, 0), RAX);
-  __ AddImmediate(RBX, Immediate(kWordSize));
-  __ AddImmediate(R12, Immediate(-kWordSize));
+  __ addq(RBX, Immediate(kWordSize));
+  __ subq(R12, Immediate(kWordSize));
   __ Bind(&loop_condition);
   __ decq(R10);
   __ j(POSITIVE, &loop, Assembler::kNearJump);
 }
 
 
 // Input parameters:
 //   RBX: ic-data.
 //   R10: arguments descriptor array.
 // Note: The receiver object is the first argument to the function being
 //       called, the stub accesses the receiver from this location directly
 //       when trying to resolve the call.
 void StubCode::GenerateInstanceFunctionLookupStub(Assembler* assembler) {
   __ EnterStubFrameWithPP();
-  __ PushObject(Object::null_object());  // Space for the return value.
+  __ PushObject(Object::null_object(), PP);  // Space for the return value.
 
   // Push the receiver as an argument.  Load the smi-tagged argument
   // count into R13 to index the receiver in the stack.  There are
   // four words (null, stub's pc marker, saved pp, saved fp) above the return
   // address.
   __ movq(R13, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   __ pushq(Address(RSP, R13, TIMES_4, (4 * kWordSize)));
 
   __ pushq(RBX);  // Pass IC data object.
   __ pushq(R10);  // Pass arguments descriptor array.
@@ skipping 159 matching lines @@
   __ movq(RAX, FieldAddress(R10, ArgumentsDescriptor::count_offset()));
   // Three words (saved pp, saved fp, stub's pc marker)
   // in the stack above the return address.
   __ movq(RAX, Address(RSP, RAX, TIMES_4,
                        kSavedAboveReturnAddress * kWordSize));
   // Preserve IC data and arguments descriptor.
   __ pushq(RBX);
   __ pushq(R10);
 
   // Space for the result of the runtime call.
-  __ PushObject(Object::null_object());
+  __ PushObject(Object::null_object(), PP);
   __ pushq(RAX);  // Receiver.
   __ pushq(RBX);  // IC data.
   __ pushq(R10);  // Arguments descriptor.
   __ CallRuntime(kMegamorphicCacheMissHandlerRuntimeEntry, 3);
   // Discard arguments.
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);
   __ popq(RAX);  // Return value from the runtime call (instructions).
   __ popq(R10);  // Restore arguments descriptor.
   __ popq(RBX);  // Restore IC data.
   __ LeaveFrameWithPP();
 
   Label lookup;
-  __ CompareObject(RAX, Object::null_object());
+  __ CompareObject(RAX, Object::null_object(), PP);
   __ j(EQUAL, &lookup, Assembler::kNearJump);
   __ addq(RAX, Immediate(Instructions::HeaderSize() - kHeapObjectTag));
   __ jmp(RAX);
 
   __ Bind(&lookup);
   __ jmp(&StubCode::InstanceFunctionLookupLabel());
 }
 
 
 // Called for inline allocation of arrays.
@@ skipping 110 matching lines @@
     __ ret();
   }
 
   // Unable to allocate the array using the fast inline code, just call
   // into the runtime.
   __ Bind(&slow_case);
   // Create a stub frame as we are pushing some objects on the stack before
   // calling into the runtime.
   __ EnterStubFrame();
   // Setup space on stack for return value.
-  __ PushObject(Object::null_object());
+  __ PushObject(Object::null_object(), PP);
   __ pushq(R10);  // Array length as Smi.
   __ pushq(RBX);  // Element type.
   __ CallRuntime(kAllocateArrayRuntimeEntry, 2);
   __ popq(RAX);  // Pop element type argument.
   __ popq(R10);  // Pop array length argument.
   __ popq(RAX);  // Pop return value from return slot.
   __ LeaveFrame();
   __ ret();
 }
 
@@ skipping 557 matching lines @@
 
     __ Bind(&slow_case);
   }
   if (is_cls_parameterized) {
     __ movq(RAX, Address(RSP, kObjectTypeArgumentsOffset));
     __ movq(RDX, Address(RSP, kInstantiatorTypeArgumentsOffset));
   }
   // Create a stub frame.
   __ EnterStubFrameWithPP();
   __ pushq(R12);  // Setup space on stack for return value.
-  __ PushObject(cls);  // Push class of object to be allocated.
+  __ PushObject(cls, PP);  // Push class of object to be allocated.
   if (is_cls_parameterized) {
     __ pushq(RAX);  // Push type arguments of object to be allocated.
     __ pushq(RDX);  // Push type arguments of instantiator.
   } else {
     __ pushq(R12);  // Push null type arguments.
     __ pushq(Immediate(Smi::RawValue(StubCode::kNoInstantiator)));
   }
   __ CallRuntime(kAllocateObjectRuntimeEntry, 3);  // Allocate object.
   __ popq(RAX);  // Pop argument (instantiator).
   __ popq(RAX);  // Pop argument (type arguments of object).
@@ skipping 115 matching lines @@
     __ Bind(&slow_case);
   }
   if (has_type_arguments) {
     __ movq(RCX, Address(RSP, kTypeArgumentsOffset));
   }
   if (is_implicit_instance_closure) {
     __ movq(RAX, Address(RSP, kReceiverOffset));
   }
 
   __ pushq(R12);  // Setup space on stack for the return value.
-  __ PushObject(func);
+  __ PushObject(func, PP);
   if (is_implicit_instance_closure) {
     __ pushq(RAX);  // Receiver.
   }
   if (has_type_arguments) {
     __ pushq(RCX);  // Push type arguments of closure to be allocated.
   } else {
     __ pushq(R12);  // Push null type arguments.
   }
   if (is_implicit_instance_closure) {
     __ CallRuntime(kAllocateImplicitInstanceClosureRuntimeEntry, 3);
@@ skipping 704 matching lines @@
   __ Bind(&not_smi);
   __ LoadClassId(RAX, RAX);
   __ SmiTag(RAX);
   __ ret();
 
   __ Bind(&update_ic_data);
 
   // RBX: ICData
   __ movq(RAX, Address(RSP, 1 * kWordSize));
   __ movq(R13, Address(RSP, 2 * kWordSize));
-  __ EnterStubFrame();
+  __ EnterStubFrameWithPP();
   __ pushq(R13);  // arg 0
   __ pushq(RAX);  // arg 1
-  __ PushObject(Symbols::EqualOperator());  // Target's name.
+  __ PushObject(Symbols::EqualOperator(), PP);  // Target's name.
   __ pushq(RBX);  // ICData
   __ CallRuntime(kUpdateICDataTwoArgsRuntimeEntry, 4);
   __ Drop(4);
-  __ LeaveFrame();
+  __ LeaveFrameWithPP();
 
   __ jmp(&compute_result, Assembler::kNearJump);
 }
 
 // Calls to the runtime to optimize the given function.
 // RDI: function to be reoptimized.
 // R10: argument descriptor (preserved).
 void StubCode::GenerateOptimizeFunctionStub(Assembler* assembler) {
   __ EnterStubFrameWithPP();
   __ LoadObject(R12, Object::null_object(), PP);
@@ skipping 122 matching lines @@
   __ movq(right, Address(RSP, 3 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right);
   __ popq(right);
   __ popq(left);
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64