A64: Use a scope utility to allocate scratch registers.

src/a64/code-stubs-a64.cc

 // 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 1204 matching lines @@
       // where base is -INFINITY or -0.
 
       // Add +0 to base. This has no effect other than turning -0 into +0.
       __ Fmov(zero_double, 0.0);
       __ Fadd(base_double, base_double, zero_double);
       // The operation -0+0 results in +0 in all cases except where the
       // FPCR rounding mode is 'round towards minus infinity' (RM). The
       // A64 simulator does not currently simulate FPCR (where the rounding
       // mode is set), so test the operation with some debug code.
       if (masm->emit_debug_code()) {
-        Register temp = masm->Tmp1();
+        UseScratchRegisterScope temps(masm);
+        Register temp = temps.AcquireX();
         //  d5  zero_double   The value +0.0 as a double.
         __ Fneg(scratch0_double, zero_double);
         // Verify that we correctly generated +0.0 and -0.0.
         //  bits(+0.0) = 0x0000000000000000
         //  bits(-0.0) = 0x8000000000000000
         __ Fmov(temp, zero_double);
         __ CheckRegisterIsClear(temp, kCouldNotGenerateZero);
         __ Fmov(temp, scratch0_double);
         __ Eor(temp, temp, kDSignMask);
         __ CheckRegisterIsClear(temp, kCouldNotGenerateNegativeZero);
@@ skipping 257 matching lines @@
 
   // Store the return address on the stack, in the space previously allocated
   // by EnterExitFrame. The return address is queried by
   // ExitFrame::GetStateForFramePointer.
   Label return_location;
   __ Adr(x12, &return_location);
   __ Poke(x12, 0);
   if (__ emit_debug_code()) {
     // Verify that the slot below fp[kSPOffset]-8 points to the return location
     // (currently in x12).
-    Register temp = masm->Tmp1();
+    UseScratchRegisterScope temps(masm);
+    Register temp = temps.AcquireX();
     __ Ldr(temp, MemOperand(fp, ExitFrameConstants::kSPOffset));
     __ Ldr(temp, MemOperand(temp, -static_cast<int64_t>(kXRegSizeInBytes)));
     __ Cmp(temp, x12);
     __ Check(eq, kReturnAddressNotFoundInFrame);
   }
 
   // Call the builtin.
   __ Blr(target);
   __ Bind(&return_location);
   const Register& result = x0;
@@ skipping 3199 matching lines @@
                         value,
                         1 << MemoryChunk::SCAN_ON_SCAVENGE,
                         &dont_need_remembered_set);
 
     // First notify the incremental marker if necessary, then update the
     // remembered set.
     CheckNeedsToInformIncrementalMarker(
         masm, kUpdateRememberedSetOnNoNeedToInformIncrementalMarker, mode);
     InformIncrementalMarker(masm);
     regs_.Restore(masm);  // Restore the extra scratch registers we used.
+
     __ RememberedSetHelper(object_,
                            address_,
-                           value_,
+                           value_,            // scratch1
                            save_fp_regs_mode_,
                            MacroAssembler::kReturnAtEnd);
 
     __ Bind(&dont_need_remembered_set);
   }
 
   CheckNeedsToInformIncrementalMarker(
       masm, kReturnOnNoNeedToInformIncrementalMarker, mode);
   InformIncrementalMarker(masm);
   regs_.Restore(masm);  // Restore the extra scratch registers we used.
@@ skipping 40 matching lines @@
          MemOperand(mem_chunk, MemoryChunk::kWriteBarrierCounterOffset));
   __ B(mi, &need_incremental);
 
   // If the object is not black we don't have to inform the incremental marker.
   __ JumpIfBlack(regs_.object(), regs_.scratch0(), regs_.scratch1(), &on_black);
 
   regs_.Restore(masm);  // Restore the extra scratch registers we used.
   if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) {
     __ RememberedSetHelper(object_,
                            address_,
-                           value_,
+                           value_,            // scratch1
                            save_fp_regs_mode_,
                            MacroAssembler::kReturnAtEnd);
   } else {
     __ Ret();
   }
 
   __ Bind(&on_black);
   // Get the value from the slot.
   Register value = regs_.scratch0();
   __ Ldr(value, MemOperand(regs_.address()));
@@ skipping 22 matching lines @@
                     regs_.object(),    // Scratch.
                     regs_.address(),   // Scratch.
                     regs_.scratch2(),  // Scratch.
                     &need_incremental_pop_scratch);
   __ Pop(regs_.object(), regs_.address());
 
   regs_.Restore(masm);  // Restore the extra scratch registers we used.
   if (on_no_need == kUpdateRememberedSetOnNoNeedToInformIncrementalMarker) {
     __ RememberedSetHelper(object_,
                            address_,
-                           value_,
+                           value_,            // scratch1
                            save_fp_regs_mode_,
                            MacroAssembler::kReturnAtEnd);
   } else {
     __ Ret();
   }
 
   __ Bind(&need_incremental_pop_scratch);
   __ Pop(regs_.object(), regs_.address());
 
   __ Bind(&need_incremental);
@@ skipping 12 matching lines @@
   // See RecordWriteStub::Patch for details.
   {
     InstructionAccurateScope scope(masm, 2);
     __ adr(xzr, &skip_to_incremental_noncompacting);
     __ adr(xzr, &skip_to_incremental_compacting);
   }
 
   if (remembered_set_action_ == EMIT_REMEMBERED_SET) {
     __ RememberedSetHelper(object_,
                            address_,
-                           value_,
+                           value_,            // scratch1
                            save_fp_regs_mode_,
                            MacroAssembler::kReturnAtEnd);
   }
   __ Ret();
 
   __ Bind(&skip_to_incremental_noncompacting);
   GenerateIncremental(masm, INCREMENTAL);
 
   __ Bind(&skip_to_incremental_compacting);
   GenerateIncremental(masm, INCREMENTAL_COMPACTION);
@@ skipping 210 matching lines @@
       __ Add(scratch2, scratch2, Operand(
           NameDictionary::GetProbeOffset(i) << Name::kHashShift));
     }
     __ And(scratch2, scratch1, Operand(scratch2, LSR, Name::kHashShift));
 
     // Scale the index by multiplying by the element size.
     ASSERT(NameDictionary::kEntrySize == 3);
     __ Add(scratch2, scratch2, Operand(scratch2, LSL, 1));
 
     // Check if the key is identical to the name.
+    UseScratchRegisterScope temps(masm);
+    Register scratch3 = temps.AcquireX();
     __ Add(scratch2, elements, Operand(scratch2, LSL, kPointerSizeLog2));
-    // TODO(jbramley): We need another scratch here, but some callers can't
-    // provide a scratch3 so we have to use Tmp1(). We should find a clean way
-    // to make it unavailable to the MacroAssembler for a short time.
-    __ Ldr(__ Tmp1(), FieldMemOperand(scratch2, kElementsStartOffset));
-    __ Cmp(name, __ Tmp1());
+    __ Ldr(scratch3, FieldMemOperand(scratch2, kElementsStartOffset));
+    __ Cmp(name, scratch3);
     __ B(eq, done);
   }
 
   // The inlined probes didn't find the entry.
   // Call the complete stub to scan the whole dictionary.
 
   CPURegList spill_list(CPURegister::kRegister, kXRegSize, 0, 6);
   spill_list.Combine(lr);
   spill_list.Remove(scratch1);
   spill_list.Remove(scratch2);
@@ skipping 693 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64