ARM64: Give LR to the allocator.

src/arm64/deoptimizer-arm64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen.h"
 #include "src/safepoint-table.h"
 
 
 namespace v8 {
 namespace internal {
 
 
 int Deoptimizer::patch_size() {
   // Size of the code used to patch lazy bailout points.
   // Patching is done by Deoptimizer::DeoptimizeFunction.
-  return 4 * kInstructionSize;
+  return 5 * kInstructionSize;
 }
 
 
 
 void Deoptimizer::PatchCodeForDeoptimization(Isolate* isolate, Code* code) {
   // Invalidate the relocation information, as it will become invalid by the
   // code patching below, and is not needed any more.
   code->InvalidateRelocation();
 
   // TODO(jkummerow): if (FLAG_zap_code_space), make the code object's
@@ skipping 10 matching lines @@
 #endif
   // For each LLazyBailout instruction insert a call to the corresponding
   // deoptimization entry.
   for (int i = 0; i < deopt_data->DeoptCount(); i++) {
     if (deopt_data->Pc(i)->value() == -1) continue;
 
     Address call_address = code_start_address + deopt_data->Pc(i)->value();
     Address deopt_entry = GetDeoptimizationEntry(isolate, i, LAZY);
 
     PatchingAssembler patcher(call_address, patch_size() / kInstructionSize);
+    patcher.adr(ip1, 0);
     patcher.ldr_pcrel(ip0, (2 * kInstructionSize) >> kLoadLiteralScaleLog2);
     patcher.blr(ip0);

[ulan, 2014/06/23 11:17:11]

Did you mean br(ip0) here?

[jbramley, 2014/06/23 17:22:05]

Yes! Thank you.

     patcher.dc64(reinterpret_cast<intptr_t>(deopt_entry));
 
     ASSERT((prev_call_address == NULL) ||
            (call_address >= prev_call_address + patch_size()));
     ASSERT(call_address + patch_size() <= code->instruction_end());
 #ifdef DEBUG
     prev_call_address = call_address;
 #endif
   }
 }
@@ skipping 80 matching lines @@
     offset0 = (copy_to_input.PopLowestIndex().code() * reg_size) + dst_offset;
     __ Str(scratch1, MemOperand(frame, offset0));
   }
 }
 
 #undef __
 
 #define __ masm()->
 
 void Deoptimizer::EntryGenerator::Generate() {
+  UseScratchRegisterScope temps(masm());
+
+  // The deopt entry jump must put the caller address in ip1. This can be done
+  // either in the level-one deopt table (GenerateDeoptJumpTable), or inline in
+  // the code (DeoptimizeBranch).
+  Register caller_address = temps.Acquire(ip1);
+
   GeneratePrologue();
 
   // TODO(all): This code needs to be revisited. We probably only need to save
   // caller-saved registers here. Callee-saved registers can be stored directly
   // in the input frame.
 
   // Save all allocatable floating point registers.
   CPURegList saved_fp_registers(CPURegister::kFPRegister, kDRegSizeInBits,
                                 FPRegister::kAllocatableFPRegisters);
   __ PushCPURegList(saved_fp_registers);
 
-  // We save all the registers expcept jssp, sp and lr.
-  CPURegList saved_registers(CPURegister::kRegister, kXRegSizeInBits, 0, 27);
-  saved_registers.Combine(fp);
+  // We save all allocatable registers plus fp.
+  CPURegList saved_registers(CPURegister::kRegister, kXRegSizeInBits,
+                             Register::kAllocatableRegisters | fp.Bit());
   __ PushCPURegList(saved_registers);
 
   const int kSavedRegistersAreaSize =
       (saved_registers.Count() * kXRegSize) +
       (saved_fp_registers.Count() * kDRegSize);
 
   // Floating point registers are saved on the stack above core registers.
   const int kFPRegistersOffset = saved_registers.Count() * kXRegSize;
 
   // Get the bailout id from the stack.
   Register bailout_id = x2;
   __ Peek(bailout_id, kSavedRegistersAreaSize);
 
   Register code_object = x3;
   Register fp_to_sp = x4;
   // Get the address of the location in the code object. This is the return
   // address for lazy deoptimization.
-  __ Mov(code_object, lr);
+  __ Mov(code_object, caller_address);
   // Compute the fp-to-sp delta, and correct one word for bailout id.
   __ Add(fp_to_sp, masm()->StackPointer(),
          kSavedRegistersAreaSize + (1 * kPointerSize));
   __ Sub(fp_to_sp, fp, fp_to_sp);
 
   // Allocate a new deoptimizer object.
   __ Ldr(x0, MemOperand(fp, JavaScriptFrameConstants::kFunctionOffset));
   __ Mov(x1, type());
   // Following arguments are already loaded:
   //  - x2: bailout id
@@ skipping 101 matching lines @@
   // TODO(all): ARM copies a lot (if not all) of the last output frame onto the
   // stack, then pops it all into registers. Here, we try to load it directly
   // into the relevant registers. Is this correct? If so, we should improve the
   // ARM code.
 
   // TODO(all): This code needs to be revisited, We probably don't need to
   // restore all the registers as fullcodegen does not keep live values in
   // registers (note that at least fp must be restored though).
 
   // Restore registers from the last output frame.
-  // Note that lr is not in the list of saved_registers and will be restored
-  // later. We can use it to hold the address of last output frame while
-  // reloading the other registers.
-  ASSERT(!saved_registers.IncludesAliasOf(lr));
-  Register last_output_frame = lr;
+  Register last_output_frame = temps.AcquireX();
+  ASSERT(!saved_registers.IncludesAliasOf(last_output_frame));
   __ Mov(last_output_frame, current_frame);
 
   // We don't need to restore x7 as it will be clobbered later to hold the
   // continuation address.
   Register continuation = x7;
   saved_registers.Remove(continuation);
 
   while (!saved_registers.IsEmpty()) {
     // TODO(all): Look for opportunities to optimize this by using ldp.
     CPURegister current_reg = saved_registers.PopLowestIndex();
@@ skipping 55 matching lines @@
 
 void FrameDescription::SetCallerConstantPool(unsigned offset, intptr_t value) {
   // No out-of-line constant pool support.
   UNREACHABLE();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal