You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
(122) |
Nov
(152) |
Dec
(69) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(6) |
Feb
(25) |
Mar
(73) |
Apr
(82) |
May
(24) |
Jun
(25) |
Jul
(10) |
Aug
(11) |
Sep
(10) |
Oct
(54) |
Nov
(203) |
Dec
(182) |
| 2004 |
Jan
(307) |
Feb
(305) |
Mar
(430) |
Apr
(312) |
May
(187) |
Jun
(342) |
Jul
(487) |
Aug
(637) |
Sep
(336) |
Oct
(373) |
Nov
(441) |
Dec
(210) |
| 2005 |
Jan
(385) |
Feb
(480) |
Mar
(636) |
Apr
(544) |
May
(679) |
Jun
(625) |
Jul
(810) |
Aug
(838) |
Sep
(634) |
Oct
(521) |
Nov
(965) |
Dec
(543) |
| 2006 |
Jan
(494) |
Feb
(431) |
Mar
(546) |
Apr
(411) |
May
(406) |
Jun
(322) |
Jul
(256) |
Aug
(401) |
Sep
(345) |
Oct
(542) |
Nov
(308) |
Dec
(481) |
| 2007 |
Jan
(427) |
Feb
(326) |
Mar
(367) |
Apr
(255) |
May
(244) |
Jun
(204) |
Jul
(223) |
Aug
(231) |
Sep
(354) |
Oct
(374) |
Nov
(497) |
Dec
(362) |
| 2008 |
Jan
(322) |
Feb
(482) |
Mar
(658) |
Apr
(422) |
May
(476) |
Jun
(396) |
Jul
(455) |
Aug
(267) |
Sep
(280) |
Oct
(253) |
Nov
(232) |
Dec
(304) |
| 2009 |
Jan
(486) |
Feb
(470) |
Mar
(458) |
Apr
(423) |
May
(696) |
Jun
(461) |
Jul
(551) |
Aug
(575) |
Sep
(134) |
Oct
(110) |
Nov
(157) |
Dec
(102) |
| 2010 |
Jan
(226) |
Feb
(86) |
Mar
(147) |
Apr
(117) |
May
(107) |
Jun
(203) |
Jul
(193) |
Aug
(238) |
Sep
(300) |
Oct
(246) |
Nov
(23) |
Dec
(75) |
| 2011 |
Jan
(133) |
Feb
(195) |
Mar
(315) |
Apr
(200) |
May
(267) |
Jun
(293) |
Jul
(353) |
Aug
(237) |
Sep
(278) |
Oct
(611) |
Nov
(274) |
Dec
(260) |
| 2012 |
Jan
(303) |
Feb
(391) |
Mar
(417) |
Apr
(441) |
May
(488) |
Jun
(655) |
Jul
(590) |
Aug
(610) |
Sep
(526) |
Oct
(478) |
Nov
(359) |
Dec
(372) |
| 2013 |
Jan
(467) |
Feb
(226) |
Mar
(391) |
Apr
(281) |
May
(299) |
Jun
(252) |
Jul
(311) |
Aug
(352) |
Sep
(481) |
Oct
(571) |
Nov
(222) |
Dec
(231) |
| 2014 |
Jan
(185) |
Feb
(329) |
Mar
(245) |
Apr
(238) |
May
(281) |
Jun
(399) |
Jul
(382) |
Aug
(500) |
Sep
(579) |
Oct
(435) |
Nov
(487) |
Dec
(256) |
| 2015 |
Jan
(338) |
Feb
(357) |
Mar
(330) |
Apr
(294) |
May
(191) |
Jun
(108) |
Jul
(142) |
Aug
(261) |
Sep
(190) |
Oct
(54) |
Nov
(83) |
Dec
(22) |
| 2016 |
Jan
(49) |
Feb
(89) |
Mar
(33) |
Apr
(50) |
May
(27) |
Jun
(34) |
Jul
(53) |
Aug
(53) |
Sep
(98) |
Oct
(206) |
Nov
(93) |
Dec
(53) |
| 2017 |
Jan
(65) |
Feb
(82) |
Mar
(102) |
Apr
(86) |
May
(187) |
Jun
(67) |
Jul
(23) |
Aug
(93) |
Sep
(65) |
Oct
(45) |
Nov
(35) |
Dec
(17) |
| 2018 |
Jan
(26) |
Feb
(35) |
Mar
(38) |
Apr
(32) |
May
(8) |
Jun
(43) |
Jul
(27) |
Aug
(30) |
Sep
(43) |
Oct
(42) |
Nov
(38) |
Dec
(67) |
| 2019 |
Jan
(32) |
Feb
(37) |
Mar
(53) |
Apr
(64) |
May
(49) |
Jun
(18) |
Jul
(14) |
Aug
(53) |
Sep
(25) |
Oct
(30) |
Nov
(49) |
Dec
(31) |
| 2020 |
Jan
(87) |
Feb
(45) |
Mar
(37) |
Apr
(51) |
May
(99) |
Jun
(36) |
Jul
(11) |
Aug
(14) |
Sep
(20) |
Oct
(24) |
Nov
(40) |
Dec
(23) |
| 2021 |
Jan
(14) |
Feb
(53) |
Mar
(85) |
Apr
(15) |
May
(19) |
Jun
(3) |
Jul
(14) |
Aug
(1) |
Sep
(57) |
Oct
(73) |
Nov
(56) |
Dec
(22) |
| 2022 |
Jan
(3) |
Feb
(22) |
Mar
(6) |
Apr
(55) |
May
(46) |
Jun
(39) |
Jul
(15) |
Aug
(9) |
Sep
(11) |
Oct
(34) |
Nov
(20) |
Dec
(36) |
| 2023 |
Jan
(79) |
Feb
(41) |
Mar
(99) |
Apr
(169) |
May
(48) |
Jun
(16) |
Jul
(16) |
Aug
(57) |
Sep
(19) |
Oct
|
Nov
|
Dec
|
| S | M | T | W | T | F | S |
|---|---|---|---|---|---|---|
|
1
(3) |
2
|
3
(2) |
4
(3) |
5
|
6
(1) |
7
|
|
8
|
9
(4) |
10
(1) |
11
(2) |
12
(1) |
13
(8) |
14
|
|
15
|
16
|
17
|
18
(2) |
19
(1) |
20
|
21
|
|
22
|
23
|
24
|
25
|
26
|
27
(1) |
28
(2) |
|
29
(6) |
30
|
31
|
|
|
|
|
|
From: Khem R. <raj...@gm...> - 2020-03-09 23:36:39
|
modern libc provides these functions, moreover this also ensures that we
are 64bit time_t safe. Fallback to existing definitions if libc does not
have the implementation or syscall is not defined
Signed-off-by: Khem Raj <raj...@gm...>
---
config.h | 9 +++++++++
config.h.in | 9 +++++++++
configure | 3 +++
configure.ac | 3 +++
memcheck/tests/linux/timerfd-syscall.c | 10 ++++++++--
5 files changed, 32 insertions(+), 2 deletions(-)
diff --git a/config.h b/config.h
index 18bb1c2..6f56dbe 100644
--- a/config.h
+++ b/config.h
@@ -311,6 +311,15 @@
/* Define to 1 if <sys/user.h> defines struct user_regs_struct */
/* #undef HAVE_SYS_USER_REGS */
+/* Define to 1 if you have the `timerfd_create' function. */
+#define HAVE_TIMERFD_CREATE 1
+
+/* Define to 1 if you have the `timerfd_gettime' function. */
+#define HAVE_TIMERFD_GETTIME 1
+
+/* Define to 1 if you have the `timerfd_settime' function. */
+#define HAVE_TIMERFD_SETTIME 1
+
/* can use __thread to define thread-local variables */
#define HAVE_TLS 1
diff --git a/config.h.in b/config.h.in
index 9747421..0f7cfca 100644
--- a/config.h.in
+++ b/config.h.in
@@ -310,6 +310,15 @@
/* Define to 1 if <sys/user.h> defines struct user_regs_struct */
#undef HAVE_SYS_USER_REGS
+/* Define to 1 if you have the `timerfd_create' function. */
+#undef HAVE_TIMERFD_CREATE
+
+/* Define to 1 if you have the `timerfd_gettime' function. */
+#undef HAVE_TIMERFD_GETTIME
+
+/* Define to 1 if you have the `timerfd_settime' function. */
+#undef HAVE_TIMERFD_SETTIME
+
/* can use __thread to define thread-local variables */
#undef HAVE_TLS
diff --git a/configure b/configure
index e6b79b6..9f5d9aa 100755
--- a/configure
+++ b/configure
@@ -14681,6 +14681,9 @@ for ac_func in \
strrchr \
strstr \
syscall \
+ timerfd_create \
+ timerfd_gettime \
+ timerfd_settime \
utimensat \
process_vm_readv \
process_vm_writev \
diff --git a/configure.ac b/configure.ac
index 8ea157b..44f129c 100755
--- a/configure.ac
+++ b/configure.ac
@@ -4169,6 +4169,9 @@ AC_CHECK_FUNCS([ \
strrchr \
strstr \
syscall \
+ timerfd_create \
+ timerfd_gettime \
+ timerfd_settime \
utimensat \
process_vm_readv \
process_vm_writev \
diff --git a/memcheck/tests/linux/timerfd-syscall.c b/memcheck/tests/linux/timerfd-syscall.c
index 74f0682..a024715 100644
--- a/memcheck/tests/linux/timerfd-syscall.c
+++ b/memcheck/tests/linux/timerfd-syscall.c
@@ -54,7 +54,7 @@
* timerfd_* system call numbers introduced in 2.6.23. These constants are
* not yet in the glibc 2.7 headers, that is why they are defined here.
*/
-#ifndef __NR_timerfd_create
+#if !defined(__NR_timerfd_create) && !defined(HAVE_TIMERFD_CREATE)
#if defined(__x86_64__)
#define __NR_timerfd_create 283
#elif defined(__i386__)
@@ -68,7 +68,7 @@
#endif
#endif
-#ifndef __NR_timerfd_settime
+#if !defined(__NR_timerfd_settime) && !defined(HAVE_TIMERFD_SETTIME)
#if defined(__x86_64__)
#define __NR_timerfd_settime 286
#define __NR_timerfd_gettime 287
@@ -127,21 +127,27 @@ void set_timespec(struct timespec *tmr, unsigned long long ustime)
tmr->tv_nsec = (long) (1000ULL * (ustime % 1000000ULL));
}
+#if !defined(HAVE_TIMERFD_CREATE)
int timerfd_create(int clockid, int flags)
{
return syscall(__NR_timerfd_create, clockid, flags);
}
+#endif
+#if !defined(HAVE_TIMERFD_SETTIME)
int timerfd_settime(int ufc, int flags, const struct itimerspec *utmr,
struct itimerspec *otmr)
{
return syscall(__NR_timerfd_settime, ufc, flags, utmr, otmr);
}
+#endif
+#if !defined(HAVE_TIMERFD_GETTIME)
int timerfd_gettime(int ufc, struct itimerspec *otmr)
{
return syscall(__NR_timerfd_gettime, ufc, otmr);
}
+#endif
long waittmr(int tfd, int timeo)
{
--
2.25.1
|
|
From: Julian S. <se...@so...> - 2020-03-09 08:27:07
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=6ef04b381879746585592ccb84ca19622f68e093 commit 6ef04b381879746585592ccb84ca19622f68e093 Author: Julian Seward <js...@ac...> Date: Mon Mar 9 09:08:28 2020 +0100 Update bug status. Diff: --- NEWS | 13 ++++++----- docs/internals/3_15_BUGSTATUS.txt | 49 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 55 insertions(+), 7 deletions(-) diff --git a/NEWS b/NEWS index d8095be..a60062b 100644 --- a/NEWS +++ b/NEWS @@ -117,11 +117,6 @@ where XXXXXX is the bug number as listed below. 416301 s390x: "compare and signal" not supported 416387 finit_module and bpf syscalls are unhandled on arm64 416464 Fix false reports for uninitialized memory for PR_CAPBSET_READ/DROP -n-i-bz Fix minor one time leaks in dhat. -n-i-bz Add --run-cxx-freeres=no in outer args to avoid inner crashes. -n-i-bz Add support for the Linux io_uring system calls -n-i-bz sys_statx: don't complain if both |filename| and |buf| are NULL. -n-i-bz Fix non-glibc build of test suite with s390x_features 416667 gcc10 ppc64le impossible constraint in 'asm' in test_isa. 416753 new 32bit time syscalls for 2038+ 417427 commit to fix vki_siginfo_t definition created numerous regression @@ -129,7 +124,13 @@ n-i-bz Fix non-glibc build of test suite with s390x_features 417452 s390_insn_store_emit: dst->tag for HRcVec128 417578 Add suppressions for glibc DTV leaks 417906 clone with CLONE_VFORK and no CLONE_VM fails -418435 s390x: memcmp test yields extra "Conditional jump or move depends on uninitialised value(s)" +418435 s390x: memcmp test yields extra "Conditional jump or move depends on + uninitialised value(s)" +n-i-bz Fix minor one time leaks in dhat. +n-i-bz Add --run-cxx-freeres=no in outer args to avoid inner crashes. +n-i-bz Add support for the Linux io_uring system calls +n-i-bz sys_statx: don't complain if both |filename| and |buf| are NULL. +n-i-bz Fix non-glibc build of test suite with s390x_features Release 3.15.0 (12 April 2019) diff --git a/docs/internals/3_15_BUGSTATUS.txt b/docs/internals/3_15_BUGSTATUS.txt index adb625b..0ac7ded 100644 --- a/docs/internals/3_15_BUGSTATUS.txt +++ b/docs/internals/3_15_BUGSTATUS.txt @@ -172,9 +172,56 @@ of 3.15.0. It doesn't carry over bugs from earlier versions. === zz_other/x86 ======================================================= +-- Wed 4 Mar 10:48:31 CET 2020 --- Wed 22 Jan 08:57:09 CET 2020 +.416682 [MIPS-Linux] mmap failed under valgrind +.416753 new 32bit time syscalls for 2038+ +In progress + +. 416760 ppc64le Assertion 'VG_IS_16_ALIGNED(sizeof(struct rt_sigframe))' +Seems important. Status unclear. + +.416779 valgrind: m_debuginfo/debuginfo.c:454 +(discard_or_archive_DebugInfo): Assertion '!di->have_dinfo || +is_DebugInfo_active(di)' failed. +WINE wierdness + +.417075 pwritev(vector[...]) suppression ignored + +.394227 [x86] False negative "uninitialised value" report due to not +recognizing simd registers clear by pcmp* (still alive) + +.417175 Valgrind is not working on Android pie. + +.417187 [MIPS] Conditional branch problem since 'grail' changes +It sounds like the MIPS folks have basically solved the problem + +.417238 Test memcheck/tests/vbit-test fails on mips64 BE +Has discussion + +.417264 Musl issues: Fix none/tests/pth_atfork1.c +Uhmm, MUSL + +.417266 Make memcheck/tests/linux/sigqueue usable with musl +Uhmm, MUSL + +.417281 s390x: /bin/true segfaults with "grail" enabled +Ongoing + +.417377 False-positive "uninitialised value(s)" reports from memcheck + +.417572 unhandled instruction bytes: 0xC5 0x79 0xD6 0xED 0xC5 0xF9 0x51 +Ech, some avx thing + +.417578 Add suppressions for glibc DTV leaks +Has patch, should land + +.417993 vbit-test fail on s390x with Iop_Add32: spurious dependency + on uninitialised value +Needs investigation + +.418004 Grail code additions break ppc64 ================== |
|
From: Julian S. <se...@so...> - 2020-03-09 08:23:51
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=3b067535056d7da12d6ca44685e696a99269585e commit 3b067535056d7da12d6ca44685e696a99269585e Author: Julian Seward <js...@ac...> Date: Mon Mar 9 09:22:31 2020 +0100 Bug 415136 - ARMv8.1 Compare-and-Swap instructions are not supported. (TEST CASES). This commit provides test cases for ARMv8.1 CAS instructions, support for which was added in the previous commit. Patch by Assad Hashmi <ass...@li...>. Diff: --- none/tests/arm64/atomics_v81.c | 5117 +++++++++++++- none/tests/arm64/atomics_v81.stdout.exp | 10911 ++++++++++++++++++++++++++++++ 2 files changed, 16013 insertions(+), 15 deletions(-) diff --git a/none/tests/arm64/atomics_v81.c b/none/tests/arm64/atomics_v81.c index aa8f2a5..f0c5b8f 100644 --- a/none/tests/arm64/atomics_v81.c +++ b/none/tests/arm64/atomics_v81.c @@ -7,6 +7,7 @@ #include <stdio.h> #include <malloc.h> #include <stdint.h> +#include <string.h> typedef unsigned char UChar; typedef unsigned int UInt; @@ -59,22 +60,68 @@ CHECK(eor, ^, 64); printf("\n\n"); \ } +#define ATOMIC_TEST_CAS(instruction, rsz, base_addr, mem_val_, rs_, rt_, dsz) \ +{ \ + ULong rs = (ULong)rs_; \ + ULong rt = (ULong)rt_; \ + ULong mem_val = (ULong)mem_val_; \ + \ + ULong mem_val_after; \ + mem_val_after = 0ULL; \ + \ + int pad = (strcmp(#rsz, "w") == 0) ? 8 : 16; \ + printf("%s :: rs %0*llx rt %0*llx rn mem %0*llx\n", \ + instruction, pad, rs, pad, rt, pad, mem_val); \ + \ + Int swap = (rs == mem_val) ? 1 : 0; \ + __asm__ __volatile__( \ + "mov " #rsz "5, %" #rsz "1;" \ + "mov " #rsz "13, %" #rsz "2;" \ + "str " #rsz "13, [x5, #0];" \ + "mov " #rsz "11, %" #rsz "3;" \ + "mov " #rsz "12, %" #rsz "4;" \ + instruction ";" \ + "ldr %" #rsz "0, [x5, #0];" \ + : "=&r" (mem_val_after) \ + : "r" (base_addr), "r" (mem_val), "r" (rs), "r" (rt) \ + : #rsz "5", #rsz "11", #rsz "12", #rsz "13", "memory" \ + ); \ + printf("%s :: rs %0*llx rt %0*llx rn mem %0*llx ", \ + instruction, pad, rs, pad, rt, pad, mem_val_after); \ + if (swap == 1) { \ + if ((mem_val_after & dsz) != (rt & dsz)) \ + printf("FAIL: swapped but mem after != rt"); \ + } \ + else { \ + if ((mem_val_after & dsz) != (mem_val & dsz)) \ + printf("FAIL: no swap but mem after != mem before"); \ + } \ + printf("\n\n"); \ +} + + // Test patterns -#define ALL5s_64 0x5555555555555555ULL -#define ALLas_64 0xAAAAAAAAAAAAAAAAULL -#define ALLfs_64 0xFFFFFFFFFFFFFFFFULL -#define UP_64 0x0123456789ABCDEFULL -#define DOWN_64 0xFEDCBA9876543210ULL -#define PI_64 0x3141592653589793ULL -#define E_64 0x2718281828459045ULL - -#define ALL5s_32 0x55555555ULL -#define ALLas_32 0xAAAAAAAAULL -#define ALLfs_32 0xFFFFFFFFULL -#define UP_32 0x01234567ULL -#define DOWN_32 0xFEDCBA98ULL -#define PI_32 0x31415926ULL -#define E_32 0x27182818ULL +#define ALL5s_64 0x5555555555555555ULL +#define MOST5s_64 0x5555555555555554ULL +#define ALLas_64 0xAAAAAAAAAAAAAAAAULL +#define MOSTas_64 0xAAAAAAAAAAAAAAA8ULL +#define ALLfs_64 0xFFFFFFFFFFFFFFFFULL +#define MOSTfs_64 0xFFFFFFFFFFFFFFFEULL +#define UP_64 0x0123456789ABCDEFULL +#define DOWN_64 0xFEDCBA9876543210ULL +#define PI_64 0x3141592653589793ULL +#define E_64 0x2718281828459045ULL + +#define ALL5s_32 0x55555555ULL +#define MOST5s_32 0x55555554ULL +#define ALLas_32 0xAAAAAAAAULL +#define MOSTas_32 0xAAAAAAA8ULL +#define ALLfs_32 0xFFFFFFFFULL +#define MOSTfs_32 0xFFFFFFFEULL +#define UP_32 0x01234567ULL +#define DOWN_32 0xFEDCBA98ULL +#define PI_32 0x31415926ULL +#define E_32 0x27182818ULL #define ALL5s_16 0x5555ULL #define ALLas_16 0xAAAAULL @@ -452,6 +499,5046 @@ static __attribute((noinline)) void test_atomics ( void ) // LDEORB, LDEORAB, LDEORALB, LDEORLB // LDEORH, LDEORAH, LDEORALH, LDEORLH + printf("CAS <Ws>, <Wt>, [<Xn|SP>]\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, 0, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, 1, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, 1, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 1, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 1, 0, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 1, 1, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 1, 1, 1, 0xFFFFFFFF); + + printf("Combinations of ALL5s_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALL5s_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOST5s_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOST5s_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, 0, 0xFFFFFFFF); + + printf("Combinations of ALLas_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLas_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOSTas_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTas_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, 0, 0xFFFFFFFF); + + printf("Combinations of ALLfs_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, ALLfs_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOSTfs_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, MOSTfs_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, 0, 0xFFFFFFFF); + + printf("Combinations of UP_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, UP_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, UP_32, UP_32, 0, 0xFFFFFFFF); + + printf("Combinations of DOWN_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, 0, DOWN_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("cas w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, 0, 0xFFFFFFFF); + + printf("CASA <Ws>, <Wt>, [<Xn|SP>]\n\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, 0, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, 1, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, 1, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 1, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 1, 0, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 1, 1, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 1, 1, 1, 0xFFFFFFFF); + + printf("Combinations of ALL5s_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALL5s_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOST5s_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOST5s_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, 0, 0xFFFFFFFF); + + printf("Combinations of ALLas_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLas_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOSTas_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTas_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, 0, 0xFFFFFFFF); + + printf("Combinations of ALLfs_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, ALLfs_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOSTfs_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, MOSTfs_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, 0, 0xFFFFFFFF); + + printf("Combinations of UP_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, UP_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, UP_32, UP_32, 0, 0xFFFFFFFF); + + printf("Combinations of DOWN_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, 0, DOWN_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casa w11, w12, [x5]", w, mem, DOWN_32, DOWN_32, 0, 0xFFFFFFFF); + + printf("CASAL <Ws>, <Wt>, [<Xn|SP>]\n\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, 0, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, 1, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, 1, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 1, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 1, 0, 1, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 1, 1, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 1, 1, 1, 0xFFFFFFFF); + + printf("Combinations of ALL5s_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALL5s_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALL5s_32, ALL5s_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOST5s_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOST5s_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOST5s_32, MOST5s_32, 0, 0xFFFFFFFF); + + printf("Combinations of ALLas_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLas_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLas_32, ALLas_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOSTas_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTas_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTas_32, MOSTas_32, 0, 0xFFFFFFFF); + + printf("Combinations of ALLfs_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, ALLfs_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, ALLfs_32, ALLfs_32, 0, 0xFFFFFFFF); + + printf("Combinations of MOSTfs_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOST5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALLas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALLas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOSTas_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOSTas_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, ALLfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, ALLfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, MOSTfs_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, MOSTfs_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, UP_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, UP_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, DOWN_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, DOWN_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, MOSTfs_32, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, 0, 0, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, MOSTfs_32, MOSTfs_32, 0, 0xFFFFFFFF); + + printf("Combinations of UP_32 and all other patterns\n"); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, UP_32, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, UP_32, 0, ALL5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, UP_32, UP_32, ALL5s_32, 0xFFFFFFFF); + + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem, 0, UP_32, MOST5s_32, 0xFFFFFFFF); + ATOMIC_TEST_CAS("casal w11, w12, [x5]", w, mem... [truncated message content] |
|
From: Julian S. <se...@so...> - 2020-03-09 08:20:55
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=2281c8c8675969537dc734237b60157e8a0fe0d6 commit 2281c8c8675969537dc734237b60157e8a0fe0d6 Author: Julian Seward <js...@ac...> Date: Mon Mar 9 09:18:09 2020 +0100 Bug 415136 - ARMv8.1 Compare-and-Swap instructions are not supported. This commit implements ARMv8.1 CAS instructions. It does not contain test cases; those will be in a subsequent commit. Patch by Assad Hashmi <ass...@li...>. Diff: --- VEX/priv/guest_arm64_toIR.c | 43 +++++++++++++++++++++++++++++++++++++++++++ VEX/priv/host_arm64_defs.c | 29 +++++++++++++++++------------ VEX/priv/host_arm64_defs.h | 7 ++++--- VEX/priv/host_arm64_isel.c | 9 +-------- 4 files changed, 65 insertions(+), 23 deletions(-) diff --git a/VEX/priv/guest_arm64_toIR.c b/VEX/priv/guest_arm64_toIR.c index aae3c6f..c8bfd18 100644 --- a/VEX/priv/guest_arm64_toIR.c +++ b/VEX/priv/guest_arm64_toIR.c @@ -6864,6 +6864,49 @@ Bool dis_ARM64_load_store(/*MB_OUT*/DisResult* dres, UInt insn, return True; } + /* ------------------ ARMv8.1-LSE: Compare-and-Swap ------------------ */ + /* 31 29 22 21 20 15 14 9 4 + sz 0010001 A 1 s R 11111 n t CAS{,A}{,L}<sz> <Rs>, <Rt>, [<Xn|SP>] + */ + if (INSN(29,23) == BITS7(0,0,1,0,0,0,1) + && INSN(21,21) == 1 + && INSN(14,10) == BITS5(1,1,1,1,1)) { + UInt szBlg2 = INSN(31,30); + Bool isAcq = INSN(22,22) == 1; + Bool isRel = INSN(15,15) == 1; + UInt ss = INSN(20,16); + UInt nn = INSN(9,5); + UInt tt = INSN(4,0); + + const HChar* suffix[4] = { "b", "h", "", "" }; + + UInt szB = 1 << szBlg2; /* 1, 2, 4 or 8 */ + IRType ty = integerIRTypeOfSize(szB); + Bool is64 = szB == 8; + + IRExpr *exp = narrowFrom64(ty, getIReg64orZR(ss)); + IRExpr *new = narrowFrom64(ty, getIReg64orZR(tt)); + + if (isAcq) + stmt(IRStmt_MBE(Imbe_Fence)); + + // Store the result back if LHS remains unchanged in memory. + IRTemp old = newTemp(ty); + stmt( IRStmt_CAS(mkIRCAS(/*oldHi*/IRTemp_INVALID, old, + Iend_LE, getIReg64orSP(nn), + /*expdHi*/NULL, exp, + /*dataHi*/NULL, new)) ); + + if (isRel) + stmt(IRStmt_MBE(Imbe_Fence)); + + putIReg64orZR(ss, widenUto64(ty, mkexpr(old))); + DIP("cas%s%s%s %s, %s, [%s]\n", + isAcq ? "a" : "", isRel ? "l" : "", suffix[szBlg2], + nameIRegOrZR(is64, ss), nameIRegOrZR(is64, tt), nameIReg64orSP(nn)); + return True; + } + if (sigill_diag) { vex_printf("ARM64 front end: load_store\n"); } diff --git a/VEX/priv/host_arm64_defs.c b/VEX/priv/host_arm64_defs.c index 33acae9..13a61b0 100644 --- a/VEX/priv/host_arm64_defs.c +++ b/VEX/priv/host_arm64_defs.c @@ -3852,9 +3852,14 @@ Int emit_ARM64Instr ( /*MB_MOD*/Bool* is_profInc, } case ARM64in_CAS: { /* This isn't simple. For an explanation see the comment in - host_arm64_defs.h on the the definition of ARM64Instr case - CAS. */ + host_arm64_defs.h on the definition of ARM64Instr case CAS. + + NOTE: We could place "loop:" after mov/and but then we need + an additional scratch register. + */ /* Generate: + + loop: -- one of: mov x8, x5 // AA0503E8 and x8, x5, #0xFFFFFFFF // 92407CA8 @@ -3872,13 +3877,13 @@ Int emit_ARM64Instr ( /*MB_MOD*/Bool* is_profInc, bne out // 54000061 -- one of: - stxr w1, x7, [x3] // C8017C67 - stxr w1, w7, [x3] // 88017C67 - stxrh w1, w7, [x3] // 48017C67 - stxrb w1, w7, [x3] // 08017C67 + stxr w8, x7, [x3] // C8087C67 + stxr w8, w7, [x3] // 88087C67 + stxrh w8, w7, [x3] // 48087C67 + stxrb w8, w7, [x3] // 08087C67 -- always: - eor x1, x5, x1 // CA0100A1 + cbne w8, loop // 35FFFF68 out: */ switch (i->ARM64in.CAS.szB) { @@ -3897,12 +3902,12 @@ Int emit_ARM64Instr ( /*MB_MOD*/Bool* is_profInc, *p++ = 0xEB08003F; *p++ = 0x54000061; switch (i->ARM64in.CAS.szB) { - case 8: *p++ = 0xC8017C67; break; - case 4: *p++ = 0x88017C67; break; - case 2: *p++ = 0x48017C67; break; - case 1: *p++ = 0x08017C67; break; + case 8: *p++ = 0xC8087C67; break; + case 4: *p++ = 0x88087C67; break; + case 2: *p++ = 0x48087C67; break; + case 1: *p++ = 0x08087C67; break; } - *p++ = 0xCA0100A1; + *p++ = 0x35FFFF68; goto done; } case ARM64in_MFence: { diff --git a/VEX/priv/host_arm64_defs.h b/VEX/priv/host_arm64_defs.h index db50056..63cf2bb 100644 --- a/VEX/priv/host_arm64_defs.h +++ b/VEX/priv/host_arm64_defs.h @@ -679,6 +679,7 @@ typedef Uses x8 as scratch (but that's not allocatable). Hence: RD x3, x5, x7; WR x1 + loop: (szB=8) mov x8, x5 (szB=4) and x8, x5, #0xFFFFFFFF (szB=2) and x8, x5, #0xFFFF @@ -690,10 +691,10 @@ typedef bne after -- if branch taken, failure; x1[[8*szB-1 : 0] holds old value -- attempt to store - stxr w1, x7, [x3] + stxr w8, x7, [x3] -- if store successful, x1==0, so the eor is "x1 := x5" - -- if store failed, x1==1, so the eor makes x1 != x5 - eor x1, x5, x1 + -- if store failed, branch back and try again. + cbne w8, loop after: */ struct { diff --git a/VEX/priv/host_arm64_isel.c b/VEX/priv/host_arm64_isel.c index 4fa50b9..d19b19f 100644 --- a/VEX/priv/host_arm64_isel.c +++ b/VEX/priv/host_arm64_isel.c @@ -3988,14 +3988,7 @@ static void iselStmt ( ISelEnv* env, IRStmt* stmt ) addInstr(env, ARM64Instr_CAS(sz)); /* Now we have the lowest szB bytes of x1 are either equal to the lowest szB bytes of x5, indicating success, or they - aren't, indicating failure. The IR semantics actually - require us to return the old value at the location, - regardless of success or failure, but in the case of - failure it's not clear how to do this, since - ARM64Instr_CAS can't provide that. Instead we'll just - return the relevant bit of x1, since that's at least - guaranteed to be different from the lowest bits of x5 on - failure. */ + aren't, indicating failure. */ HReg rResult = hregARM64_X1(); switch (sz) { case 8: break; |