A64: Use a scope utility to allocate scratch registers.

src/a64/macro-assembler-a64-inl.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 570 matching lines @@
 
 void MacroAssembler::Fcmp(const FPRegister& fn, const FPRegister& fm) {
   ASSERT(allow_macro_instructions_);
   fcmp(fn, fm);
 }
 
 
 void MacroAssembler::Fcmp(const FPRegister& fn, double value) {
   ASSERT(allow_macro_instructions_);
   if (value != 0.0) {
-    FPRegister tmp = AppropriateTempFor(fn);
+    UseScratchRegisterScope temps(this);
+    FPRegister tmp = temps.AcquireSameSizeAs(fn);
     Fmov(tmp, value);
     fcmp(fn, tmp);
   } else {
     fcmp(fn, value);
   }
 }
 
 
 void MacroAssembler::Fcsel(const FPRegister& fd,
                            const FPRegister& fn,
@@ skipping 133 matching lines @@
 
 
 void MacroAssembler::Fmov(FPRegister fd, double imm) {
   ASSERT(allow_macro_instructions_);
   if ((fd.Is64Bits() && IsImmFP64(imm)) ||
       (fd.Is32Bits() && IsImmFP32(imm)) ||
       ((imm == 0.0) && (copysign(1.0, imm) == 1.0))) {
     // These cases can be handled by the Assembler.
     fmov(fd, imm);
   } else {
+    UseScratchRegisterScope temps(this);
     // TODO(all): The Assembler would try to relocate the immediate with
     // Assembler::ldr(const FPRegister& ft, double imm) but it is not
     // implemented yet.
     if (fd.SizeInBits() == kDRegSize) {
-      Mov(Tmp0(), double_to_rawbits(imm));
-      Fmov(fd, Tmp0());
+      Register tmp = temps.AcquireX();
+      Mov(tmp, double_to_rawbits(imm));
+      Fmov(fd, tmp);
     } else {
       ASSERT(fd.SizeInBits() == kSRegSize);
-      Mov(WTmp0(), float_to_rawbits(static_cast<float>(imm)));
-      Fmov(fd, WTmp0());
+      Register tmp = temps.AcquireW();
+      Mov(tmp, float_to_rawbits(static_cast<float>(imm)));
+      Fmov(fd, tmp);
     }
   }
 }
 
 
 void MacroAssembler::Fmov(Register rd, FPRegister fn) {
   ASSERT(allow_macro_instructions_);
   ASSERT(!rd.IsZero());
   fmov(rd, fn);
 }
@@ skipping 579 matching lines @@
 void MacroAssembler::JumpIfNotSmi(Register value, Label* not_smi_label) {
   JumpIfSmi(value, NULL, not_smi_label);
 }
 
 
 void MacroAssembler::JumpIfBothSmi(Register value1,
                                    Register value2,
                                    Label* both_smi_label,
                                    Label* not_smi_label) {
   STATIC_ASSERT((kSmiTagSize == 1) && (kSmiTag == 0));
+  UseScratchRegisterScope temps(this);
+  Register tmp = temps.AcquireX();
   // Check if both tag bits are clear.
-  Orr(Tmp0(), value1, value2);
-  JumpIfSmi(Tmp0(), both_smi_label, not_smi_label);
+  Orr(tmp, value1, value2);
+  JumpIfSmi(tmp, both_smi_label, not_smi_label);
 }
 
 
 void MacroAssembler::JumpIfEitherSmi(Register value1,
                                      Register value2,
                                      Label* either_smi_label,
                                      Label* not_smi_label) {
   STATIC_ASSERT((kSmiTagSize == 1) && (kSmiTag == 0));
+  UseScratchRegisterScope temps(this);
+  Register tmp = temps.AcquireX();
   // Check if either tag bit is clear.
-  And(Tmp0(), value1, value2);
-  JumpIfSmi(Tmp0(), either_smi_label, not_smi_label);
+  And(tmp, value1, value2);
+  JumpIfSmi(tmp, either_smi_label, not_smi_label);
 }
 
 
 void MacroAssembler::JumpIfEitherNotSmi(Register value1,
                                         Register value2,
                                         Label* not_smi_label) {
   JumpIfBothSmi(value1, value2, NULL, not_smi_label);
 }
 
 
@@ skipping 52 matching lines @@
   } else if (not_string == NULL) {
     TestAndBranchIfAllClear(type.W(), kIsNotStringMask, string);
   } else {
     TestAndBranchIfAnySet(type.W(), kIsNotStringMask, not_string);
     B(string);
   }
 }
 
 
 void MacroAssembler::Push(Handle<Object> handle) {
-  Mov(Tmp0(), Operand(handle));
-  Push(Tmp0());
+  UseScratchRegisterScope temps(this);
+  Register tmp = temps.AcquireX();
+  Mov(tmp, Operand(handle));
+  Push(tmp);
 }
 
 
 void MacroAssembler::Claim(uint64_t count, uint64_t unit_size) {
   uint64_t size = count * unit_size;
 
   if (size == 0) {
     return;
   }
 
@@ skipping 187 matching lines @@
   // characters are reserved for controlling features of the instrumentation.
   ASSERT(isprint(marker_name[0]) && isprint(marker_name[1]));
 
   InstructionAccurateScope scope(this, 1);
   movn(xzr, (marker_name[1] << 8) | marker_name[0]);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_A64_MACRO_ASSEMBLER_A64_INL_H_