Fixes a bug in CheckClassInstr on arm64.

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 161 matching lines @@
     } else {
       true_condition = NegateCondition(true_condition);
     }
   }
 
   __ cset(result, true_condition);
 
   if (is_power_of_two_kind) {
     const intptr_t shift =
         Utils::ShiftForPowerOfTwo(Utils::Maximum(true_value, false_value));
-    __ Lsl(result, result, shift + kSmiTagSize);
+    __ LslImmediate(result, result, shift + kSmiTagSize);
   } else {
     __ sub(result, result, Operand(1));
     const int64_t val =
         Smi::RawValue(true_value) - Smi::RawValue(false_value);
     __ AndImmediate(result, result, val, PP);
     if (false_value != 0) {
       __ AddImmediate(result, result, Smi::RawValue(false_value), PP);
     }
   }
 }
@@ skipping 648 matching lines @@
 }
 
 
 void StringFromCharCodeInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const Register char_code = locs()->in(0).reg();
   const Register result = locs()->out(0).reg();
   __ LoadImmediate(
       result, reinterpret_cast<uword>(Symbols::PredefinedAddress()), PP);
   __ AddImmediate(
       result, result, Symbols::kNullCharCodeSymbolOffset * kWordSize, PP);
-  __ Asr(TMP, char_code, kSmiTagShift);  // Untag to use scaled adress mode.
+  __ SmiUntag(TMP, char_code);  // Untag to use scaled adress mode.
   __ ldr(result, Address(result, TMP, UXTX, Address::Scaled));
 }
 
 
 LocationSummary* StringToCharCodeInstr::MakeLocationSummary(Isolate* isolate,
                                                             bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(isolate,
                                kNumInputs,
                                Location::RequiresRegister(),
@@ skipping 1678 matching lines @@
       : NULL;
   if (locs.in(1).IsConstant()) {
     const Object& constant = locs.in(1).constant();
     ASSERT(constant.IsSmi());
     // Immediate shift operation takes 6 bits for the count.
     const intptr_t kCountLimit = 0x3F;
     const intptr_t value = Smi::Cast(constant).Value();
     ASSERT((0 < value) && (value < kCountLimit));
     if (shift_left->can_overflow()) {
       // Check for overflow (preserve left).
-      __ Lsl(TMP, left, value);
+      __ LslImmediate(TMP, left, value);
       __ cmp(left, Operand(TMP, ASR, value));
       __ b(deopt, NE);  // Overflow.
     }
     // Shift for result now we know there is no overflow.
-    __ Lsl(result, left, value);
+    __ LslImmediate(result, left, value);
     if (FLAG_throw_on_javascript_int_overflow) {
       EmitJavascriptOverflowCheck(compiler, shift_left->range(), deopt, result);
     }
     return;
   }
 
   // Right (locs.in(1)) is not constant.
   const Register right = locs.in(1).reg();
   Range* right_range = shift_left->right()->definition()->range();
   if (shift_left->left()->BindsToConstant() && shift_left->can_overflow()) {
@@ skipping 160 matching lines @@
           __ b(deopt, NE);
         }
         break;
       }
       case Token::kTRUNCDIV: {
         const intptr_t value = Smi::Cast(constant).Value();
         ASSERT(Utils::IsPowerOfTwo(Utils::Abs(value)));
         const intptr_t shift_count =
             Utils::ShiftForPowerOfTwo(Utils::Abs(value)) + kSmiTagSize;
         ASSERT(kSmiTagSize == 1);
-        __ Asr(TMP, left, 63);
+        __ AsrImmediate(TMP, left, 63);
         ASSERT(shift_count > 1);  // 1, -1 case handled above.
         const Register temp = TMP2;
         __ add(temp, left, Operand(TMP, LSR, 64 - shift_count));
         ASSERT(shift_count > 0);
-        __ Asr(result, temp, shift_count);
+        __ AsrImmediate(result, temp, shift_count);
         if (value < 0) {
           __ sub(result, ZR, Operand(result));
         }
         __ SmiTag(result);
         break;
       }
       case Token::kBIT_AND:
         // No overflow check.
         __ AndImmediate(result, left, imm, PP);
         break;
       case Token::kBIT_OR:
         // No overflow check.
         __ OrImmediate(result, left, imm, PP);
         break;
       case Token::kBIT_XOR:
         // No overflow check.
         __ XorImmediate(result, left, imm, PP);
         break;
       case Token::kSHR: {
         // Asr operation masks the count to 6 bits.
         const intptr_t kCountLimit = 0x3F;
         intptr_t value = Smi::Cast(constant).Value();
-        __ Asr(result, left, Utils::Minimum(value + kSmiTagSize, kCountLimit));
+        __ AsrImmediate(
+            result, left, Utils::Minimum(value + kSmiTagSize, kCountLimit));
         __ SmiTag(result);
         break;
       }
       default:
         UNREACHABLE();
         break;
     }
     if (FLAG_throw_on_javascript_int_overflow) {
       EmitJavascriptOverflowCheck(compiler, range(), deopt, result);
     }
