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

runtime/vm/assembler_x64.h

 // 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.
 
 #ifndef VM_ASSEMBLER_X64_H_
 #define VM_ASSEMBLER_X64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_x64.h directly; use assembler.h instead.
 #endif
@@ skipping 352 matching lines @@
   void call(Register reg);
   void call(const Address& address);
   void call(Label* label);
   void call(const ExternalLabel* label);
 
   static const intptr_t kCallExternalLabelSize = 7;
 
   void pushq(Register reg);
   void pushq(const Address& address);
   void pushq(const Immediate& imm);
-  void PushImmediate(const Immediate& imm, Register pp);
+  void PushImmediate(const Immediate& imm);
 
   void popq(Register reg);
   void popq(const Address& address);
 
   void setcc(Condition condition, ByteRegister dst);
 
   void movl(Register dst, Register src);
   void movl(Register dst, const Immediate& imm);
   void movl(Register dst, const Address& src);
   void movl(const Address& dst, Register src);
@@ skipping 136 matching lines @@
   void cmpl(Register reg0, Register reg1);
   void cmpl(Register reg, const Address& address);
   void cmpl(const Address& address, const Immediate& imm);
 
   void cmpq(Register reg, const Immediate& imm);
   void cmpq(const Address& address, Register reg);
   void cmpq(const Address& address, const Immediate& imm);
   void cmpq(Register reg0, Register reg1);
   void cmpq(Register reg, const Address& address);
 
-  void CompareImmediate(Register reg, const Immediate& imm, Register pp);
-  void CompareImmediate(const Address& address, const Immediate& imm,
-                        Register pp);
+  void CompareImmediate(Register reg, const Immediate& imm);
+  void CompareImmediate(const Address& address, const Immediate& imm);
 
   void testl(Register reg1, Register reg2);
   void testl(Register reg, const Immediate& imm);
   void testb(const Address& address, const Immediate& imm);
 
   void testq(Register reg1, Register reg2);
   void testq(Register reg, const Immediate& imm);
-  void TestImmediate(Register dst, const Immediate& imm, Register pp);
+  void TestImmediate(Register dst, const Immediate& imm);
 
   void andl(Register dst, Register src);
   void andl(Register dst, const Immediate& imm);
 
   void orl(Register dst, Register src);
   void orl(Register dst, const Immediate& imm);
   void orl(const Address& dst, Register src);
 
   void xorl(Register dst, Register src);
 
   void andq(Register dst, Register src);
   void andq(Register dst, const Address& address);
   void andq(Register dst, const Immediate& imm);
-  void AndImmediate(Register dst, const Immediate& imm, Register pp);
+  void AndImmediate(Register dst, const Immediate& imm);
 
   void orq(Register dst, Register src);
   void orq(Register dst, const Address& address);
   void orq(Register dst, const Immediate& imm);
-  void OrImmediate(Register dst, const Immediate& imm, Register pp);
+  void OrImmediate(Register dst, const Immediate& imm);
 
   void xorq(Register dst, Register src);
   void xorq(Register dst, const Address& address);
   void xorq(const Address& dst, Register src);
   void xorq(Register dst, const Immediate& imm);
-  void XorImmediate(Register dst, const Immediate& imm, Register pp);
+  void XorImmediate(Register dst, const Immediate& imm);
 
   void addl(Register dst, Register src);
   void addl(Register dst, const Immediate& imm);
   void addl(Register dst, const Address& address);
   void addl(const Address& address, Register src);
   void adcl(Register dst, Register src);
   void adcl(Register dst, const Immediate& imm);
   void adcl(Register dst, const Address& address);
 
   void addq(Register dst, Register src);
@@ skipping 14 matching lines @@
   void idivq(Register reg);
   void divq(Register reg);
 
   void imull(Register dst, Register src);
   void imull(Register reg, const Immediate& imm);
   void mull(Register reg);
 
   void imulq(Register dst, Register src);
   void imulq(Register dst, const Address& address);
   void imulq(Register dst, const Immediate& imm);
-  void MulImmediate(Register reg, const Immediate& imm, Register pp);
+  void MulImmediate(Register reg, const Immediate& imm);
   void mulq(Register reg);
 
   void subl(Register dst, Register src);
   void subl(Register dst, const Immediate& imm);
   void subl(Register dst, const Address& address);
   void sbbl(Register dst, Register src);
   void sbbl(Register dst, const Immediate& imm);
   void sbbl(Register dst, const Address& address);
 
   void subq(Register dst, Register src);
@@ skipping 121 matching lines @@
   /*
    * Macros for High-level operations and implemented on all architectures.
    */
 
   void CompareRegisters(Register a, Register b);
 
   // Issues a move instruction if 'to' is not the same as 'from'.
   void MoveRegister(Register to, Register from);
   void PopRegister(Register r);
 
