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

runtime/vm/assembler_arm64.h

 // Copyright (c) 2014, 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_ARM64_H_
 #define VM_ASSEMBLER_ARM64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_arm64.h directly; use assembler.h instead.
 #endif
@@ skipping 101 matching lines @@
     PCOffset,
     Unknown,
   };
 
   // Offset is in bytes. For the unsigned imm12 case, we unscale based on the
   // operand size, and assert that offset is aligned accordingly.
   // For the smaller signed imm9 case, the offset is the number of bytes, but
   // is unscaled.
   Address(Register rn, int32_t offset = 0, AddressType at = Offset,
           OperandSize sz = kDoubleWord) {
-    ASSERT((rn != R31) && (rn != ZR));
+    ASSERT((rn != kNoRegister) && (rn != R31) && (rn != ZR));
     ASSERT(CanHoldOffset(offset, at, sz));
     const Register crn = ConcreteRegister(rn);
     const int32_t scale = Log2OperandSizeBytes(sz);
     if ((at == Offset) &&
          Utils::IsUint(12 + scale, offset) &&
         (offset == ((offset >> scale) << scale))) {
       encoding_ =
           B24 |
           ((offset >> scale) << kImm12Shift) |
           (static_cast<int32_t>(crn) << kRnShift);
@@ skipping 1021 matching lines @@
   void TagAndPushPPAndPcMarker(Register pc_marker_reg) {
     ASSERT(pc_marker_reg != TMP2);
     // Add the heap object tag back to PP before putting it on the stack.
     add(TMP2, PP, Operand(kHeapObjectTag));
     stp(TMP2, pc_marker_reg,
         Address(SP, -2 * kWordSize, Address::PairPreIndex));
   }
   void PopAndUntagPP() {
     ldr(PP, Address(SP, 1 * kWordSize, Address::PostIndex));
     sub(PP, PP, Operand(kHeapObjectTag));
+    // The caller of PopAndUntagPP() must explicitly allow use of popped PP.
+    set_constant_pool_allowed(false);
   }
   void tst(Register rn, Operand o) {
     ands(ZR, rn, o);
   }
   void tsti(Register rn, const Immediate& imm) {
     andis(ZR, rn, imm);
   }
 
   void LslImmediate(Register rd, Register rn, int shift) {
     add(rd, ZR, Operand(rn, LSL, shift));
@@ skipping 15 matching lines @@
     AsrImmediate(dst, src, kSmiTagSize);
   }
   void SmiTag(Register reg) {
     LslImmediate(reg, reg, kSmiTagSize);
   }
   void SmiTag(Register dst, Register src) {
     LslImmediate(dst, src, kSmiTagSize);
   }
 
   // Branching to ExternalLabels.
-  void Branch(const ExternalLabel* label, Register pp) {
-    LoadExternalLabel(TMP, label, kNotPatchable, pp);
+  void Branch(const ExternalLabel* label) {
+    LoadExternalLabel(TMP, label);
     br(TMP);
   }
 
   // Fixed length branch to label.
   void BranchPatchable(const ExternalLabel* label) {
     // TODO(zra): Use LoadExternalLabelFixed if possible.
     LoadImmediateFixed(TMP, label->address());
     br(TMP);
   }
 
-  void BranchLink(const ExternalLabel* label, Register pp) {
-    LoadExternalLabel(TMP, label, kNotPatchable, pp);
+  void BranchLink(const ExternalLabel* label) {
+    LoadExternalLabel(TMP, label);
     blr(TMP);
   }
 
   // BranchLinkPatchable must be a fixed-length sequence so we can patch it
   // with the debugger.
   void BranchLinkPatchable(const ExternalLabel* label) {
-    LoadExternalLabelFixed(TMP, label, kPatchable, PP);
+    LoadExternalLabelFixed(TMP, label, kPatchable);
     blr(TMP);
   }
 
   // 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.
-  void AddImmediate(Register dest, Register rn, int64_t imm, Register pp);
-  void AddImmediateSetFlags(
-      Register dest, Register rn, int64_t imm, Register pp);
-  void SubImmediateSetFlags(
-      Register dest, Register rn, int64_t imm, Register pp);
-  void AndImmediate(Register rd, Register rn, int64_t imm, Register pp);
-  void OrImmediate(Register rd, Register rn, int64_t imm, Register pp);
-  void XorImmediate(Register rd, Register rn, int64_t imm, Register pp);
-  void TestImmediate(Register rn, int64_t imm, Register pp);
-  void CompareImmediate(Register rn, int64_t imm, Register pp);
+  void AddImmediate(Register dest, Register rn, int64_t imm);
+  void AddImmediateSetFlags(Register dest, Register rn, int64_t imm);
+  void SubImmediateSetFlags(Register dest, Register rn, int64_t imm);
+  void AndImmediate(Register rd, Register rn, int64_t imm);
+  void OrImmediate(Register rd, Register rn, int64_t imm);
+  void XorImmediate(Register rd, Register rn, int64_t imm);
+  void TestImmediate(Register rn, int64_t imm);
+  void CompareImmediate(Register rn, int64_t imm);
 
   void LoadFromOffset(Register dest, Register base, int32_t offset,
-                      Register pp, OperandSize sz = kDoubleWord);
+                      OperandSize sz = kDoubleWord);
   void LoadFieldFromOffset(Register dest, Register base, int32_t offset,
-                           Register pp, OperandSize sz = kDoubleWord) {
-    LoadFromOffset(dest, base, offset - kHeapObjectTag, pp, sz);
+                           OperandSize sz = kDoubleWord) {
+    LoadFromOffset(dest, base, offset - kHeapObjectTag, sz);
   }
-  void LoadDFromOffset(
-      VRegister dest, Register base, int32_t offset, Register pp);
-  void LoadDFieldFromOffset(
-      VRegister dest, Register base, int32_t offset, Register pp) {
-    LoadDFromOffset(dest, base, offset - kHeapObjectTag, pp);
+  void LoadDFromOffset(VRegister dest, Register base, int32_t offset);
+  void LoadDFieldFromOffset(VRegister dest, Register base, int32_t offset) {
+    LoadDFromOffset(dest, base, offset - kHeapObjectTag);
   }
-  void LoadQFromOffset(
-      VRegister dest, Register base, int32_t offset, Register pp);
-  void LoadQFieldFromOffset(
-      VRegister dest, Register base, int32_t offset, Register pp) {
-    LoadQFromOffset(dest, base, offset - kHeapObjectTag, pp);
+  void LoadQFromOffset(VRegister dest, Register base, int32_t offset);
+  void LoadQFieldFromOffset(VRegister dest, Register base, int32_t offset) {
+    LoadQFromOffset(dest, base, offset - kHeapObjectTag);
   }
 
   void StoreToOffset(Register src, Register base, int32_t offset,
-                     Register pp, OperandSize sz = kDoubleWord);
+                     OperandSize sz = kDoubleWord);
   void StoreFieldToOffset(Register src, Register base, int32_t offset,
-                          Register pp, OperandSize sz = kDoubleWord) {
-    StoreToOffset(src, base, offset - kHeapObjectTag, pp, sz);
+                          OperandSize sz = kDoubleWord) {
+    StoreToOffset(src, base, offset - kHeapObjectTag, sz);
   }
-  void StoreDToOffset(
-      VRegister src, Register base, int32_t offset, Register pp);
-  void StoreDFieldToOffset(
-      VRegister src, Register base, int32_t offset, Register pp) {
-    StoreDToOffset(src, base, offset - kHeapObjectTag, pp);
+  void StoreDToOffset(VRegister src, Register base, int32_t offset);
+  void StoreDFieldToOffset(VRegister src, Register base, int32_t offset) {
+    StoreDToOffset(src, base, offset - kHeapObjectTag);
   }
-  void StoreQToOffset(
-      VRegister src, Register base, int32_t offset, Register pp);
-  void StoreQFieldToOffset(
-      VRegister src, Register base, int32_t offset, Register pp) {
-    StoreQToOffset(src, base, offset - kHeapObjectTag, pp);
+  void StoreQToOffset(VRegister src, Register base, int32_t offset);
+  void StoreQFieldToOffset(VRegister src, Register base, int32_t offset) {
+    StoreQToOffset(src, base, offset - kHeapObjectTag);
   }
 
   // Storing into an object.
   void StoreIntoObject(Register object,
                        const Address& dest,
                        Register value,
                        bool can_value_be_smi = true);
   void StoreIntoObjectOffset(Register object,
                              int32_t offset,
                              Register value,
-                             Register pp,
                              bool can_value_be_smi = true);
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 Register value);
   void StoreIntoObjectOffsetNoBarrier(Register object,
                                       int32_t offset,
-                                      Register value,
-                                      Register pp);
+                                      Register value);
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 const Object& value);
   void StoreIntoObjectOffsetNoBarrier(Register object,
                                       int32_t offset,
-                                      const Object& value,
-                                      Register pp);
+                                      const Object& value);
 
   // Object pool, loading from pool, etc.
-  void LoadPoolPointer(Register pp);
+  void LoadPoolPointer();
 
   bool constant_pool_allowed() const {
     return constant_pool_allowed_;
   }
   void set_constant_pool_allowed(bool b) {
     constant_pool_allowed_ = b;
   }
 
-  void LoadWordFromPoolOffset(Register dst, Register pp, uint32_t offset);
-  void LoadWordFromPoolOffsetFixed(Register dst, Register pp, uint32_t offset);
+  void LoadWordFromPoolOffset(Register dst, uint32_t offset);
+  void LoadWordFromPoolOffsetFixed(Register dst, uint32_t offset);
   intptr_t FindImmediate(int64_t imm);
   bool CanLoadFromObjectPool(const Object& object) const;
-  bool CanLoadImmediateFromPool(int64_t imm, Register pp);
-  void LoadExternalLabel(Register dst, const ExternalLabel* label,
-                         Patchability patchable, Register pp);
+  void LoadExternalLabel(Register dst, const ExternalLabel* label);
   void LoadExternalLabelFixed(Register dst,
                               const ExternalLabel* label,
-                              Patchability patchable,
-                              Register pp);
+                              Patchability patchable);
   void LoadIsolate(Register dst);
-  void LoadObject(Register dst, const Object& obj, Register pp);
-  void LoadUniqueObject(Register dst, const Object& obj, Register pp);
-  void LoadDecodableImmediate(Register reg, int64_t imm, Register pp);
+  void LoadObject(Register dst, const Object& obj);
+  void LoadUniqueObject(Register dst, const Object& obj);
+  void LoadDecodableImmediate(Register reg, int64_t imm);
   void LoadImmediateFixed(Register reg, int64_t imm);
-  void LoadImmediate(Register reg, int64_t imm, Register pp);
-  void LoadDImmediate(VRegister reg, double immd, Register pp);
+  void LoadImmediate(Register reg, int64_t imm);
+  void LoadDImmediate(VRegister reg, double immd);
 
-  void PushObject(const Object& object, Register pp) {
-    LoadObject(TMP, object, pp);
+  void PushObject(const Object& object) {
+    LoadObject(TMP, object);
     Push(TMP);
   }
-  void CompareObject(Register reg, const Object& object, Register pp);
+  void CompareObject(Register reg, const Object& object);
 
-  void LoadClassId(Register result, Register object, Register pp);
-  void LoadClassById(Register result, Register class_id, Register pp);
-  void LoadClass(Register result, Register object, Register pp);
-  void CompareClassId(Register object, intptr_t class_id, Register pp);
+  void LoadClassId(Register result, Register object);
+  void LoadClassById(Register result, Register class_id);
+  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);
 
   void ComputeRange(Register result,
                     Register value,
                     Register scratch,
                     Label* miss);
 
   void UpdateRangeFeedback(Register value,
                            intptr_t idx,
@@ skipping 22 matching lines @@
   void EnterCallRuntimeFrame(intptr_t frame_size);
   void LeaveCallRuntimeFrame();
   void CallRuntime(const RuntimeEntry& entry, intptr_t argument_count);
 
   // Set up a stub frame so that the stack traversal code can easily identify
   // a stub frame.
   void EnterStubFrame();
   void LeaveStubFrame();
 
   void UpdateAllocationStats(intptr_t cid,
-                             Register pp,
                              Heap::Space space,
                              bool inline_isolate = true);
 
   void UpdateAllocationStatsWithSize(intptr_t cid,
                                      Register size_reg,
-                                     Register pp,
                                      Heap::Space space,
                                      bool inline_isolate = true);
 
   // If allocation tracing for |cid| is enabled, will jump to |trace| label,
   // which will allocate in the runtime where tracing occurs.
   void MaybeTraceAllocation(intptr_t cid,
                             Register temp_reg,
-                            Register pp,
                             Label* trace,
                             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.
   void TryAllocate(const Class& cls,
                    Label* failure,
                    Register instance_reg,
-                   Register temp_reg,
-                   Register pp);
+                   Register temp_reg);
 
   void TryAllocateArray(intptr_t cid,
                         intptr_t instance_size,
                         Label* failure,
                         Register instance,
                         Register end_address,
                         Register temp1,
                         Register temp2);
 
   Address ElementAddressForIntIndex(bool is_external,
@@ skipping 29 matching lines @@
     intptr_t pc_offset_;
     const String& comment_;
 
     DISALLOW_COPY_AND_ASSIGN(CodeComment);
   };
 
   GrowableArray<CodeComment*> comments_;
 
   bool constant_pool_allowed_;
 
-  void LoadObjectHelper(Register dst,
-                        const Object& obj,
-                        Register pp,
-                        bool is_unique);
+  void LoadObjectHelper(Register dst, const Object& obj, bool is_unique);
 
   void AddSubHelper(OperandSize os, bool set_flags, bool subtract,
                     Register rd, Register rn, Operand o) {
     ASSERT((rd != R31) && (rn != R31));
     const Register crd = ConcreteRegister(rd);
     const Register crn = ConcreteRegister(rn);
     if (o.type() == Operand::Immediate) {
       ASSERT(rn != ZR);
       EmitAddSubImmOp(subtract ? SUBI : ADDI, crd, crn, o, os, set_flags);
     } else if (o.type() == Operand::Shifted) {
@@ skipping 480 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM64_H_