@@ skipping 217 matching lines @@
 
 void UnboxDoubleInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   CompileType* value_type = value()->Type();
   const intptr_t value_cid = value_type->ToCid();
   const Register value = locs()->in(0).reg();
   const VRegister result = locs()->out(0).fpu_reg();
 
   if (value_cid == kDoubleCid) {
     __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
   } else if (value_cid == kSmiCid) {
-    __ Asr(TMP, value, kSmiTagSize);  // Untag input before conversion.
+    __ SmiUntag(TMP, value);  // Untag input before conversion.
     __ scvtfd(result, TMP);
   } else {
     Label* deopt = compiler->AddDeoptStub(deopt_id_,
                                           ICData::kDeoptBinaryDoubleOp);
     if (value_type->is_nullable() &&
         (value_type->ToNullableCid() == kDoubleCid)) {
       __ CompareObject(value, Object::null_object(), PP);
       __ b(deopt, EQ);
       // It must be double now.
       __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
     } else {
       Label is_smi, done;
       __ tsti(value, kSmiTagMask);
       __ b(&is_smi, EQ);
       __ CompareClassId(value, kDoubleCid, PP);
       __ b(deopt, NE);
       __ LoadDFieldFromOffset(result, value, Double::value_offset(), PP);
       __ b(&done);
       __ Bind(&is_smi);
-      __ Asr(TMP, value, kSmiTagSize);  // Copy and untag.
+      __ SmiUntag(TMP, value);  // Copy and untag.
       __ scvtfd(result, TMP);
       __ Bind(&done);
     }
   }
 }
 
 
 LocationSummary* BoxFloat32x4Instr::MakeLocationSummary(Isolate* isolate,
                                                         bool opt) const {
   const intptr_t kNumInputs = 1;
@@ skipping 334 matching lines @@
 }
 
 
 void Simd32x4GetSignMaskInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const VRegister value = locs()->in(0).fpu_reg();
   const Register out = locs()->out(0).reg();
   const Register temp = locs()->temp(0).reg();
 
   // X lane.
   __ vmovrs(out, value, 0);
-  __ Lsr(out, out, 31);
+  __ LsrImmediate(out, out, 31);
   // Y lane.
   __ vmovrs(temp, value, 1);
-  __ Lsr(temp, temp, 31);
+  __ LsrImmediate(temp, temp, 31);
   __ orr(out, out, Operand(temp, LSL, 1));
   // Z lane.
   __ vmovrs(temp, value, 2);
-  __ Lsr(temp, temp, 31);
+  __ LsrImmediate(temp, temp, 31);
   __ orr(out, out, Operand(temp, LSL, 2));
   // W lane.
   __ vmovrs(temp, value, 3);
