ARM64: Give LR to the allocator.

src/arm64/lithium-codegen-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/arm64/lithium-codegen-arm64.h"
 #include "src/arm64/lithium-gap-resolver-arm64.h"
 #include "src/code-stubs.h"
 #include "src/stub-cache.h"
@@ skipping 369 matching lines @@
                         LInstruction* instr) {
   CallCodeGeneric(code, mode, instr, RECORD_SIMPLE_SAFEPOINT);
 }
 
 
 void LCodeGen::CallCodeGeneric(Handle<Code> code,
                                RelocInfo::Mode mode,
                                LInstruction* instr,
                                SafepointMode safepoint_mode) {
   ASSERT(instr != NULL);
+  ASSERT(instr->IsMarkedAsCall());
 
   Assembler::BlockPoolsScope scope(masm_);
   __ Call(code, mode);
   RecordSafepointWithLazyDeopt(instr, safepoint_mode);
 
   if ((code->kind() == Code::BINARY_OP_IC) ||
       (code->kind() == Code::COMPARE_IC)) {
     // Signal that we don't inline smi code before these stubs in the
     // optimizing code generator.
     InlineSmiCheckInfo::EmitNotInlined(masm());
@@ skipping 432 matching lines @@
 
 
 bool LCodeGen::GenerateDeoptJumpTable() {
   Label needs_frame, restore_caller_doubles, call_deopt_entry;
 
   if (deopt_jump_table_.length() > 0) {
     Comment(";;; -------------------- Jump table --------------------");
     Address base = deopt_jump_table_[0]->address;
 
     UseScratchRegisterScope temps(masm());
-    Register entry_offset = temps.AcquireX();
+    // This is reused as the caller address later, and the second-level deopt
+    // table expects this in ip1.
+    Register entry_offset = temps.Acquire(ip1);

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

Nit: maybe introduce a descriptive alias for ip1 to make places that set it and
use it easier to find?

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

Done.

 
     int length = deopt_jump_table_.length();
     for (int i = 0; i < length; i++) {
       __ Bind(&deopt_jump_table_[i]->label);
 
       Deoptimizer::BailoutType type = deopt_jump_table_[i]->bailout_type;
       Address entry = deopt_jump_table_[i]->address;
       int id = Deoptimizer::GetDeoptimizationId(isolate(), entry, type);
       if (id == Deoptimizer::kNotDeoptimizationEntry) {
         Comment(";;; jump table entry %d.", i);
@@ skipping 47 matching lines @@
 
       masm()->CheckConstPool(false, last_entry);
     }
 
     // Generate common code for calling the second-level deopt table.
     Register deopt_entry = temps.AcquireX();
     __ Bind(&call_deopt_entry);
     __ Mov(deopt_entry, Operand(reinterpret_cast<uint64_t>(base),
                                 RelocInfo::RUNTIME_ENTRY));
     __ Add(deopt_entry, deopt_entry, entry_offset);
-    __ Call(deopt_entry);
+
+    const Register& caller_address = entry_offset;
+    ASSERT(caller_address.Is(ip1));
+    __ adr(caller_address, 0);
+    __ Br(deopt_entry);
   }
 
   // Force constant pool emission at the end of the deopt jump table to make
   // sure that no constant pools are emitted after.
   masm()->CheckConstPool(true, false);
 
   // The deoptimization jump table is the last part of the instruction
   // sequence. Mark the generated code as done unless we bailed out.
   if (!is_aborted()) status_ = DONE;
   return !is_aborted();
@@ skipping 108 matching lines @@
     __ Push(x0, x1, x2);
     __ Mrs(x2, NZCV);
     __ Mov(x0, count);
     __ Ldr(w1, MemOperand(x0));
     __ Subs(x1, x1, 1);
     __ B(gt, &not_zero);
     __ Mov(w1, FLAG_deopt_every_n_times);
     __ Str(w1, MemOperand(x0));
     __ Pop(x2, x1, x0);
     ASSERT(frame_is_built_);
-    __ Call(entry, RelocInfo::RUNTIME_ENTRY);
+
+    {
+      UseScratchRegisterScope temps(masm());
+      // The second-level deopt table expects the caller address in ip1.
+      Register caller_address = temps.Acquire(ip1);
+      Register entry_address = temps.AcquireX();
+
+      __ Mov(entry_address, Operand(reinterpret_cast<uintptr_t>(entry),
+                                    RelocInfo::RUNTIME_ENTRY));
+      __ adr(caller_address, 0);
+      __ Br(entry_address);
+    }
+
     __ Unreachable();
 
     __ Bind(&not_zero);
     __ Str(w1, MemOperand(x0));
     __ Msr(NZCV, x2);
     __ Pop(x2, x1, x0);
   }
 
   if (info()->ShouldTrapOnDeopt()) {
     Label dont_trap;
     __ B(&dont_trap, InvertBranchType(branch_type), reg, bit);
     __ Debug("trap_on_deopt", __LINE__, BREAK);
     __ Bind(&dont_trap);
   }
 
   ASSERT(info()->IsStub() || frame_is_built_);
-  // Go through jump table if we need to build frame, or restore caller doubles.
   if (branch_type == always &&
       frame_is_built_ && !info()->saves_caller_doubles()) {
-    __ Call(entry, RelocInfo::RUNTIME_ENTRY);
+    // For unconditional deopts that don't require special handling (such as
+    // constructing a frame), branch directly to the second-level table.
+
+    UseScratchRegisterScope temps(masm());
+    // The second-level deopt table expects the caller address in ip1.
+    Register caller_address = temps.Acquire(ip1);
+    Register entry_address = temps.AcquireX();
+
+    __ Mov(entry_address, Operand(reinterpret_cast<uintptr_t>(entry),
+                                  RelocInfo::RUNTIME_ENTRY));
+    __ adr(caller_address, 0);
+    __ Br(entry_address);
   } else {
+    // For conditional deopts, try to generate as little fast-path code as
+    // possible. Defer all special handling to the first-level deopt table and
+    // emit a simple conditional branch here.
+
     // We often have several deopts to the same entry, reuse the last
     // jump entry if this is the case.
     if (deopt_jump_table_.is_empty() ||
         (deopt_jump_table_.last()->address != entry) ||
         (deopt_jump_table_.last()->bailout_type != bailout_type) ||
         (deopt_jump_table_.last()->needs_frame != !frame_is_built_)) {
       Deoptimizer::JumpTableEntry* table_entry =
         new(zone()) Deoptimizer::JumpTableEntry(entry,
                                                 bailout_type,
                                                 !frame_is_built_);
@@ skipping 4981 matching lines @@
   Handle<ScopeInfo> scope_info = instr->scope_info();
   __ Push(scope_info);
   __ Push(ToRegister(instr->function()));
   CallRuntime(Runtime::kHiddenPushBlockContext, 2, instr);
   RecordSafepoint(Safepoint::kNoLazyDeopt);
 }
 
 
 
 } }  // namespace v8::internal