-  // Macros accepting a pp Register argument may attempt to load values from
-  // the object pool when possible. Unless you are sure that the untagged object
-  // pool pointer is in another register, or that it is not available at all,
-  // PP should be passed for pp.
+  // Macros for adding/subtracting an immediate value that may be loaded from
+  // the constant pool.
   // TODO(koda): Assert that these are not used for heap objects.
-  void AddImmediate(Register reg, const Immediate& imm, Register pp);
-  void AddImmediate(const Address& address, const Immediate& imm, Register pp);
-  void SubImmediate(Register reg, const Immediate& imm, Register pp);
-  void SubImmediate(const Address& address, const Immediate& imm, Register pp);
+  void AddImmediate(Register reg, const Immediate& imm);
+  void AddImmediate(const Address& address, const Immediate& imm);
+  void SubImmediate(Register reg, const Immediate& imm);
+  void SubImmediate(const Address& address, const Immediate& imm);
 
   void Drop(intptr_t stack_elements, Register tmp = TMP);
 
   bool constant_pool_allowed() const {
     return constant_pool_allowed_;
   }
   void set_constant_pool_allowed(bool b) {
     constant_pool_allowed_ = b;
   }
 
-  bool CanLoadImmediateFromPool(const Immediate& imm, Register pp);
-  void LoadImmediate(Register reg, const Immediate& imm, Register pp);
+  void LoadImmediate(Register reg, const Immediate& imm);
   void LoadIsolate(Register dst);
-  void LoadObject(Register dst, const Object& obj, Register pp);
-  void LoadUniqueObject(Register dst, const Object& obj, Register pp);
+  void LoadObject(Register dst, const Object& obj);
+  void LoadUniqueObject(Register dst, const Object& obj);
   void LoadExternalLabel(Register dst,
                          const ExternalLabel* label,
-                         Patchability patchable,
-                         Register pp);
+                         Patchability patchable);
+  void LoadFunctionFromCalleePool(Register dst,
+                                  const Function& function,
+                                  Register new_pp);
   void JmpPatchable(const ExternalLabel* label, Register pp);
   void Jmp(const ExternalLabel* label, Register pp);
   void J(Condition condition, const ExternalLabel* label, Register pp);
   void CallPatchable(const ExternalLabel* label);
-  void Call(const ExternalLabel* label, Register pp);
+  void Call(const ExternalLabel* label);
   // Unaware of write barrier (use StoreInto* methods for storing to objects).
   // TODO(koda): Add StackAddress/HeapAddress types to prevent misuse.
-  void StoreObject(const Address& dst, const Object& obj, Register pp);
-  void PushObject(const Object& object, Register pp);
-  void CompareObject(Register reg, const Object& object, Register pp);
+  void StoreObject(const Address& dst, const Object& obj);
+  void PushObject(const Object& object);
+  void CompareObject(Register reg, const Object& object);
 
   // When storing into a heap object field, knowledge of the previous content
   // is expressed through these constants.
   enum FieldContent {
     kEmptyOrSmiOrNull,  // Empty = garbage/zapped in release/debug mode.
     kHeapObjectOrSmi,
     kOnlySmi,
   };
 
   // Destroys value.
   void StoreIntoObject(Register object,  // Object we are storing into.
                        const Address& dest,  // Where we are storing into.
                        Register value,  // Value we are storing.
                        bool can_value_be_smi = true);
 
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 Register value,
                                 FieldContent old_content = kHeapObjectOrSmi);
   void InitializeFieldNoBarrier(Register object,
                                 const Address& dest,
                                 Register value) {
     return StoreIntoObjectNoBarrier(object, dest, value, kEmptyOrSmiOrNull);
   }
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 const Object& value,
-                                Register pp,
                                 FieldContent old_content = kHeapObjectOrSmi);
   void InitializeFieldNoBarrier(Register object,
                                 const Address& dest,
-                                const Object& value,
-                                Register pp) {
-    return StoreIntoObjectNoBarrier(object, dest, value, pp, kEmptyOrSmiOrNull);
+                                const Object& value) {
+    return StoreIntoObjectNoBarrier(object, dest, value, kEmptyOrSmiOrNull);
   }
 
   // Stores a Smi value into a heap object field that always contains a Smi.
   void StoreIntoSmiField(const Address& dest, Register value);
   void ZeroInitSmiField(const Address& dest);
   // Increments a Smi field. Leaves flags in same state as an 'addq'.
   void IncrementSmiField(const Address& dest, int64_t increment);
 
   void DoubleNegate(XmmRegister d);
   void FloatNegate(XmmRegister f);
@@ skipping 23 matching lines @@
   // Call runtime function. Reserves shadow space on the stack before calling
   // if platform ABI requires that. Does not restore RSP after the call itself.
   void CallCFunction(const ExternalLabel* label);
   void CallCFunction(Register reg);
 
   /*
    * Loading and comparing classes of objects.
    */
   void LoadClassId(Register result, Register object);
 