-  __ Lsr(temp, temp, 31);
+  __ LsrImmediate(temp, temp, 31);
   __ orr(out, out, Operand(temp, LSL, 3));
   // Tag.
   __ SmiTag(out);
 }
 
 
 LocationSummary* Float32x4ConstructorInstr::MakeLocationSummary(
     Isolate* isolate, bool opt) const {
   const intptr_t kNumInputs = 4;
   const intptr_t kNumTemps = 0;
@@ skipping 479 matching lines @@
 
 
 void Float64x2ZeroArgInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   const VRegister value = locs()->in(0).fpu_reg();
 
   if ((op_kind() == MethodRecognizer::kFloat64x2GetSignMask)) {
     const Register out = locs()->out(0).reg();
 
     // Bits of X lane.
     __ vmovrd(out, value, 0);
-    __ Lsr(out, out, 63);
+    __ LsrImmediate(out, out, 63);
     // Bits of Y lane.
     __ vmovrd(TMP, value, 1);
-    __ Lsr(TMP, TMP, 63);
+    __ LsrImmediate(TMP, TMP, 63);
     __ orr(out, out, Operand(TMP, LSL, 1));
     // Tag.
     __ SmiTag(out);
     return;
   }
   ASSERT(representation() == kUnboxedFloat64x2);
   const VRegister result = locs()->out(0).fpu_reg();
 
   switch (op_kind()) {
     case MethodRecognizer::kFloat64x2Negate:
@@ skipping 1018 matching lines @@
     __ AddImmediate(temp, temp, -cids_[0], PP);
     __ CompareImmediate(temp, cids_[cids_.length() - 1] - cids_[0], PP);
     __ b(deopt, HI);
 
     intptr_t mask = ComputeCidMask();
     if (!IsDenseMask(mask)) {
       // Only need mask if there are missing numbers in the range.
       ASSERT(cids_.length() > 2);
       Register mask_reg = locs()->temp(1).reg();
       __ LoadImmediate(mask_reg, 1, PP);
-      __ Lsl(mask_reg, mask_reg, temp);
+      __ lslv(mask_reg, mask_reg, temp);
       __ TestImmediate(mask_reg, mask, PP);
       __ b(deopt, EQ);
     }
 
   } else {
     const intptr_t num_checks = unary_checks().NumberOfChecks();
     for (intptr_t i = cix; i < num_checks; i++) {
       ASSERT(unary_checks().GetReceiverClassIdAt(i) != kSmiCid);
       __ CompareImmediate(temp, unary_checks().GetReceiverClassIdAt(i), PP);
       if (i == (num_checks - 1)) {
@@ skipping 248 matching lines @@
 }
 
 
 void BoxIntNInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Register value = locs()->in(0).reg();
   Register out = locs()->out(0).reg();
   ASSERT(value != out);
 
   ASSERT(kSmiTagSize == 1);
   // TODO(vegorov) implement and use UBFM/SBFM for this.
-  __ Lsl(out, value, 32);
+  __ LslImmediate(out, value, 32);
   if (from_representation() == kUnboxedInt32) {
-    __ Asr(out, out, 32 - kSmiTagSize);
+    __ AsrImmediate(out, out, 32 - kSmiTagSize);
   } else {
     ASSERT(from_representation() == kUnboxedUint32);
-    __ Lsr(out, out, 32 - kSmiTagSize);
+    __ LsrImmediate(out, out, 32 - kSmiTagSize);
   }
 }
 
 
 LocationSummary* UnboxedIntConverterInstr::MakeLocationSummary(Isolate* isolate,
                                                                bool opt) const {
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary = new(isolate) LocationSummary(
       isolate, kNumInputs, kNumTemps, LocationSummary::kNoCall);
@@ skipping 13 matching lines @@
 
 void UnboxedIntConverterInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (from() == kUnboxedInt32 && to() == kUnboxedUint32) {
     const Register value = locs()->in(0).reg();
     const Register out = locs()->out(0).reg();
     // Representations are bitwise equivalent but we want to normalize
     // upperbits for safety reasons.
     // TODO(vegorov) if we ensure that we never use kDoubleWord size
     // with it then we could avoid this.
     // TODO(vegorov) implement and use UBFM for zero extension.
-    __ Lsl(out, value, 32);
-    __ Lsr(out, out, 32);
+    __ LslImmediate(out, value, 32);
+    __ LsrImmediate(out, out, 32);
   } else if (from() == kUnboxedUint32 && to() == kUnboxedInt32) {
     // Representations are bitwise equivalent.
     // TODO(vegorov) if we ensure that we never use kDoubleWord size
     // with it then we could avoid this.
     // TODO(vegorov) implement and use SBFM for sign extension.
     const Register value = locs()->in(0).reg();
     const Register out = locs()->out(0).reg();
-    __ Lsl(out, value, 32);
-    __ Asr(out, out, 32);
+    __ LslImmediate(out, value, 32);
+    __ AsrImmediate(out, out, 32);
     if (CanDeoptimize()) {
       Label* deopt =
           compiler->AddDeoptStub(deopt_id(), ICData::kDeoptUnboxInteger);
       __ cmp(out, Operand(value, UXTW, 0));
       __ b(deopt, NE);
     }
   } else if (from() == kUnboxedMint) {
     UNREACHABLE();
   } else if (to() == kUnboxedMint) {
     ASSERT((from() == kUnboxedUint32) || (from() == kUnboxedInt32));
@@ skipping 218 matching lines @@
   compiler->GenerateCall(token_pos(), &label, stub_kind_, locs());
 #if defined(DEBUG)
   __ LoadImmediate(R4, kInvalidObjectPointer, kNoPP);
   __ LoadImmediate(R5, kInvalidObjectPointer, kNoPP);
 #endif
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64