CpuProfiler: fix for CollectDeoptEvents test on arm64

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/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 846 matching lines @@
       __ Bind(&table_entry->label);
 
       Address entry = table_entry->address;
       DeoptComment(table_entry->deopt_info);
 
       // Second-level deopt table entries are contiguous and small, so instead
       // of loading the full, absolute address of each one, load the base
       // address and add an immediate offset.
       __ Mov(entry_offset, entry - base);
 
-      // The last entry can fall through into `call_deopt_entry`, avoiding a
-      // branch.
-      bool last_entry = (i + 1) == length;
-
       if (table_entry->needs_frame) {
         DCHECK(!info()->saves_caller_doubles());
-        if (!needs_frame.is_bound()) {
-          // This variant of deopt can only be used with stubs. Since we don't
-          // have a function pointer to install in the stack frame that we're
-          // building, install a special marker there instead.
-          DCHECK(info()->IsStub());
-
-          UseScratchRegisterScope temps(masm());
-          Register stub_marker = temps.AcquireX();
-          __ Bind(&needs_frame);
-          __ Mov(stub_marker, Smi::FromInt(StackFrame::STUB));
-          __ Push(lr, fp, cp, stub_marker);
-          __ Add(fp, __ StackPointer(), 2 * kPointerSize);
-          if (!last_entry) __ B(&call_deopt_entry);
-        } else {
-          // Reuse the existing needs_frame code.
-          __ B(&needs_frame);
-        }
+        // Save lr before Bl, fp will be adjusted in the needs_frame code.
+        __ Push(lr, fp, cp);

[jbramley, 2015/03/10 13:11:18]

We can save some space here by pushing (lr, fp) here, then (cp, stub_marker) at
needs_frame. ARM64 pushes registers in pairs, so pushing (a,b),(c,d) is more
space-efficient than pushing (a,b,c),(d).

The effect is probably small but I'll make a patch to address this, since there
is basically no cost.

(Sorry, I didn't see it at first.)

[loislo, 2015/03/10 14:42:18]

I'll do this in https://codereview.chromium.org/995813002/

+        // Reuse the existing needs_frame code.
+        __ Bl(&needs_frame);
       } else if (info()->saves_caller_doubles()) {
         DCHECK(info()->IsStub());
-        if (!restore_caller_doubles.is_bound()) {
-          __ Bind(&restore_caller_doubles);
-          RestoreCallerDoubles();
-          if (!last_entry) __ B(&call_deopt_entry);
-        } else {
-          // Reuse the existing restore_caller_doubles code.
-          __ B(&restore_caller_doubles);
-        }
+        // Reuse the existing restore_caller_doubles code.
+        __ Bl(&restore_caller_doubles);
       } else {
         // There is nothing special to do, so just continue to the second-level
         // table.
-        if (!last_entry) __ B(&call_deopt_entry);
+        __ Bl(&call_deopt_entry);
       }
 
+      bool last_entry = (i + 1) == length;
       masm()->CheckConstPool(false, last_entry);
     }
 
+    if (needs_frame.is_linked()) {
+      // This variant of deopt can only be used with stubs. Since we don't
+      // have a function pointer to install in the stack frame that we're
+      // building, install a special marker there instead.
+      DCHECK(info()->IsStub());
+
+      UseScratchRegisterScope temps(masm());
+      Register stub_marker = temps.AcquireX();
+      __ Bind(&needs_frame);
+      __ Mov(stub_marker, Smi::FromInt(StackFrame::STUB));
+      __ Push(stub_marker);
+      __ Add(fp, __ StackPointer(), 2 * kPointerSize);
+      if (restore_caller_doubles.is_linked()) {
+        __ B(&call_deopt_entry);
+      }
+    }
+
+    if (restore_caller_doubles.is_linked()) {
+      __ Bind(&restore_caller_doubles);
+      RestoreCallerDoubles();
+    }
+
     // 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);
+    __ 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 219 matching lines @@
 
 void LCodeGen::DeoptimizeIfMinusZero(DoubleRegister input, LInstruction* instr,
                                      Deoptimizer::DeoptReason deopt_reason) {
   __ TestForMinusZero(input);
   DeoptimizeIf(vs, instr, deopt_reason);
 }
 
 
 void LCodeGen::DeoptimizeIfNotHeapNumber(Register object, LInstruction* instr) {
   __ CompareObjectMap(object, Heap::kHeapNumberMapRootIndex);
-  DeoptimizeIf(ne, instr, Deoptimizer::kNotHeapNumber);
+  DeoptimizeIf(ne, instr, Deoptimizer::kNotAHeapNumber);
 }
 
 
 void LCodeGen::DeoptimizeIfBitSet(Register rt, int bit, LInstruction* instr,
                                   Deoptimizer::DeoptReason deopt_reason) {
   DeoptimizeBranch(instr, deopt_reason, reg_bit_set, rt, bit);
 }
 
 
 void LCodeGen::DeoptimizeIfBitClear(Register rt, int bit, LInstruction* instr,
@@ skipping 4941 matching lines @@
   Handle<ScopeInfo> scope_info = instr->scope_info();
   __ Push(scope_info);
   __ Push(ToRegister(instr->function()));
   CallRuntime(Runtime::kPushBlockContext, 2, instr);
   RecordSafepoint(Safepoint::kNoLazyDeopt);
 }
 
 
 
 } }  // namespace v8::internal