-  void LoadClassById(Register result, Register class_id, Register pp);
+  void LoadClassById(Register result, Register class_id);
 
-  void LoadClass(Register result, Register object, Register pp);
+  void LoadClass(Register result, Register object);
 
   void CompareClassId(Register object, intptr_t class_id);
 
   void LoadClassIdMayBeSmi(Register result, Register object);
   void LoadTaggedClassIdMayBeSmi(Register result, Register object);
 
   // CheckClassIs fused with optimistic SmiUntag.
   // Value in the register object is untagged optimistically.
   void SmiUntagOrCheckClass(Register object, intptr_t class_id, Label* smi);
 
@@ skipping 46 matching lines @@
   ObjectPoolWrapper& object_pool_wrapper() { return object_pool_wrapper_; }
 
   RawObjectPool* MakeObjectPool() {
     return object_pool_wrapper_.MakeObjectPool();
   }
 
   void FinalizeInstructions(const MemoryRegion& region) {
     buffer_.FinalizeInstructions(region);
   }
 
-  void LoadPoolPointer(Register pp);
+  void LoadPoolPointer(Register pp = PP);
 
   // Set up a Dart frame on entry with a frame pointer and PC information to
   // enable easy access to the RawInstruction object of code corresponding
   // to this frame.
   // The dart frame layout is as follows:
   //   ....
   //   locals space  <=== RSP
   //   saved PP
   //   pc (used to derive the RawInstruction Object of the dart code)
   //   saved RBP     <=== RBP
@@ skipping 63 matching lines @@
   // which will allocate in the runtime where tracing occurs.
   void MaybeTraceAllocation(intptr_t cid,
                             Label* trace,
                             bool near_jump,
                             bool inline_isolate = true);
 
   // Inlined allocation of an instance of class 'cls', code has no runtime
   // calls. Jump to 'failure' if the instance cannot be allocated here.
   // Allocated instance is returned in 'instance_reg'.
   // Only the tags field of the object is initialized.
-  // Loads large immediates from the object pool with pool pointer in PP if it
-  // is not kNoRegister
   void TryAllocate(const Class& cls,
                    Label* failure,
                    bool near_jump,
-                   Register instance_reg,
-                   Register pp);
+                   Register instance_reg);
 
   void TryAllocateArray(intptr_t cid,
                         intptr_t instance_size,
                         Label* failure,
                         bool near_jump,
                         Register instance,
                         Register end_address);
 
   // Debugging and bringup support.
   void Stop(const char* message, bool fixed_length_encoding = false);
@@ skipping 43 matching lines @@
     const String& comment_;
 
     DISALLOW_COPY_AND_ASSIGN(CodeComment);
   };
 
   GrowableArray<CodeComment*> comments_;
   bool constant_pool_allowed_;
 
   intptr_t FindImmediate(int64_t imm);
   bool CanLoadFromObjectPool(const Object& object) const;
-  void LoadObjectHelper(Register dst,
-                        const Object& obj,
-                        Register pp,
-                        bool is_unique);
-  void LoadWordFromPoolOffset(Register dst, Register pp, int32_t offset);
+  void LoadObjectHelper(Register dst, const Object& obj, bool is_unique);
+  void LoadWordFromPoolOffset(Register dst, int32_t offset);
 
   inline void EmitUint8(uint8_t value);
   inline void EmitInt32(int32_t value);
   inline void EmitInt64(int64_t value);
 
   inline void EmitRegisterREX(Register reg, uint8_t rex);
   inline void EmitOperandREX(int rm, const Operand& operand, uint8_t rex);
   inline void EmitXmmRegisterOperand(int rm, XmmRegister reg);
   inline void EmitFixup(AssemblerFixup* fixup);
   inline void EmitOperandSizeOverride();
@@ skipping 30 matching lines @@
   void VerifyObjectOrSmi(const Address& address);
   void VerifySmi(const Address& address, const char* stop_msg = "Expected Smi");
 #endif  // DEBUG
   // Like VerifiedMemory::Verify(address, kWordSize) and ::Write, but also,
   // in DEBUG mode, verifies that 'address' has content of type 'old_content'.
   void VerifyHeapWord(const Address& address, FieldContent old_content);
   void VerifiedWrite(const Address& dest,
                      Register value,
                      FieldContent old_content);
   // Unaware of write barrier (use StoreInto* methods for storing to objects).
-  void MoveImmediate(const Address& dst, const Immediate& imm, Register pp);
+  void MoveImmediate(const Address& dst, const Immediate& imm);
 
   void ComputeCounterAddressesForCid(intptr_t cid,
                                      Heap::Space space,
                                      Address* count_address,
                                      Address* size_address);
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 
@@ skipping 68 matching lines @@
 }
 
 
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_X64_H_