Lines Matching refs:VIXL_CHECK
61 VIXL_CHECK(result == leading_sign_bits);
62 VIXL_CHECK(fallback_result == leading_sign_bits);
101 VIXL_CHECK(CountLeadingSignBits(static_cast<int8_t>(42)) == 1); // 0b00101010
102 VIXL_CHECK(CountLeadingSignBits(static_cast<int16_t>(42)) == 9);
103 VIXL_CHECK(CountLeadingSignBits(static_cast<int32_t>(42)) == 25);
104 VIXL_CHECK(CountLeadingSignBits(static_cast<int64_t>(42)) == 57);
113 VIXL_CHECK(!(f1 == f2));
114 VIXL_CHECK(f1 != f2);
115 VIXL_CHECK(!(f3 == f4));
116 VIXL_CHECK(f3 != f4);
117 VIXL_CHECK(::vixl::internal::SimFloat16(kFP16PositiveZero) ==
119 VIXL_CHECK(!(::vixl::internal::SimFloat16(kFP16PositiveZero) !=
124 VIXL_CHECK(RawbitsToInt64(0x0) == 0x0);
125 VIXL_CHECK(RawbitsToInt64(0x123) == 0x123);
126 VIXL_CHECK(RawbitsToInt64(INT64_MAX) == INT64_MAX);
127 VIXL_CHECK(RawbitsToInt64(UINT64_C(0xffffffffffffffff)) == -1);
128 VIXL_CHECK(RawbitsToInt64(UINT64_C(0x8000000000000000)) == INT64_MIN);
129 VIXL_CHECK(RawbitsToInt64(UINT64_C(0x8000000000000001)) == -INT64_MAX);
131 VIXL_CHECK(RawbitsToInt32(0x0) == 0x0);
132 VIXL_CHECK(RawbitsToInt32(0x123) == 0x123);
133 VIXL_CHECK(RawbitsToInt32(INT32_MAX) == INT32_MAX);
134 VIXL_CHECK(RawbitsToInt32(UINT32_C(0xffffffff)) == -1);
135 VIXL_CHECK(RawbitsToInt32(UINT32_C(0x80000000)) == INT32_MIN);
136 VIXL_CHECK(RawbitsToInt32(UINT32_C(0x80000001)) == -INT32_MAX);
141 VIXL_CHECK(vixl::aarch64::kFP64PositiveInfinity ==
143 VIXL_CHECK(vixl::aarch64::kFP64NegativeInfinity ==
145 VIXL_CHECK(vixl::aarch64::kFP32PositiveInfinity ==
147 VIXL_CHECK(vixl::aarch64::kFP32NegativeInfinity ==
149 VIXL_CHECK(Float16ToRawbits(vixl::aarch64::kFP16PositiveInfinity) ==
151 VIXL_CHECK(Float16ToRawbits(vixl::aarch64::kFP16NegativeInfinity) ==
153 VIXL_CHECK(DoubleToRawbits(vixl::aarch64::kFP64DefaultNaN) ==
155 VIXL_CHECK(FloatToRawbits(vixl::aarch64::kFP32DefaultNaN) ==
157 VIXL_CHECK(IsNaN(vixl::aarch64::kFP16DefaultNaN) ==
159 VIXL_CHECK(vixl::aarch64::kDoubleExponentBits == vixl::kDoubleExponentBits);
160 VIXL_CHECK(vixl::aarch64::kDoubleMantissaBits == vixl::kDoubleMantissaBits);
161 VIXL_CHECK(vixl::aarch64::kFloatExponentBits == vixl::kFloatExponentBits);
162 VIXL_CHECK(vixl::aarch64::kFloatMantissaBits == vixl::kFloatMantissaBits);
163 VIXL_CHECK(vixl::aarch64::kFloat16ExponentBits == vixl::kFloat16ExponentBits);
164 VIXL_CHECK(vixl::aarch64::kFloat16MantissaBits == vixl::kFloat16MantissaBits);
169 VIXL_CHECK(x0.GetBit() == (UINT64_C(1) << 0));
170 VIXL_CHECK(x1.GetBit() == (UINT64_C(1) << 1));
171 VIXL_CHECK(x10.GetBit() == (UINT64_C(1) << 10));
174 VIXL_CHECK(lr.GetBit() == (UINT64_C(1) << kLinkRegCode));
177 VIXL_CHECK(xzr.GetBit() == (UINT64_C(1) << kZeroRegCode));
180 VIXL_CHECK(sp.GetBit() == (UINT64_C(1) << kSPRegInternalCode));
181 VIXL_CHECK(sp.GetBit() != xzr.GetBit());
184 VIXL_CHECK(x0.GetBit() == w0.GetBit());
185 VIXL_CHECK(x1.GetBit() == w1.GetBit());
186 VIXL_CHECK(x10.GetBit() == w10.GetBit());
187 VIXL_CHECK(xzr.GetBit() == wzr.GetBit());
188 VIXL_CHECK(sp.GetBit() == wsp.GetBit());
193 VIXL_CHECK(NoReg.Is(NoVReg));
194 VIXL_CHECK(NoVReg.Is(NoReg));
196 VIXL_CHECK(NoVReg.Is(NoReg));
197 VIXL_CHECK(NoReg.Is(NoVReg));
199 VIXL_CHECK(NoReg.Is(NoCPUReg));
200 VIXL_CHECK(NoCPUReg.Is(NoReg));
202 VIXL_CHECK(NoVReg.Is(NoCPUReg));
203 VIXL_CHECK(NoCPUReg.Is(NoVReg));
205 VIXL_CHECK(NoVReg.Is(NoCPUReg));
206 VIXL_CHECK(NoCPUReg.Is(NoVReg));
208 VIXL_CHECK(NoReg.IsNone());
209 VIXL_CHECK(NoVReg.IsNone());
210 VIXL_CHECK(NoCPUReg.IsNone());
216 VIXL_CHECK(WRegister(0).Is(w0));
217 VIXL_CHECK(XRegister(1).Is(x1));
219 VIXL_CHECK(BRegister(2).Is(b2));
220 VIXL_CHECK(HRegister(3).Is(h3));
221 VIXL_CHECK(SRegister(4).Is(s4));
222 VIXL_CHECK(DRegister(5).Is(d5));
223 VIXL_CHECK(QRegister(6).Is(q6));
225 VIXL_CHECK(ZRegister(7).Is(z7));
226 VIXL_CHECK(PRegister(8).Is(p8));
232 VIXL_CHECK(Register(0, kWRegSize).Is(w0));
233 VIXL_CHECK(Register(1, kXRegSize).Is(x1));
239 VIXL_CHECK(VRegister(0).Is(v0));
240 VIXL_CHECK(VRegister(1).Is(v1));
241 VIXL_CHECK(VRegister(2).Is(v2));
242 VIXL_CHECK(VRegister(3).Is(v3));
243 VIXL_CHECK(VRegister(4).Is(v4));
246 VIXL_CHECK(VRegister(0, kBRegSize).Is(b0));
247 VIXL_CHECK(VRegister(1, kHRegSize).Is(h1));
248 VIXL_CHECK(VRegister(2, kSRegSize).Is(s2));
249 VIXL_CHECK(VRegister(3, kDRegSize).Is(d3));
250 VIXL_CHECK(VRegister(4, kQRegSize).Is(q4));
253 VIXL_CHECK(VRegister(0, kBRegSize, 1).Is(b0));
254 VIXL_CHECK(VRegister(1, kHRegSize, 1).Is(h1));
255 VIXL_CHECK(VRegister(2, kSRegSize, 1).Is(s2));
256 VIXL_CHECK(VRegister(3, kDRegSize, 1).Is(d3));
257 VIXL_CHECK(VRegister(4, kQRegSize, 1).Is(q4));
259 VIXL_CHECK(VRegister(0, kSRegSize, 2).Is(v0.V2H()));
261 VIXL_CHECK(VRegister(1, kDRegSize, 1).Is(v1.V1D()));
262 VIXL_CHECK(VRegister(2, kDRegSize, 2).Is(v2.V2S()));
263 VIXL_CHECK(VRegister(3, kDRegSize, 4).Is(v3.V4H()));
264 VIXL_CHECK(VRegister(4, kDRegSize, 8).Is(v4.V8B()));
266 VIXL_CHECK(VRegister(5, kQRegSize, 2).Is(v5.V2D()));
267 VIXL_CHECK(VRegister(6, kQRegSize, 4).Is(v6.V4S()));
268 VIXL_CHECK(VRegister(7, kQRegSize, 8).Is(v7.V8H()));
269 VIXL_CHECK(VRegister(8, kQRegSize, 16).Is(v8.V16B()));
272 VIXL_CHECK(VRegister(0, kFormatB).Is(b0));
273 VIXL_CHECK(VRegister(1, kFormatH).Is(h1));
274 VIXL_CHECK(VRegister(2, kFormatS).Is(s2));
275 VIXL_CHECK(VRegister(3, kFormatD).Is(d3));
276 VIXL_CHECK(VRegister(4, kFormat8B).Is(v4.V8B()));
277 VIXL_CHECK(VRegister(5, kFormat16B).Is(v5.V16B()));
278 VIXL_CHECK(VRegister(6, kFormat2H).Is(v6.V2H()));
279 VIXL_CHECK(VRegister(7, kFormat4H).Is(v7.V4H()));
280 VIXL_CHECK(VRegister(8, kFormat8H).Is(v8.V8H()));
281 VIXL_CHECK(VRegister(9, kFormat2S).Is(v9.V2S()));
282 VIXL_CHECK(VRegister(10, kFormat4S).Is(v10.V4S()));
283 VIXL_CHECK(VRegister(11, kFormat1D).Is(v11.V1D()));
284 VIXL_CHECK(VRegister(12, kFormat2D).Is(v12.V2D()));
290 VIXL_CHECK(ZRegister(0, kBRegSize).Is(z0.VnB()));
291 VIXL_CHECK(ZRegister(1, kHRegSize).Is(z1.VnH()));
292 VIXL_CHECK(ZRegister(2, kSRegSize).Is(z2.VnS()));
293 VIXL_CHECK(ZRegister(3, kDRegSize).Is(z3.VnD()));
296 VIXL_CHECK(ZRegister(0, kFormatVnB).Is(z0.VnB()));
297 VIXL_CHECK(ZRegister(1, kFormatVnH).Is(z1.VnH()));
298 VIXL_CHECK(ZRegister(2, kFormatVnS).Is(z2.VnS()));
299 VIXL_CHECK(ZRegister(3, kFormatVnD).Is(z3.VnD()));
305 VIXL_CHECK(PRegisterWithLaneSize(0, kBRegSize).Is(p0.VnB()));
306 VIXL_CHECK(PRegisterWithLaneSize(1, kHRegSize).Is(p1.VnH()));
307 VIXL_CHECK(PRegisterWithLaneSize(2, kSRegSize).Is(p2.VnS()));
308 VIXL_CHECK(PRegisterWithLaneSize(3, kDRegSize).Is(p3.VnD()));
311 VIXL_CHECK(PRegisterWithLaneSize(0, kFormatVnB).Is(p0.VnB()));
312 VIXL_CHECK(PRegisterWithLaneSize(1, kFormatVnH).Is(p1.VnH()));
313 VIXL_CHECK(PRegisterWithLaneSize(2, kFormatVnS).Is(p2.VnS()));
314 VIXL_CHECK(PRegisterWithLaneSize(3, kFormatVnD).Is(p3.VnD()));
316 VIXL_CHECK(PRegisterZ(0).Is(p0.Zeroing()));
317 VIXL_CHECK(PRegisterM(1).Is(p1.Merging()));
323 VIXL_CHECK(CPURegister(0, kWRegSize, CPURegister::kRegister).Is(w0));
324 VIXL_CHECK(CPURegister(1, kXRegSize, CPURegister::kRegister).Is(x1));
326 VIXL_CHECK(CPURegister(2, kBRegSize, CPURegister::kVRegister).Is(b2));
327 VIXL_CHECK(CPURegister(3, kHRegSize, CPURegister::kVRegister).Is(h3));
328 VIXL_CHECK(CPURegister(4, kSRegSize, CPURegister::kVRegister).Is(s4));
329 VIXL_CHECK(CPURegister(5, kDRegSize, CPURegister::kVRegister).Is(d5));
330 VIXL_CHECK(CPURegister(6, kQRegSize, CPURegister::kVRegister).Is(q6));
331 VIXL_CHECK(CPURegister(7, kQRegSize, CPURegister::kVRegister).Is(v7));
333 VIXL_CHECK(CPURegister(0, CPURegister::kUnknownSize, CPURegister::kVRegister)
335 VIXL_CHECK(CPURegister(1, CPURegister::kUnknownSize, CPURegister::kPRegister)
366 VIXL_CHECK(out.Is(reg));
382 VIXL_CHECK(!NoReg.IsValid());
383 VIXL_CHECK(!NoVReg.IsValid());
384 VIXL_CHECK(!NoCPUReg.IsValid());
386 VIXL_CHECK(x0.IsValid());
387 VIXL_CHECK(w0.IsValid());
388 VIXL_CHECK(x30.IsValid());
389 VIXL_CHECK(w30.IsValid());
390 VIXL_CHECK(xzr.IsValid());
391 VIXL_CHECK(wzr.IsValid());
393 VIXL_CHECK(sp.IsValid());
394 VIXL_CHECK(wsp.IsValid());
396 VIXL_CHECK(d0.IsValid());
397 VIXL_CHECK(s0.IsValid());
398 VIXL_CHECK(d31.IsValid());
399 VIXL_CHECK(s31.IsValid());
401 VIXL_CHECK(x0.IsValidRegister());
402 VIXL_CHECK(w0.IsValidRegister());
403 VIXL_CHECK(xzr.IsValidRegister());
404 VIXL_CHECK(wzr.IsValidRegister());
405 VIXL_CHECK(sp.IsValidRegister());
406 VIXL_CHECK(wsp.IsValidRegister());
407 VIXL_CHECK(!x0.IsValidVRegister());
408 VIXL_CHECK(!w0.IsValidVRegister());
409 VIXL_CHECK(!xzr.IsValidVRegister());
410 VIXL_CHECK(!wzr.IsValidVRegister());
411 VIXL_CHECK(!sp.IsValidVRegister());
412 VIXL_CHECK(!wsp.IsValidVRegister());
413 VIXL_CHECK(!x0.IsValidFPRegister());
414 VIXL_CHECK(!w0.IsValidFPRegister());
415 VIXL_CHECK(!xzr.IsValidFPRegister());
416 VIXL_CHECK(!wzr.IsValidFPRegister());
417 VIXL_CHECK(!sp.IsValidFPRegister());
418 VIXL_CHECK(!wsp.IsValidFPRegister());
420 VIXL_CHECK(q0.IsValidVRegister());
421 VIXL_CHECK(!q0.IsValidFPRegister());
422 VIXL_CHECK(!q0.IsValidRegister());
424 VIXL_CHECK(d0.IsValidVRegister());
425 VIXL_CHECK(d0.IsValidFPRegister());
426 VIXL_CHECK(!d0.IsValidRegister());
428 VIXL_CHECK(s0.IsValidVRegister());
429 VIXL_CHECK(s0.IsValidFPRegister());
430 VIXL_CHECK(!s0.IsValidRegister());
432 VIXL_CHECK(h0.IsValidVRegister());
433 VIXL_CHECK(h0.IsValidFPRegister());
434 VIXL_CHECK(!h0.IsValidRegister());
436 VIXL_CHECK(b0.IsValidVRegister());
437 VIXL_CHECK(!b0.IsValidFPRegister());
438 VIXL_CHECK(!b0.IsValidRegister());
441 VIXL_CHECK(q0.V2D().IsValidVRegister());
442 VIXL_CHECK(!q0.V2D().IsValidFPRegister());
443 VIXL_CHECK(d0.V2S().IsValidVRegister());
444 VIXL_CHECK(!d0.V2S().IsValidFPRegister());
445 VIXL_CHECK(s0.V2H().IsValidVRegister());
446 VIXL_CHECK(!s0.V2H().IsValidFPRegister());
453 VIXL_CHECK(!static_cast<CPURegister>(NoReg).IsValid());
454 VIXL_CHECK(!static_cast<CPURegister>(NoVReg).IsValid());
455 VIXL_CHECK(!static_cast<CPURegister>(NoCPUReg).IsValid());
457 VIXL_CHECK(static_cast<CPURegister>(x0).IsValid());
458 VIXL_CHECK(static_cast<CPURegister>(w0).IsValid());
459 VIXL_CHECK(static_cast<CPURegister>(x30).IsValid());
460 VIXL_CHECK(static_cast<CPURegister>(w30).IsValid());
461 VIXL_CHECK(static_cast<CPURegister>(xzr).IsValid());
462 VIXL_CHECK(static_cast<CPURegister>(wzr).IsValid());
464 VIXL_CHECK(static_cast<CPURegister>(sp).IsValid());
465 VIXL_CHECK(static_cast<CPURegister>(wsp).IsValid());
467 VIXL_CHECK(static_cast<CPURegister>(d0).IsValid());
468 VIXL_CHECK(static_cast<CPURegister>(s0).IsValid());
469 VIXL_CHECK(static_cast<CPURegister>(d31).IsValid());
470 VIXL_CHECK(static_cast<CPURegister>(s31).IsValid());
472 VIXL_CHECK(static_cast<CPURegister>(x0).IsValidRegister());
473 VIXL_CHECK(static_cast<CPURegister>(w0).IsValidRegister());
474 VIXL_CHECK(static_cast<CPURegister>(xzr).IsValidRegister());
475 VIXL_CHECK(static_cast<CPURegister>(wzr).IsValidRegister());
476 VIXL_CHECK(static_cast<CPURegister>(sp).IsValidRegister());
477 VIXL_CHECK(static_cast<CPURegister>(wsp).IsValidRegister());
478 VIXL_CHECK(!static_cast<CPURegister>(x0).IsValidVRegister());
479 VIXL_CHECK(!static_cast<CPURegister>(w0).IsValidVRegister());
480 VIXL_CHECK(!static_cast<CPURegister>(xzr).IsValidVRegister());
481 VIXL_CHECK(!static_cast<CPURegister>(wzr).IsValidVRegister());
482 VIXL_CHECK(!static_cast<CPURegister>(sp).IsValidVRegister());
483 VIXL_CHECK(!static_cast<CPURegister>(wsp).IsValidVRegister());
484 VIXL_CHECK(!static_cast<CPURegister>(x0).IsValidFPRegister());
485 VIXL_CHECK(!static_cast<CPURegister>(w0).IsValidFPRegister());
486 VIXL_CHECK(!static_cast<CPURegister>(xzr).IsValidFPRegister());
487 VIXL_CHECK(!static_cast<CPURegister>(wzr).IsValidFPRegister());
488 VIXL_CHECK(!static_cast<CPURegister>(sp).IsValidFPRegister());
489 VIXL_CHECK(!static_cast<CPURegister>(wsp).IsValidFPRegister());
491 VIXL_CHECK(static_cast<CPURegister>(q0).IsValidVRegister());
492 VIXL_CHECK(!static_cast<CPURegister>(q0).IsValidFPRegister());
493 VIXL_CHECK(!static_cast<CPURegister>(q0).IsValidRegister());
495 VIXL_CHECK(static_cast<CPURegister>(d0).IsValidVRegister());
496 VIXL_CHECK(static_cast<CPURegister>(d0).IsValidFPRegister());
497 VIXL_CHECK(!static_cast<CPURegister>(d0).IsValidRegister());
499 VIXL_CHECK(static_cast<CPURegister>(s0).IsValidVRegister());
500 VIXL_CHECK(static_cast<CPURegister>(s0).IsValidFPRegister());
501 VIXL_CHECK(!static_cast<CPURegister>(s0).IsValidRegister());
503 VIXL_CHECK(static_cast<CPURegister>(h0).IsValidVRegister());
504 VIXL_CHECK(static_cast<CPURegister>(h0).IsValidFPRegister());
505 VIXL_CHECK(!static_cast<CPURegister>(h0).IsValidRegister());
507 VIXL_CHECK(static_cast<CPURegister>(b0).IsValidVRegister());
508 VIXL_CHECK(!static_cast<CPURegister>(b0).IsValidFPRegister());
509 VIXL_CHECK(!static_cast<CPURegister>(b0).IsValidRegister());
514 VIXL_CHECK(AreConsecutive(b0, NoVReg));
515 VIXL_CHECK(AreConsecutive(b1, b2));
516 VIXL_CHECK(AreConsecutive(b3, b4, b5));
517 VIXL_CHECK(AreConsecutive(b6, b7, b8, b9));
518 VIXL_CHECK(AreConsecutive(h10, NoVReg));
519 VIXL_CHECK(AreConsecutive(h11, h12));
520 VIXL_CHECK(AreConsecutive(h13, h14, h15));
521 VIXL_CHECK(AreConsecutive(h16, h17, h18, h19));
522 VIXL_CHECK(AreConsecutive(s20, NoVReg));
523 VIXL_CHECK(AreConsecutive(s21, s22));
524 VIXL_CHECK(AreConsecutive(s23, s24, s25));
525 VIXL_CHECK(AreConsecutive(s26, s27, s28, s29));
526 VIXL_CHECK(AreConsecutive(d30, NoVReg));
527 VIXL_CHECK(AreConsecutive(d31, d0));
528 VIXL_CHECK(AreConsecutive(d1, d2, d3));
529 VIXL_CHECK(AreConsecutive(d4, d5, d6, d7));
530 VIXL_CHECK(AreConsecutive(q8, NoVReg));
531 VIXL_CHECK(AreConsecutive(q9, q10));
532 VIXL_CHECK(AreConsecutive(q11, q12, q13));
533 VIXL_CHECK(AreConsecutive(q14, q15, q16, q17));
534 VIXL_CHECK(AreConsecutive(v18, NoVReg));
535 VIXL_CHECK(AreConsecutive(v19, v20));
536 VIXL_CHECK(AreConsecutive(v21, v22, v23));
537 VIXL_CHECK(AreConsecutive(v24, v25, v26, v27));
538 VIXL_CHECK(AreConsecutive(b29, h30));
539 VIXL_CHECK(AreConsecutive(s31, d0, q1));
540 VIXL_CHECK(AreConsecutive(v2, b3, h4, s5));
542 VIXL_CHECK(!AreConsecutive(b0, b2));
543 VIXL_CHECK(!AreConsecutive(h1, h0));
544 VIXL_CHECK(!AreConsecutive(s31, s1));
545 VIXL_CHECK(!AreConsecutive(d12, d12));
546 VIXL_CHECK(!AreConsecutive(q31, q1));
548 VIXL_CHECK(!AreConsecutive(b0, b1, b3));
549 VIXL_CHECK(!AreConsecutive(h4, h5, h6, h6));
550 VIXL_CHECK(!AreConsecutive(d11, d13, NoVReg, d14));
551 VIXL_CHECK(!AreConsecutive(d15, d16, d18, NoVReg));
552 VIXL_CHECK(!AreConsecutive(b26, b28, NoVReg, b29));
553 VIXL_CHECK(!AreConsecutive(s28, s30, NoVReg, NoVReg));
555 VIXL_CHECK(AreConsecutive(q19, NoVReg, NoVReg, q22));
556 VIXL_CHECK(AreConsecutive(v23, NoVReg, v25, NoVReg));
557 VIXL_CHECK(AreConsecutive(b26, b27, NoVReg, NoVReg));
558 VIXL_CHECK(AreConsecutive(h28, NoVReg, NoVReg, NoVReg));
559 VIXL_CHECK(AreConsecutive(s30, s31, NoVReg, s2));
560 VIXL_CHECK(AreConsecutive(d3, NoVReg, d6, d7));
576 VIXL_CHECK(kNumberOfPRegisters == 16);
577 VIXL_CHECK(p0.GetCode() == 0);
578 VIXL_CHECK(p15.GetCode() == 15);
579 VIXL_CHECK(p14.VnB().GetLaneSizeInBits() == kBRegSize);
580 VIXL_CHECK(p14.VnH().GetLaneSizeInBits() == kHRegSize);
581 VIXL_CHECK(p14.VnS().GetLaneSizeInBits() == kSRegSize);
582 VIXL_CHECK(p14.VnD().GetLaneSizeInBits() == kDRegSize);
583 VIXL_CHECK(p14.VnB().GetLaneSizeInBytes() == kBRegSizeInBytes);
584 VIXL_CHECK(p14.VnH().GetLaneSizeInBytes() == kHRegSizeInBytes);
585 VIXL_CHECK(p14.VnS().GetLaneSizeInBytes() == kSRegSizeInBytes);
586 VIXL_CHECK(p14.VnD().GetLaneSizeInBytes() == kDRegSizeInBytes);
587 VIXL_CHECK(Helper::GetQualification(p1) == kNone);
588 VIXL_CHECK(Helper::GetQualification(p2.Zeroing()) == kZeroing);
589 VIXL_CHECK(Helper::GetQualification(p3.Merging()) == kMerging);
590 VIXL_CHECK(Helper::GetQualification(p4.VnB()) == kWithLaneSize);
591 VIXL_CHECK(Helper::GetQualification(p5.VnH()) == kWithLaneSize);
592 VIXL_CHECK(Helper::GetQualification(p6.VnS()) == kWithLaneSize);
593 VIXL_CHECK(Helper::GetQualification(p7.VnD()) == kWithLaneSize);
598 VIXL_CHECK(z0.GetCode() == 0);
599 VIXL_CHECK(z31.GetCode() == 31);
601 VIXL_CHECK(z0.Is(z0));
602 VIXL_CHECK(!z0.Is(z1));
603 VIXL_CHECK(!z0.Is(v0));
604 VIXL_CHECK(!z0.Is(b0));
605 VIXL_CHECK(!z0.Is(q0));
607 VIXL_CHECK(AreAliased(z5, z5));
608 VIXL_CHECK(AreAliased(z5, b5));
609 VIXL_CHECK(AreAliased(b5, z5));
610 VIXL_CHECK(AreAliased(z5, z5.B()));
611 VIXL_CHECK(AreAliased(z5, z5.VnB()));
613 VIXL_CHECK(!AreAliased(z6, z7));
614 VIXL_CHECK(!AreAliased(b6, z7));
615 VIXL_CHECK(!AreAliased(x7, z7));
646 VIXL_CHECK(!z6.VnB().Is(b6));
647 VIXL_CHECK(!z7.VnH().Is(h7));
648 VIXL_CHECK(!z8.VnS().Is(s8));
649 VIXL_CHECK(!z9.VnD().Is(d9));
651 VIXL_CHECK(!z6.VnB().Is(v6.B()));
652 VIXL_CHECK(!z7.VnH().Is(v7.H()));
653 VIXL_CHECK(!z8.VnS().Is(v8.S()));
654 VIXL_CHECK(!z9.VnD().Is(v9.D()));
656 VIXL_CHECK(!z6.VnB().Is(z6.B()));
657 VIXL_CHECK(!z7.VnH().Is(z7.H()));
658 VIXL_CHECK(!z8.VnS().Is(z8.S()));
659 VIXL_CHECK(!z9.VnD().Is(z9.D()));
670 VIXL_CHECK(Helper::GetVariant(z10.VnB()) == kSVE);
671 VIXL_CHECK(Helper::GetVariant(z11.VnH()) == kSVE);
672 VIXL_CHECK(Helper::GetVariant(z12.VnS()) == kSVE);
673 VIXL_CHECK(Helper::GetVariant(z13.VnD()) == kSVE);
675 VIXL_CHECK(Helper::GetVariant(v10.B()) == kNEON);
676 VIXL_CHECK(Helper::GetVariant(v11.H()) == kNEON);
677 VIXL_CHECK(Helper::GetVariant(v12.S()) == kNEON);
678 VIXL_CHECK(Helper::GetVariant(v13.D()) == kNEON);
680 VIXL_CHECK(Helper::GetVariant(v10.V16B()) == kNEON);
681 VIXL_CHECK(Helper::GetVariant(v11.V8H()) == kNEON);
682 VIXL_CHECK(Helper::GetVariant(v12.V4S()) == kNEON);
683 VIXL_CHECK(Helper::GetVariant(v13.V2D()) == kNEON);
685 VIXL_CHECK(Helper::GetVariant(b10) == kNEON);
686 VIXL_CHECK(Helper::GetVariant(h11) == kNEON);
687 VIXL_CHECK(Helper::GetVariant(s12) == kNEON);
688 VIXL_CHECK(Helper::GetVariant(d13) == kNEON);
706 VIXL_CHECK(!invalid_1.IsValid());
707 VIXL_CHECK(!invalid_2.IsValid());
709 VIXL_CHECK(invalid_1.Equals(invalid_1));
710 VIXL_CHECK(invalid_2.Equals(invalid_2));
711 VIXL_CHECK(reg.Equals(reg));
712 VIXL_CHECK(mem.Equals(mem));
714 VIXL_CHECK(invalid_1.Equals(invalid_2));
715 VIXL_CHECK(invalid_2.Equals(invalid_1));
717 VIXL_CHECK(!invalid_1.Equals(reg));
718 VIXL_CHECK(!invalid_1.Equals(mem));
719 VIXL_CHECK(!reg.Equals(invalid_1));
720 VIXL_CHECK(!reg.Equals(invalid_2));
721 VIXL_CHECK(!reg.Equals(mem));
722 VIXL_CHECK(!mem.Equals(invalid_1));
723 VIXL_CHECK(!mem.Equals(reg));
728 VIXL_CHECK(IntegerOperand(0).IsZero());
729 VIXL_CHECK(!IntegerOperand(1).IsZero());
730 VIXL_CHECK(!IntegerOperand(-1).IsZero());
732 VIXL_CHECK(!IntegerOperand(-0x81).IsIntN(8));
733 VIXL_CHECK(IntegerOperand(-0x80).IsIntN(8));
734 VIXL_CHECK(IntegerOperand(-1).IsIntN(8));
735 VIXL_CHECK(IntegerOperand(0).IsIntN(8));
736 VIXL_CHECK(IntegerOperand(1).IsIntN(8));
737 VIXL_CHECK(IntegerOperand(0x7f).IsIntN(8));
738 VIXL_CHECK(!IntegerOperand(0x80).IsIntN(8));
740 VIXL_CHECK(!IntegerOperand(-1).IsUintN(8));
741 VIXL_CHECK(IntegerOperand(0).IsUintN(8));
742 VIXL_CHECK(IntegerOperand(1).IsUintN(8));
743 VIXL_CHECK(IntegerOperand(0xff).IsUintN(8));
744 VIXL_CHECK(!IntegerOperand(0x100).IsUintN(8));
746 VIXL_CHECK(IntegerOperand(INT64_MIN).IsIntN(64));
747 VIXL_CHECK(IntegerOperand(0).IsIntN(64));
748 VIXL_CHECK(IntegerOperand(INT64_MAX).IsIntN(64));
749 VIXL_CHECK(!IntegerOperand(0x8000000000000000).IsIntN(64));
751 VIXL_CHECK(!IntegerOperand(-1).IsUintN(64));
752 VIXL_CHECK(IntegerOperand(0).IsUintN(64));
753 VIXL_CHECK(IntegerOperand(UINT64_MAX).IsUintN(64));
755 VIXL_CHECK(!IntegerOperand(-0x801).FitsInBits(12));
756 VIXL_CHECK(IntegerOperand(-0x800).FitsInBits(12));
757 VIXL_CHECK(IntegerOperand(0).FitsInBits(12));
758 VIXL_CHECK(IntegerOperand(0x7ff).FitsInBits(12));
759 VIXL_CHECK(IntegerOperand(0x800).FitsInBits(12));
760 VIXL_CHECK(IntegerOperand(0xfff).FitsInBits(12));
761 VIXL_CHECK(!IntegerOperand(0x1000).FitsInBits(12));
763 VIXL_CHECK(!IntegerOperand(-0x8001).FitsInLane(z0.VnH()));
764 VIXL_CHECK(IntegerOperand(-0x8000).FitsInLane(z0.VnH()));
765 VIXL_CHECK(IntegerOperand(0).FitsInLane(z0.VnH()));
766 VIXL_CHECK(IntegerOperand(0x7fff).FitsInLane(z0.VnH()));
767 VIXL_CHECK(IntegerOperand(0x8000).FitsInLane(z0.VnH()));
768 VIXL_CHECK(IntegerOperand(0xffff).FitsInLane(z0.VnH()));
769 VIXL_CHECK(!IntegerOperand(0x10000).FitsInLane(z0.VnH()));
774 VIXL_CHECK(IntegerOperand(1).AsUintN(8) == 1);
775 VIXL_CHECK(IntegerOperand(1).AsUintN(16) == 1);
776 VIXL_CHECK(IntegerOperand(1).AsUintN(32) == 1);
777 VIXL_CHECK(IntegerOperand(1).AsUintN(64) == 1);
778 VIXL_CHECK(IntegerOperand(-1).AsUintN(8) == 0xff);
779 VIXL_CHECK(IntegerOperand(-1).AsUintN(16) == 0xffff);
780 VIXL_CHECK(IntegerOperand(-1).AsUintN(32) == 0xffffffff);
781 VIXL_CHECK(IntegerOperand(-1).AsUintN(64) == 0xffffffffffffffff);
782 VIXL_CHECK(IntegerOperand(0xf0).AsUintN(8) == 0xf0);
783 VIXL_CHECK(IntegerOperand(0xf420).AsUintN(16) == 0xf420);
784 VIXL_CHECK(IntegerOperand(0xf4242420).AsUintN(32) == 0xf4242420);
785 VIXL_CHECK(IntegerOperand(0xf424242424242420).AsUintN(64) ==
789 VIXL_CHECK(IntegerOperand(INT8_MIN).AsUintN(8) == 0x80);
790 VIXL_CHECK(IntegerOperand(INT8_MAX).AsUintN(8) == 0x7f);
791 VIXL_CHECK(IntegerOperand(UINT8_MAX).AsUintN(8) == 0xff);
793 VIXL_CHECK(IntegerOperand(INT16_MIN).AsUintN(16) == 0x8000);
794 VIXL_CHECK(IntegerOperand(INT16_MAX).AsUintN(16) == 0x7fff);
795 VIXL_CHECK(IntegerOperand(UINT16_MAX).AsUintN(16) == 0xffff);
797 VIXL_CHECK(IntegerOperand(INT32_MIN).AsUintN(32) == 0x80000000);
798 VIXL_CHECK(IntegerOperand(INT32_MAX).AsUintN(32) == 0x7fffffff);
799 VIXL_CHECK(IntegerOperand(UINT32_MAX).AsUintN(32) == 0xffffffff);
801 VIXL_CHECK(IntegerOperand(INT64_MIN).AsUintN(64) == 0x8000000000000000);
802 VIXL_CHECK(IntegerOperand(INT64_MAX).AsUintN(64) == 0x7fffffffffffffff);
803 VIXL_CHECK(IntegerOperand(UINT64_MAX).AsUintN(64) == 0xffffffffffffffff);
808 VIXL_CHECK(IntegerOperand(1).AsIntN(8) == 1);
809 VIXL_CHECK(IntegerOperand(1).AsIntN(16) == 1);
810 VIXL_CHECK(IntegerOperand(1).AsIntN(32) == 1);
811 VIXL_CHECK(IntegerOperand(1).AsIntN(64) == 1);
812 VIXL_CHECK(IntegerOperand(-1).AsIntN(8) == -1);
813 VIXL_CHECK(IntegerOperand(-1).AsIntN(16) == -1);
814 VIXL_CHECK(IntegerOperand(-1).AsIntN(32) == -1);
815 VIXL_CHECK(IntegerOperand(-1).AsIntN(64) == -1);
816 VIXL_CHECK(IntegerOperand(0x70).AsIntN(8) == 0x70);
817 VIXL_CHECK(IntegerOperand(0x7420).AsIntN(16) == 0x7420);
818 VIXL_CHECK(IntegerOperand(0x74242420).AsIntN(32) == 0x74242420);
819 VIXL_CHECK(IntegerOperand(0x7424242424242420).AsIntN(64) ==
823 VIXL_CHECK(IntegerOperand(UINT8_MAX).AsIntN(8) == -1);
824 VIXL_CHECK(IntegerOperand(UINT16_MAX).AsIntN(16) == -1);
825 VIXL_CHECK(IntegerOperand(UINT32_MAX).AsIntN(32) == -1);
826 VIXL_CHECK(IntegerOperand(UINT64_MAX).AsIntN(64) == -1);
828 VIXL_CHECK(IntegerOperand(INT8_MAX).AsIntN(8) == INT8_MAX);
829 VIXL_CHECK(IntegerOperand(INT16_MAX).AsIntN(16) == INT16_MAX);
830 VIXL_CHECK(IntegerOperand(INT32_MAX).AsIntN(32) == INT32_MAX);
831 VIXL_CHECK(IntegerOperand(INT64_MAX).AsIntN(64) == INT64_MAX);
833 VIXL_CHECK(IntegerOperand(0x80).AsIntN(8) == INT8_MIN);
834 VIXL_CHECK(IntegerOperand(0x8000).AsIntN(16) == INT16_MIN);
835 VIXL_CHECK(IntegerOperand(0x80000000).AsIntN(32) == INT32_MIN);
836 VIXL_CHECK(IntegerOperand(0x8000000000000000).AsIntN(64) == INT64_MIN);
846 VIXL_CHECK(TestImpl<kShift>(value, zd, expected_imm));
852 VIXL_CHECK(!TestImpl<kShift>(value, zd, 0));
864 VIXL_CHECK(imm == expected_imm);
865 VIXL_CHECK(shift == kShift);
868 VIXL_CHECK(imm == 0xdeadbeef42);
869 VIXL_CHECK(shift == 0xbeef43);
878 VIXL_CHECK(unshifted_success == success);
880 VIXL_CHECK(unshifted_imm == expected_imm);
882 VIXL_CHECK(unshifted_imm == 0xdeadbeef99);
955 VIXL_CHECK(r_x0.Is(x_x0));
956 VIXL_CHECK(x_x0.Is(r_x0));
957 VIXL_CHECK(r_w0.Is(w_w0));
958 VIXL_CHECK(w_w0.Is(r_w0));
965 VIXL_CHECK(r_x1.Is(x_x1));
966 VIXL_CHECK(x_x1.Is(r_x1));
967 VIXL_CHECK(r_w1.Is(w_w1));
968 VIXL_CHECK(w_w1.Is(r_w1));
975 VIXL_CHECK(cpu_x2.Is(x_x2));
976 VIXL_CHECK(x_x2.Is(cpu_x2));
977 VIXL_CHECK(cpu_w2.Is(w_w2));
978 VIXL_CHECK(w_w2.Is(cpu_w2));
983 VIXL_CHECK(Operand(x0).IsPlainRegister());
984 VIXL_CHECK(Operand(x1, LSL, 0).IsPlainRegister());
985 VIXL_CHECK(Operand(x2, LSR, 0).IsPlainRegister());
986 VIXL_CHECK(Operand(x3, ASR, 0).IsPlainRegister());
987 VIXL_CHECK(Operand(x4, ROR, 0).IsPlainRegister());
988 VIXL_CHECK(Operand(x5, UXTX).IsPlainRegister());
989 VIXL_CHECK(Operand(x6, SXTX).IsPlainRegister());
990 VIXL_CHECK(Operand(w7).IsPlainRegister());
991 VIXL_CHECK(Operand(w8, LSL, 0).IsPlainRegister());
992 VIXL_CHECK(Operand(w9, LSR, 0).IsPlainRegister());
993 VIXL_CHECK(Operand(w10, ASR, 0).IsPlainRegister());
994 VIXL_CHECK(Operand(w11, ROR, 0).IsPlainRegister());
996 VIXL_CHECK(!Operand(x0, LSL, 1).IsPlainRegister());
997 VIXL_CHECK(!Operand(x1, LSR, 2).IsPlainRegister());
998 VIXL_CHECK(!Operand(x2, ASR, 3).IsPlainRegister());
999 VIXL_CHECK(!Operand(x3, ROR, 4).IsPlainRegister());
1000 VIXL_CHECK(!Operand(x5, UXTX, 1).IsPlainRegister());
1001 VIXL_CHECK(!Operand(x6, SXTX, 2).IsPlainRegister());
1002 VIXL_CHECK(!Operand(w7, LSL, 1).IsPlainRegister());
1003 VIXL_CHECK(!Operand(w8, LSR, 2).IsPlainRegister());
1004 VIXL_CHECK(!Operand(w9, ASR, 3).IsPlainRegister());
1005 VIXL_CHECK(!Operand(w10, ROR, 4).IsPlainRegister());
1006 VIXL_CHECK(!Operand(w11, UXTB).IsPlainRegister());
1007 VIXL_CHECK(!Operand(w12, SXTB).IsPlainRegister());
1008 VIXL_CHECK(!Operand(w13, UXTH).IsPlainRegister());
1009 VIXL_CHECK(!Operand(w14, SXTH).IsPlainRegister());
1012 VIXL_CHECK(!Operand(w15, UXTW).IsPlainRegister());
1013 VIXL_CHECK(!Operand(w16, SXTW).IsPlainRegister());
1018 VIXL_CHECK(MemOperand(x0).IsPlainRegister());
1019 VIXL_CHECK(MemOperand(sp).IsPlainRegister());
1020 VIXL_CHECK(MemOperand(x1, 0).IsPlainRegister());
1022 VIXL_CHECK(!MemOperand(x2, xzr).IsPlainRegister());
1023 VIXL_CHECK(!MemOperand(x3, xzr, SXTX).IsPlainRegister());
1024 VIXL_CHECK(!MemOperand(x4, xzr, SXTX, 2).IsPlainRegister());
1025 VIXL_CHECK(!MemOperand(x5, wzr, UXTW).IsPlainRegister());
1026 VIXL_CHECK(!MemOperand(x6, wzr, UXTW, 3).IsPlainRegister());
1028 VIXL_CHECK(!MemOperand(x7, 0, PostIndex).IsPlainRegister());
1029 VIXL_CHECK(!MemOperand(x8, 0, PreIndex).IsPlainRegister());
1030 VIXL_CHECK(!MemOperand(x9, xzr, PostIndex).IsPlainRegister());
1032 VIXL_CHECK(!MemOperand(x20, 1).IsPlainRegister());
1033 VIXL_CHECK(!MemOperand(x21, x30).IsPlainRegister());
1037 VIXL_CHECK(MemOperand(x0).IsEquivalentToPlainRegister());
1038 VIXL_CHECK(MemOperand(sp).IsEquivalentToPlainRegister());
1039 VIXL_CHECK(MemOperand(x1, 0).IsEquivalentToPlainRegister());
1041 VIXL_CHECK(MemOperand(x2, xzr).IsEquivalentToPlainRegister());
1042 VIXL_CHECK(MemOperand(x3, xzr, SXTX).IsEquivalentToPlainRegister());
1043 VIXL_CHECK(MemOperand(x4, xzr, SXTX, 2).IsEquivalentToPlainRegister());
1044 VIXL_CHECK(MemOperand(x5, wzr, UXTW).IsEquivalentToPlainRegister());
1045 VIXL_CHECK(MemOperand(x6, wzr, UXTW, 3).IsEquivalentToPlainRegister());
1047 VIXL_CHECK(MemOperand(x7, 0, PostIndex).IsEquivalentToPlainRegister());
1048 VIXL_CHECK(MemOperand(x8, 0, PreIndex).IsEquivalentToPlainRegister());
1049 VIXL_CHECK(MemOperand(x9, xzr, PostIndex).IsEquivalentToPlainRegister());
1051 VIXL_CHECK(!MemOperand(x20, 1).IsEquivalentToPlainRegister());
1052 VIXL_CHECK(!MemOperand(x21, x30).IsEquivalentToPlainRegister());
1056 VIXL_CHECK(SVEMemOperand(x0).IsPlainScalar());
1057 VIXL_CHECK(SVEMemOperand(sp).IsPlainScalar());
1058 VIXL_CHECK(SVEMemOperand(x1, 0).IsPlainScalar());
1060 VIXL_CHECK(!SVEMemOperand(x2, xzr).IsPlainScalar());
1061 VIXL_CHECK(!SVEMemOperand(x4, xzr, LSL, 2).IsPlainScalar());
1063 VIXL_CHECK(!SVEMemOperand(x20, 1).IsPlainScalar());
1064 VIXL_CHECK(!SVEMemOperand(x21, x30).IsPlainScalar());
1066 VIXL_CHECK(!SVEMemOperand(x0, z1.VnD()).IsPlainScalar());
1067 VIXL_CHECK(!SVEMemOperand(x2, z3.VnS(), UXTW).IsPlainScalar());
1068 VIXL_CHECK(!SVEMemOperand(z4.VnD(), 0).IsPlainScalar());
1072 VIXL_CHECK(SVEMemOperand(x0).IsEquivalentToScalar());
1073 VIXL_CHECK(SVEMemOperand(sp).IsEquivalentToScalar());
1074 VIXL_CHECK(SVEMemOperand(x1, 0).IsEquivalentToScalar());
1076 VIXL_CHECK(SVEMemOperand(x2, xzr).IsEquivalentToScalar());
1077 VIXL_CHECK(SVEMemOperand(x4, xzr, LSL, 2).IsEquivalentToScalar());
1079 VIXL_CHECK(!SVEMemOperand(x20, 1).IsEquivalentToScalar());
1080 VIXL_CHECK(!SVEMemOperand(x21, x30).IsEquivalentToScalar());
1082 VIXL_CHECK(!SVEMemOperand(x0, z1.VnD()).IsEquivalentToScalar());
1083 VIXL_CHECK(!SVEMemOperand(x2, z3.VnD(), SXTW).IsEquivalentToScalar());
1084 VIXL_CHECK(!SVEMemOperand(z4.VnD(), 0).IsEquivalentToScalar());
1088 VIXL_CHECK(SVEMemOperand(x0, 42).IsScalarPlusImmediate());
1089 VIXL_CHECK(SVEMemOperand(x1, 42, SVE_MUL_VL).IsScalarPlusImmediate());
1090 VIXL_CHECK(SVEMemOperand(x2, -42, SVE_MUL_VL).IsScalarPlusImmediate());
1092 VIXL_CHECK(SVEMemOperand(sp, x3).IsScalarPlusScalar());
1093 VIXL_CHECK(SVEMemOperand(x4, xzr).IsScalarPlusScalar());
1094 VIXL_CHECK(SVEMemOperand(x5, x6, LSL, 1).IsScalarPlusScalar());
1096 VIXL_CHECK(SVEMemOperand(x7, z0.VnD()).IsScalarPlusVector());
1097 VIXL_CHECK(SVEMemOperand(x8, z1.VnS(), SXTW).IsScalarPlusVector());
1098 VIXL_CHECK(SVEMemOperand(x9, z2.VnD(), UXTW).IsScalarPlusVector());
1099 VIXL_CHECK(SVEMemOperand(x10, z3.VnD(), LSL, 2).IsScalarPlusVector());
1101 VIXL_CHECK(SVEMemOperand(z4.VnD(), 42).IsVectorPlusImmediate());
1102 VIXL_CHECK(SVEMemOperand(z5.VnS(), -42).IsVectorPlusImmediate());
1107 VIXL_CHECK(!SVEMemOperand(x0, 42).IsScatterGather());
1108 VIXL_CHECK(!SVEMemOperand(x1, 42, SVE_MUL_VL).IsScatterGather());
1109 VIXL_CHECK(!SVEMemOperand(x2, -42, SVE_MUL_VL).IsScatterGather());
1111 VIXL_CHECK(!SVEMemOperand(sp, x3).IsScatterGather());
1112 VIXL_CHECK(!SVEMemOperand(x4, xzr).IsScatterGather());
1113 VIXL_CHECK(!SVEMemOperand(x5, x6, LSL, 1).IsScatterGather());
1116 VIXL_CHECK(SVEMemOperand(x7, z0.VnD()).IsScatterGather());
1117 VIXL_CHECK(SVEMemOperand(x8, z1.VnS(), SXTW).IsScatterGather());
1118 VIXL_CHECK(SVEMemOperand(x9, z2.VnD(), UXTW).IsScatterGather());
1119 VIXL_CHECK(SVEMemOperand(x10, z3.VnD(), LSL, 2).IsScatterGather());
1121 VIXL_CHECK(SVEMemOperand(z4.VnD(), 42).IsScatterGather());
1122 VIXL_CHECK(SVEMemOperand(z5.VnS(), -42).IsScatterGather());
1132 VIXL_CHECK(temp1.Is(w16));
1133 VIXL_CHECK(temp2.Is(x17));
1139 VIXL_CHECK(temp1.Is(x16));
1140 VIXL_CHECK(temp2.Is(w17));
1150 VIXL_CHECK(temp.Is(h31));
1155 VIXL_CHECK(temp.Is(s31));
1160 VIXL_CHECK(temp.Is(d31));
1165 VIXL_CHECK(temp.Is(q31));
1170 VIXL_CHECK(temp.Is(d31));
1175 VIXL_CHECK(temp.Is(s31));
1184 VIXL_CHECK(temps.IsAvailable(v31));
1185 VIXL_CHECK(temps.IsAvailable(z31));
1187 VIXL_CHECK(temp.Is(z31));
1190 VIXL_CHECK(!temps.IsAvailable(v31));
1191 VIXL_CHECK(!temps.IsAvailable(z31));
1195 VIXL_CHECK(temps.IsAvailable(v31));
1196 VIXL_CHECK(temps.IsAvailable(z31));
1204 VIXL_CHECK(masm.GetScratchPRegisterList()->IsEmpty());
1206 VIXL_CHECK(temps.IsAvailable(p0));
1207 VIXL_CHECK(temps.IsAvailable(p1));
1209 VIXL_CHECK(temps.IsAvailable(p7));
1210 VIXL_CHECK(temps.IsAvailable(p8));
1211 VIXL_CHECK(temps.IsAvailable(p15));
1214 VIXL_CHECK(temps.AcquireGoverningP().GetCode() <
1216 VIXL_CHECK(temps.AcquireGoverningP().GetCode() <
1218 VIXL_CHECK(temps.IsAvailable(p8));
1219 VIXL_CHECK(temps.IsAvailable(p15));
1222 VIXL_CHECK(temps.AcquireP().GetCode() >= kNumberOfGoverningPRegisters);
1223 VIXL_CHECK(temps.AcquireP().GetCode() >= kNumberOfGoverningPRegisters);
1225 VIXL_CHECK(temps.AcquireP().GetCode() < kNumberOfGoverningPRegisters);
1227 VIXL_CHECK(masm.GetScratchPRegisterList()->IsEmpty());
1231 VIXL_CHECK(!masm.GetScratchPRegisterList()->IsEmpty());
1234 VIXL_CHECK(masm.GetScratchPRegisterList()->IsEmpty());
1256 VIXL_CHECK(masm.GetScratchRegisterList()->IsEmpty());
1257 VIXL_CHECK(masm.GetScratchVRegisterList()->IsEmpty());
1288 VIXL_CHECK((*expected & update) == 0);
1297 VIXL_CHECK(masm_->GetScratchRegisterList()->GetList() == expected_);
1298 VIXL_CHECK(masm_->GetScratchVRegisterList()->GetList() == expected_v_);
1299 VIXL_CHECK(masm_->GetScratchPRegisterList()->GetList() == expected_p_);
1718 VIXL_CHECK(IsAligned<16>(s.GetBase()));
1719 VIXL_CHECK(IsAligned<16>(s.GetLimit() + 1));
1721 VIXL_CHECK(s.GetBase() > s.GetLimit());
1725 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetBase(), 1));
1726 VIXL_CHECK(!s.IsAccessInGuardRegion(s.GetBase() - 1, 1));
1728 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetLimit(), 1));
1729 VIXL_CHECK(!s.IsAccessInGuardRegion(s.GetLimit() + 1, 1));
1732 VIXL_CHECK(!s.IsAccessInGuardRegion(s.GetBase() - 16, 16));
1733 VIXL_CHECK(!s.IsAccessInGuardRegion(s.GetLimit() + 1, 16));
1744 VIXL_CHECK(IsAligned<1024>(s.GetBase()));
1745 VIXL_CHECK(IsAligned<1024>(s.GetLimit() + 1));
1750 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetBase(), 1));
1751 VIXL_CHECK(!s.IsAccessInGuardRegion(s.GetBase() - 1, 1));
1752 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetLimit(), 1));
1753 VIXL_CHECK(!s.IsAccessInGuardRegion(s.GetLimit() + 1, 1));
1754 VIXL_CHECK((s.GetBase() - s.GetLimit() - 1) == 2048);
1757 VIXL_CHECK(!s.IsAccessInGuardRegion(s.GetLimit() + 1, 2048));
1759 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetLimit(), 2048));
1760 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetLimit() + 1, 2049));
1762 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetBase() - 42, 4096));
1763 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetLimit() - 1280, 2048));
1764 VIXL_CHECK(s.IsAccessInGuardRegion(s.GetLimit() - 1280, 10000));