ARM64: Preserve x8 and x9 when necessary.

src/arm64/code-stubs-arm64.h

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 192 matching lines @@
   // This is a helper class to manage the registers associated with the stub.
   // The 'object' and 'address' registers must be preserved.
   class RegisterAllocation {
    public:
     RegisterAllocation(Register object,
                        Register address,
                        Register scratch)
         : object_(object),
           address_(address),
           scratch0_(scratch),
-          saved_regs_(kCallerSaved)  {
+          saved_regs_(kCallerSaved),
+          saved_fp_regs_(kCallerSavedFP) {
       ASSERT(!AreAliased(scratch, object, address));
 
+      // The SaveCallerSaveRegisters method needs to save caller-saved
+      // registers, but we don't bother saving MacroAssembler scratch registers.
+      saved_regs_.Remove(MacroAssembler::DefaultTmpList());
+      saved_fp_regs_.Remove(MacroAssembler::DefaultFPTmpList());
+
       // We would like to require more scratch registers for this stub,
       // but the number of registers comes down to the ones used in
       // FullCodeGen::SetVar(), which is architecture independent.
       // We allocate 2 extra scratch registers that we'll save on the stack.
       CPURegList pool_available = GetValidRegistersForAllocation();
       CPURegList used_regs(object, address, scratch);
       pool_available.Remove(used_regs);
       scratch1_ = Register(pool_available.PopLowestIndex());
       scratch2_ = Register(pool_available.PopLowestIndex());
 
-      // SaveCallerRegisters method needs to save caller saved register, however
-      // we don't bother saving ip0 and ip1 because they are used as scratch
-      // registers by the MacroAssembler.
-      saved_regs_.Remove(ip0);
-      saved_regs_.Remove(ip1);
-
       // The scratch registers will be restored by other means so we don't need
       // to save them with the other caller saved registers.
       saved_regs_.Remove(scratch0_);
       saved_regs_.Remove(scratch1_);
       saved_regs_.Remove(scratch2_);
     }
 
     void Save(MacroAssembler* masm) {
       // We don't have to save scratch0_ because it was given to us as
       // a scratch register.
       masm->Push(scratch1_, scratch2_);
     }
 
     void Restore(MacroAssembler* masm) {
       masm->Pop(scratch2_, scratch1_);
     }
 
     // If we have to call into C then we need to save and restore all caller-
     // saved registers that were not already preserved.
     void SaveCallerSaveRegisters(MacroAssembler* masm, SaveFPRegsMode mode) {
       // TODO(all): This can be very expensive, and it is likely that not every
       // register will need to be preserved. Can we improve this?
       masm->PushCPURegList(saved_regs_);
       if (mode == kSaveFPRegs) {
-        masm->PushCPURegList(kCallerSavedFP);
+        masm->PushCPURegList(saved_fp_regs_);
       }
     }
 
     void RestoreCallerSaveRegisters(MacroAssembler*masm, SaveFPRegsMode mode) {
       // TODO(all): This can be very expensive, and it is likely that not every
       // register will need to be preserved. Can we improve this?
       if (mode == kSaveFPRegs) {
-        masm->PopCPURegList(kCallerSavedFP);
+        masm->PopCPURegList(saved_fp_regs_);
       }
       masm->PopCPURegList(saved_regs_);
     }
 
     Register object() { return object_; }
     Register address() { return address_; }
     Register scratch0() { return scratch0_; }
     Register scratch1() { return scratch1_; }
     Register scratch2() { return scratch2_; }
 
    private:
     Register object_;
     Register address_;
     Register scratch0_;
     Register scratch1_;
     Register scratch2_;
     CPURegList saved_regs_;
+    CPURegList saved_fp_regs_;
 
     // TODO(all): We should consider moving this somewhere else.
     static CPURegList GetValidRegistersForAllocation() {
       // The list of valid registers for allocation is defined as all the
       // registers without those with a special meaning.
       //
       // The default list excludes registers x26 to x31 because they are
       // reserved for the following purpose:
       //  - x26 root register
       //  - x27 context pointer register
       //  - x28 jssp
       //  - x29 frame pointer
       //  - x30 link register(lr)
       //  - x31 xzr/stack pointer
       CPURegList list(CPURegister::kRegister, kXRegSizeInBits, 0, 25);
 
       // We also remove MacroAssembler's scratch registers.
-      list.Remove(ip0);
-      list.Remove(ip1);
-      list.Remove(x8);
-      list.Remove(x9);
+      list.Remove(MacroAssembler::DefaultTmpList());
 
       return list;
     }
 
     friend class RecordWriteStub;
   };
 
   // A list of stub variants which are pregenerated.
   // The variants are stored in the same format as the minor key, so
   // MinorKeyFor() can be used to populate and check this list.
@@ skipping 178 matching lines @@
   TargetAddressStorageMode storage_mode() { return storage_mode_; }
 
  private:
   TargetAddressStorageMode storage_mode_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM64_CODE_STUBS_ARM64_H_