ARM64: Preserve x8 and x9 when necessary.

src/arm64/macro-assembler-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 1909 matching lines @@
 
   // Load the initial map from the global function. The registers function and
   // map can be the same, function is then overwritten.
   void LoadGlobalFunctionInitialMap(Register function,
                                     Register map,
                                     Register scratch);
 
   CPURegList* TmpList() { return &tmp_list_; }
   CPURegList* FPTmpList() { return &fptmp_list_; }
 
+  static CPURegList DefaultTmpList();
+  static CPURegList DefaultFPTmpList();
+
   // Like printf, but print at run-time from generated code.
   //
   // The caller must ensure that arguments for floating-point placeholders
   // (such as %e, %f or %g) are FPRegisters, and that arguments for integer
   // placeholders are Registers.
   //
   // A maximum of four arguments may be given to any single Printf call. The
   // arguments must be of the same type, but they do not need to have the same
   // size.
   //
   // The following registers cannot be printed:
   //    StackPointer(), csp.
   //
   // This function automatically preserves caller-saved registers so that
   // calling code can use Printf at any point without having to worry about
   // corruption. The preservation mechanism generates a lot of code. If this is
   // a problem, preserve the important registers manually and then call
   // PrintfNoPreserve. Callee-saved registers are not used by Printf, and are
   // implicitly preserved.
   //
-  // Unlike many MacroAssembler functions, x8 and x9 are guaranteed to be
-  // preserved, and can be printed. This allows Printf to be used during debug
-  // code.
-  //
   // This function assumes (and asserts) that the current stack pointer is
   // callee-saved, not caller-saved. This is most likely the case anyway, as a
   // caller-saved stack pointer doesn't make a lot of sense.
   void Printf(const char * format,
               const CPURegister& arg0 = NoCPUReg,
               const CPURegister& arg1 = NoCPUReg,
               const CPURegister& arg2 = NoCPUReg,
               const CPURegister& arg3 = NoCPUReg);
 
   // Like Printf, but don't preserve any caller-saved registers, not even 'lr'.
@@ skipping 345 matching lines @@
 #error "Unsupported option"
 #define CODE_COVERAGE_STRINGIFY(x) #x
 #define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x)
 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
 #define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 #endif  // V8_ARM64_MACRO_ASSEMBLER_ARM64_H_