ARM64: Minor improvement in LCodeGen::DoCheckInstanceType.

src/arm64/lithium-codegen-arm64.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 1060 matching lines @@
 }
 
 
 void LCodeGen::DeoptimizeIfNotZero(Register rt, LEnvironment* environment) {
   DeoptimizeBranch(environment, reg_not_zero, rt);
 }
 
 
 void LCodeGen::DeoptimizeIfNegative(Register rt, LEnvironment* environment) {
   int sign_bit = rt.Is64Bits() ? kXSignBit : kWSignBit;
-  DeoptimizeBranch(environment, reg_bit_set, rt, sign_bit);
+  DeoptimizeIfBitSet(rt, sign_bit, environment);
 }
 
 
 void LCodeGen::DeoptimizeIfSmi(Register rt,
                                LEnvironment* environment) {
-  DeoptimizeBranch(environment, reg_bit_clear, rt, MaskToBit(kSmiTagMask));
+  DeoptimizeIfBitClear(rt, MaskToBit(kSmiTagMask), environment);
 }
 
 
 void LCodeGen::DeoptimizeIfNotSmi(Register rt, LEnvironment* environment) {
-  DeoptimizeBranch(environment, reg_bit_set, rt, MaskToBit(kSmiTagMask));
+  DeoptimizeIfBitSet(rt, MaskToBit(kSmiTagMask), environment);
 }
 
 
 void LCodeGen::DeoptimizeIfRoot(Register rt,
                                 Heap::RootListIndex index,
                                 LEnvironment* environment) {
   __ CompareRoot(rt, index);
   DeoptimizeIf(eq, environment);
 }
 
 
 void LCodeGen::DeoptimizeIfNotRoot(Register rt,
                                    Heap::RootListIndex index,
                                    LEnvironment* environment) {
   __ CompareRoot(rt, index);
   DeoptimizeIf(ne, environment);
 }
 
 
 void LCodeGen::DeoptimizeIfMinusZero(DoubleRegister input,
                                      LEnvironment* environment) {
   __ TestForMinusZero(input);
   DeoptimizeIf(vs, environment);
 }
 
 
+void LCodeGen::DeoptimizeIfBitSet(Register rt,
+                                  int bit,
+                                  LEnvironment* environment) {
+  DeoptimizeBranch(environment, reg_bit_set, rt, bit);
+}
+
+
+void LCodeGen::DeoptimizeIfBitClear(Register rt,
+                                    int bit,
+                                    LEnvironment* environment) {
+  DeoptimizeBranch(environment, reg_bit_clear, rt, bit);
+}
+
+
 void LCodeGen::EnsureSpaceForLazyDeopt(int space_needed) {
   if (!info()->IsStub()) {
     // Ensure that we have enough space after the previous lazy-bailout
     // instruction for patching the code here.
     intptr_t current_pc = masm()->pc_offset();
 
     if (current_pc < (last_lazy_deopt_pc_ + space_needed)) {
       ptrdiff_t padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
       ASSERT((padding_size % kInstructionSize) == 0);
       InstructionAccurateScope instruction_accurate(
@@ skipping 1048 matching lines @@
       __ Ccmp(scratch, last, CFlag, hs);
       DeoptimizeIf(hi, instr->environment());
     }
   } else {
     uint8_t mask;
     uint8_t tag;
     instr->hydrogen()->GetCheckMaskAndTag(&mask, &tag);
 
     if (IsPowerOf2(mask)) {
       ASSERT((tag == 0) || (tag == mask));
-      // TODO(all): We might be able to use tbz/tbnz if we can guarantee that
-      // the deopt handler is reachable by a tbz instruction.
-      __ Tst(scratch, mask);
-      DeoptimizeIf(tag == 0 ? ne : eq, instr->environment());
+      if (tag == 0) {
+        DeoptimizeIfBitSet(scratch, MaskToBit(mask), instr->environment());
+      } else {
+        DeoptimizeIfBitClear(scratch, MaskToBit(mask), instr->environment());
+      }
     } else {
       if (tag == 0) {
         __ Tst(scratch, mask);
       } else {
         __ And(scratch, scratch, mask);
         __ Cmp(scratch, tag);
       }
       DeoptimizeIf(ne, instr->environment());
     }
   }
@@ skipping 3655 matching lines @@
   __ Bind(&out_of_object);
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal