[arm64] Emit CBZ for deoptimisations.

src/compiler/arm64/instruction-selector-arm64.cc

 // Copyright 2014 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/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 2134 matching lines @@
     case kUnsignedLessThanOrEqual:  // generate CBZ
       return kEqual;
     case kUnsignedGreaterThan:  // generate CBNZ
       return kNotEqual;
     default:
       UNREACHABLE();
       return cond;
   }
 }
 
+void EmitBranchOrDeoptimize(InstructionSelector* selector,
+                            InstructionCode opcode, InstructionOperand value,
+                            FlagsContinuation* cont) {
+  Arm64OperandGenerator g(selector);
+  if (cont->IsBranch()) {
+    selector->Emit(cont->Encode(opcode), g.NoOutput(), value,
+                   g.Label(cont->true_block()), g.Label(cont->false_block()));
+  } else {
+    DCHECK(cont->IsDeoptimize());
+    selector->EmitDeoptimize(cont->Encode(opcode), g.NoOutput(), value,
+                             cont->reason(), cont->frame_state());
+  }
+}
+
 // Try to emit TBZ, TBNZ, CBZ or CBNZ for certain comparisons of {node}
 // against zero, depending on the condition.
 bool TryEmitCbzOrTbz(InstructionSelector* selector, Node* node, Node* user,
                      FlagsCondition cond, FlagsContinuation* cont) {
   Int32BinopMatcher m_user(user);
   USE(m_user);
   DCHECK(m_user.right().Is(0) || m_user.left().Is(0));
 
-  // Only handle branches.
-  if (!cont->IsBranch()) return false;
+  // Only handle branches and deoptimisations.
+  if (!cont->IsBranch() && !cont->IsDeoptimize()) return false;
 
   switch (cond) {
     case kSignedLessThan:
     case kSignedGreaterThanOrEqual: {
+      // We don't generate TBZ/TBNZ for deoptimisations, as they have a
+      // shorter range than conditional branches and generating them for
+      // deoptimisations results in more veneers.
+      if (cont->IsDeoptimize()) return false;
       Arm64OperandGenerator g(selector);
       cont->Overwrite(MapForTbz(cond));
       Int32Matcher m(node);
       if (m.IsFloat64ExtractHighWord32() && selector->CanCover(user, node)) {
         // SignedLessThan(Float64ExtractHighWord32(x), 0) and
         // SignedGreaterThanOrEqual(Float64ExtractHighWord32(x), 0) essentially
         // check the sign bit of a 64-bit floating point value.
         InstructionOperand temp = g.TempRegister();
         selector->Emit(kArm64U64MoveFloat64, temp,
                        g.UseRegister(node->InputAt(0)));
         selector->Emit(cont->Encode(kArm64TestAndBranch), g.NoOutput(), temp,
                        g.TempImmediate(63), g.Label(cont->true_block()),
                        g.Label(cont->false_block()));
         return true;
       }
       selector->Emit(cont->Encode(kArm64TestAndBranch32), g.NoOutput(),
                      g.UseRegister(node), g.TempImmediate(31),
                      g.Label(cont->true_block()), g.Label(cont->false_block()));
       return true;
     }
     case kEqual:
     case kNotEqual:
     case kUnsignedLessThanOrEqual:
     case kUnsignedGreaterThan: {
       Arm64OperandGenerator g(selector);
       cont->Overwrite(MapForCbz(cond));
-      selector->Emit(cont->Encode(kArm64CompareAndBranch32), g.NoOutput(),
-                     g.UseRegister(node), g.Label(cont->true_block()),
-                     g.Label(cont->false_block()));
+      EmitBranchOrDeoptimize(selector, kArm64CompareAndBranch32,
+                             g.UseRegister(node), cont);
       return true;
     }
     default:
       return false;
   }
 }
 
 void VisitWord32Compare(InstructionSelector* selector, Node* node,
                         FlagsContinuation* cont) {
   Int32BinopMatcher m(node);
@@ skipping 165 matching lines @@
             // Attempt to merge the Word64Equal(Word64And(x, y), 0) comparison
             // into a tbz/tbnz instruction.
             if (TryEmitTestAndBranch<Uint64BinopMatcher, kArm64TestAndBranch>(
                     selector, left, cont)) {
               return;
             }
             return VisitWordCompare(selector, left, kArm64Tst, cont, true,
                                     kLogical64Imm);
           }
           // Merge the Word64Equal(x, 0) comparison into a cbz instruction.
-          if (cont->IsBranch()) {
-            selector->Emit(cont->Encode(kArm64CompareAndBranch), g.NoOutput(),
-                           g.UseRegister(left), g.Label(cont->true_block()),
-                           g.Label(cont->false_block()));
+          if (cont->IsBranch() || cont->IsDeoptimize()) {
+            EmitBranchOrDeoptimize(selector,
+                                   cont->Encode(kArm64CompareAndBranch),
+                                   g.UseRegister(left), cont);
             return;
           }
         }
         return VisitWordCompare(selector, value, kArm64Cmp, cont, false,
                                 kArithmeticImm);
       }
       case IrOpcode::kInt64LessThan:
         cont->OverwriteAndNegateIfEqual(kSignedLessThan);
         return VisitWordCompare(selector, value, kArm64Cmp, cont, false,
                                 kArithmeticImm);
@@ skipping 491 matching lines @@
 // static
 MachineOperatorBuilder::AlignmentRequirements
 InstructionSelector::AlignmentRequirements() {
   return MachineOperatorBuilder::AlignmentRequirements::
       FullUnalignedAccessSupport();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8