Macintosh-Tools/syn68k
1
0
Fork 0
mirror of https://github.com/ctm/syn68k.git synced 2024-11-29 03:50:27 +00:00
Code Issues Projects Releases Wiki Activity
9f31e73203
syn68k/test/tests.c

4106 lines
102 KiB
C
Raw Normal View History

Syn68k from an svn export
2008-09-26 14:25:10 +00:00
#include "syn68k_public.h"
#include "driver.h"
#include "setup.h"
#include <stdio.h>
#define TEST(f, cc_mask, size, changes_memory, max_calls) void f (uint16 *code)
#define MEM (US_TO_SYN68K (&mem[0]))
#define MEMEND (US_TO_SYN68K (&mem[MEM_SIZE - 1]))
#define MEMMID (US_TO_SYN68K (&mem[(MEM_SIZE) / 2]))
#define GNUC_LOSES_WITH_EXPONENTIAL_GROWTH
#ifdef GNUC_LOSES_WITH_EXPONENTIAL_GROWTH
static inline int
MASK (const char *s, int c)
{
int i, ret;
for (i = 0, ret = 0; i < 16; i++)
ret |= ((s[i] == c) << (15 - i));
return ret;
}
#else
#define MASK(s,c) (( (s[0 ] == (c)) << 15) | ((s[1 ] == (c)) << 14) \
| ((s[2 ] == (c)) << 13) | ((s[3 ] == (c)) << 12) \
| ((s[4 ] == (c)) << 11) | ((s[5 ] == (c)) << 10) \
| ((s[6 ] == (c)) << 9) | ((s[7 ] == (c)) << 8) \
| ((s[8 ] == (c)) << 7) | ((s[9 ] == (c)) << 6) \
| ((s[10] == (c)) << 5) | ((s[11] == (c)) << 4) \
| ((s[12] == (c)) << 3) | ((s[13] == (c)) << 2) \
| ((s[14] == (c)) << 1) | ((s[15] == (c))))
#endif
#define B(s) MASK(s, '1')
#define R(s) (B(s) | (MASK(s, 'r') & randint (0, 65535)))
#define NOP_OPCODE 0x4E71
#define RANDOM_SIZE() (randint (0, 2) << 6)
/* The WRITE4 macro does not write out values in big-endian! Rather, it
* writes out the words in big endian format and leaves the bytes within
* each word in whatever format. This is because we always byte swap
* words later, if appropriate.
*/
#define WRITE4(c,n) \
{ \
uint32 tmp = (n); \
code[c] = tmp >> 16; \
code[(c) + 1] = tmp; \
}
TEST (unpk_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1000rrr110000rrr");
code[1] = randnum ();
}
TEST (unpk_mem, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1000rrr110001rrr");
code[1] = randnum ();
}
TEST (unlk, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint8 *p;
for (p = mem; p < mem + MEM_SIZE; )
{
uint32 addr = randint (MEM + 50, MEMEND - 50) & ~1;
*p++ = addr >> 24;
*p++ = addr >> 16;
*p++ = addr >> 8;
*p++ = addr;
}
/* NOTE: "unlk a7" wedges my 68040 NeXT, so I am skipping that test here.
* "unlk a7" works on a 68030 NeXT, so it may be worth modifying this
* code to test that case when we run it on a non-68040 based machine.
*/
/* WARNING! Assumes that mem is aligned % 4 */
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 3);
code[0] = R ("0100111001011000") | randint (0, 6);
}
TEST (movewl_ind_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("001rrrr000000rrr") /* Randomly either word or long. */
| (randint (2, 4) << 6) /* Random amode [2, 4] */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (divsl_ll_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int divisor_reg = randint (0, 7);
do { EM_DREG (divisor_reg) = randnum ();} while (EM_DREG (divisor_reg) == 0);
code[0] = B ("0100110001000000") | divisor_reg;
code[1] = R ("0rrr1r0000000rrr");
}
TEST (divsl_ll_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = R ("0100110001000rrr") | (randint (2, 4) << 3);
code[1] = R ("0rrr1r0000000rrr");
}
TEST (divsl_ll_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = B ("0100110001111001");
code[1] = R ("0rrr1r0000000rrr");
WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (lea_pc_ind_preix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size = randint (2, 3), od_size = randint (1, 3);
int scale = randint (0, 3);
randomize_mem ();
randomize_regs (0, 15, 0, 8 >> scale, (4 >> scale) - 1);
/* Put out some initial NOPs */
for (i = 0; i < 4; i++)
code[i] = NOP_OPCODE; /* nop */
/* Output the main opcode. */
code[i] = R ("0100rrr111111011");
code[i + 1] = (R ("rrrrr0010r000000") | (scale << 9)
| (bd_size << 4) | od_size);
i += 2;
/* Output the base displacement. */
switch (bd_size) {
case 2:
code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
i++;
break;
case 3:
WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
i += 2;
break;
}
/* Output outer displacement (if any). */
switch (od_size) {
case 1:
break;
case 2:
code[i] = randint (-20, 20);
i++;
break;
case 3:
WRITE4 (i, randint (-20, 20));
i += 2;
break;
}
/* Skip over array of addresses. */
code[i] = 0x4EF9; /* jmp absl */
WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
for (i += 3; i < 49; i += 2)
WRITE4 (i, randint (MEM + 50, MEMEND - 50));
}
TEST (lea_pc_ind_postix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size = randint (2, 3), od_size = randint (1, 3);
int scale = randint (0, 3);
randomize_mem ();
randomize_regs (0, 15, -6, 6, 0);
/* Put out some initial NOPs */
for (i = 0; i < 4; i++)
code[i] = NOP_OPCODE; /* nop */
/* Output the main opcode. */
code[i] = R ("0100rrr111111011");
code[i + 1] = (R ("rrrrr0010r000100") | (scale << 9)
| (bd_size << 4) | od_size);
i += 2;
/* Output the base displacement. */
switch (bd_size) {
case 2:
code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
i++;
break;
case 3:
WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
i += 2;
break;
}
/* Output outer displacement (if any). */
switch (od_size) {
case 1:
break;
case 2:
code[i] = randint (-20, 20);
i++;
break;
case 3:
WRITE4 (i, randint (-20, 20));
i += 2;
break;
}
/* Skip over array of addresses. */
code[i] = 0x4EF9; /* jmp absl */
WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
for (i += 3; i < 49; i += 2)
WRITE4 (i, randint (MEM + 100, MEMEND - 100));
}
TEST (moveb_pc_ind_preix_dreg, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size = randint (2, 3), od_size = randint (1, 3);
int scale = randint (0, 3);
randomize_mem ();
randomize_regs (0, 15, 0, 8 >> scale, (4 >> scale) - 1);
/* Put out some initial NOPs */
for (i = 0; i < 4; i++)
code[i] = NOP_OPCODE; /* nop */
/* Output the main opcode. */
code[i] = R ("0001rrr000111011");
code[i + 1] = (R ("rrrrr0010r000000") | (scale << 9)
| (bd_size << 4) | od_size);
i += 2;
/* Output the base displacement. */
switch (bd_size) {
case 2:
code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
i++;
break;
case 3:
WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
i += 2;
break;
}
/* Output outer displacement (if any). */
switch (od_size) {
case 1:
break;
case 2:
code[i] = randint (-20, 20);
i++;
break;
case 3:
WRITE4 (i, randint (-20, 20));
i += 2;
break;
}
/* Skip over array of addresses. */
code[i] = 0x4EF9; /* jmp absl */
WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
for (i += 3; i < 49; i += 2)
WRITE4 (i, randint (MEM + 50, MEMEND - 50));
}
TEST (moveb_pc_ind_postix_dreg, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size = randint (2, 3), od_size = randint (1, 3);
int scale = randint (0, 3);
randomize_mem ();
randomize_regs (0, 15, -6, 6, 0);
/* Put out some initial NOPs */
for (i = 0; i < 4; i++)
code[i] = NOP_OPCODE; /* nop */
/* Output the main opcode. */
code[i] = R ("0001rrr000111011");
code[i + 1] = (R ("rrrrr0010r000100") | (scale << 9)
| (bd_size << 4) | od_size);
i += 2;
/* Output the base displacement. */
switch (bd_size) {
case 2:
code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
i++;
break;
case 3:
WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
i += 2;
break;
}
/* Output outer displacement (if any). */
switch (od_size) {
case 1:
break;
case 2:
code[i] = randint (-20, 20);
i++;
break;
case 3:
WRITE4 (i, randint (-20, 20));
i += 2;
break;
}
/* Skip over array of addresses. */
code[i] = 0x4EF9; /* jmp absl */
WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
for (i += 3; i < 49; i += 2)
WRITE4 (i, randint (MEM + 100, MEMEND - 100));
}
TEST (moveb_pcd16_dreg, ALL_CCS, 6, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = NOP_OPCODE; /* nop */
code[1] = NOP_OPCODE; /* nop */
code[2] = R ("0001rrr000111010");
code[3] = randint (-4, 4);
code[4] = NOP_OPCODE; /* nop */
code[5] = NOP_OPCODE; /* nop */
}
TEST (movewl_pcd16_dreg, ALL_CCS, 6, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = NOP_OPCODE; /* nop */
code[1] = NOP_OPCODE; /* nop */
code[2] = R ("001rrrr000111010");
code[3] = randint (-4, 4) & ~1;
code[4] = NOP_OPCODE; /* nop */
code[5] = NOP_OPCODE; /* nop */
}
TEST (moveb_pcd8_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int long_ix = randint (0, 1); /* Are we using a index reg as a long? */
randomize_mem ();
randomize_regs (0, 15, -2, 2, 0);
/* If we have a word sized index, blow away high word of all regs so
* that we know the high word is being properly ignored.
*/
if (!long_ix)
{
for (i = 0; i < 16; i++)
cpu_state.regs[i].ul.n = ((cpu_state.regs[i].ul.n & 0xFFFF)
| (randnum () << 16));
}
for (i = 0; i < 20; i++)
code[i] = NOP_OPCODE; /* nop */
code[i] = R ("0001rrr000111011");
code[i + 1] = (R ("rrrr0rr000000000") | (long_ix << 11)
| (randint (-4, 4) & 0xFF));
for (i += 2; i < 40; i++)
code[i] = NOP_OPCODE; /* nop */
}
TEST (movewl_pcd8_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
randomize_mem ();
randomize_regs (0, 15, -2, 2, 1);
for (i = 0; i < 20; i++)
code[i] = NOP_OPCODE; /* nop */
code[i] = R ("001rrrr000111011");
code[i + 1] = R ("rrrrrrr000000000") | (randint (-4, 4) & 0xFE);
for (i += 2; i < 40; i++)
code[i] = NOP_OPCODE; /* nop */
}
TEST (moveb_pc_ind_ix_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size = randint (1, 3);
randomize_mem ();
randomize_regs (0, 15, -2, 2, 0);
for (i = 0; i < 20; i++)
code[i] = NOP_OPCODE; /* nop */
code[i] = R ("0001rrr000111011");
code[i + 1] = R ("rrrrrrr10r000000") | (bd_size << 4);
switch (bd_size) {
case 1:
i += 2;
break;
case 2:
code[i + 2] = randint (-4, 4);
i += 3;
break;
case 3:
WRITE4 (i + 2, randint (-4, 4));
i += 4;
break;
}
for (; i < 40; i++)
code[i] = NOP_OPCODE; /* nop */
}
TEST (movewl_pc_ind_ix_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size = randint (1, 3);
randomize_mem ();
randomize_regs (0, 15, -2, 2, 1);
for (i = 0; i < 20; i++)
code[i] = NOP_OPCODE; /* nop */
code[i] = R ("001rrrr000111011");
code[i + 1] = R ("rrrrrrr10r000000") | (bd_size << 4);
switch (bd_size) {
case 1:
i += 2;
break;
case 2:
code[i + 2] = randint (-4, 4) & ~1;
i += 3;
break;
case 3:
WRITE4 (i + 2, randint (-4, 4) & ~1);
i += 4;
break;
}
for (; i < 40; i++)
code[i] = NOP_OPCODE; /* nop */
}
TEST (lea_ind_preix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size, od_size = randint (1, 3);
int scale = randint (0, 3);
int base_address_reg = randint (0, 7);
int base_suppress = randint (0, 1);
int ixreg_specifier;
randomize_mem ();
randomize_regs (0, 15, 0, 8 >> scale, (4 >> scale) - 1);
/* Put out some initial NOPs */
for (i = 0; i < 4; i++)
code[i] = NOP_OPCODE; /* nop */
/* Determine the index reg. Make sure it's not the same as our base reg. */
do
{
ixreg_specifier = randint (0, 15);
}
while ((ixreg_specifier & 8) && (ixreg_specifier & 7) == base_address_reg);
if (base_suppress)
bd_size = 3;
else
bd_size = randint (2, 3);
/* Output the main opcode. */
code[i] = R ("0100rrr111110000") | base_address_reg;
code[i + 1] = (R ("0000r0010r000000") | (ixreg_specifier << 12)
| (base_suppress << 7) | (scale << 9) | (bd_size << 4)
| od_size);
i += 2;
/* Put the address of a block of random memory into our base register. */
cpu_state.regs[8 + base_address_reg].ul.n
= randint (MEM + 32, MEM + 128) & ~1;
/* Output the base displacement. */
if (!base_suppress)
{
/* Since we aren't suppressing the base, make this a small offset. */
switch (bd_size) {
case 2:
code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
i++;
break;
case 3:
WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
i += 2;
break;
}
}
else /* base_suppress */
{
/* Since we're suppressing the base, we must make it larger and
* point directly to the base of the addresses in which we
* are interested.
*/
WRITE4 (i, MEM + 32 + (randint (0, 50) * 4));
i += 2;
}
/* Output outer displacement (if any). */
switch (od_size) {
case 1:
break;
case 2:
code[i] = randint (-20, 20);
i++;
break;
case 3:
WRITE4 (i, randint (-20, 20));
i += 2;
break;
}
/* Skip over array of addresses. */
code[i] = 0x4EF9; /* jmp absl */
WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
for (i += 3; i < 49; i += 2)
WRITE4 (i, randint (MEM + 50, MEMEND - 50));
}
TEST (lea_ind_postix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int i;
int bd_size, od_size = randint (1, 3);
int scale = randint (0, 3);
int base_address_reg = randint (0, 7);
int base_suppress = randint (0, 1);
int ixreg_specifier = randint (0, 15);
randomize_mem ();
randomize_regs (0, 15, -1024, 1024, 1);
/* Put out some initial NOPs */
for (i = 0; i < 4; i++)
code[i] = NOP_OPCODE; /* nop */
if (base_suppress)
bd_size = 3;
else
bd_size = randint (2, 3);
/* Output the main opcode. */
code[i] = R ("0100rrr111110000") | base_address_reg;
code[i + 1] = (R ("0000r0010r000100") | (ixreg_specifier << 12)
| (base_suppress << 7) | (scale << 9) | (bd_size << 4)
| od_size);
i += 2;
/* Put the address of a block of random memory into our base register. */
cpu_state.regs[8 + base_address_reg].ul.n
= randint (MEM + 32, MEMEND - 128) & ~1;
/* Output the base displacement. */
if (!base_suppress)
{
/* Since we aren't suppressing the base, make this a small offset. */
switch (bd_size) {
case 2:
code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
i++;
break;
case 3:
WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
i += 2;
break;
}
}
else /* base_suppress */
{
/* Since we're suppressing the base, we must make it larger and
* point directly to the base of the addresses in which we
* are interested.
*/
WRITE4 (i, MEM + 32 + (randint (0, 50) * 4));
i += 2;
}
/* Output outer displacement (if any). */
switch (od_size) {
case 1:
break;
case 2:
code[i] = randint (-20, 20);
i++;
break;
case 3:
WRITE4 (i, randint (-20, 20));
i += 2;
break;
}
/* Skip over array of addresses. */
code[i] = 0x4EF9; /* jmp absl */
WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
for (i += 3; i < 49; i += 2)
WRITE4 (i, randint (MEM + 50, MEMEND - 50));
}
TEST (add_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("1101rrr000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 8, MEMEND - 8) & ~1);
}
TEST (abcd_reg, C_BIT | Z_BIT | X_BIT, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1100rrr100000rrr");
}
TEST (abcd_mem, C_BIT | Z_BIT | X_BIT, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1100rrr100001rrr");
}
TEST (addb_dreg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr000000rrr");
}
TEST (addw_reg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr00100rrrr");
}
TEST (addl_reg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr01000rrrr");
}
TEST (add_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1101rrr000101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (addb_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr000111100");
code[1] = randint (0, 65535);
}
TEST (addw_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr001111100");
code[1] = randint (0, 65535);
}
TEST (add_dreg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1101rrr100000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (add_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1101rrr000000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (addl_const_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1101rrr010111100");
WRITE4 (1, randnum ());
}
TEST (add_dreg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1101rrr100101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (add_dreg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1101rrr100111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (addaw_reg_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr01100rrrr");
}
TEST (addal_reg_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr11100rrrr");
}
TEST (adda_ind_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1101rrrr11000rrr") /* Random size. */
| (randint (2, 4) << 3)); /* Random amode [2, 4]; */
}
TEST (adda_d16_areg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1101rrrr11101rrr"); /* Random size. */
code[1] = randint (-290, 290) & ~1;
}
TEST (adda_absl_areg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1101rrrr11111001"); /* Random size. */
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (addaw_const_areg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr011111100");
code[1] = randint (0, 65535);
}
TEST (addal_const_areg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr111111100");
code[1] = randint (0, 65535);
code[2] = randint (0, 65535);
}
TEST (addibw_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000001100r000rrr"); /* Randomly either byte or word */
code[1] = randnum ();
}
TEST (addil_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000011010000rrr");
WRITE4 (1, randnum ());
}
TEST (addibw_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("000001100r000rrr") /* Randomly either byte or word. */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
code[1] = randnum ();
}
TEST (addil_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0000011010000rrr")
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
WRITE4 (1, randnum ());
}
TEST (addibw_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000001100r101rrr"); /* Randomly either byte or word. */
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (addil_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000011010101rrr");
WRITE4 (1, randnum ());
code[3] = randint (-290, 290) & ~1;
}
TEST (addibw_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000001100r111001"); /* Randomly either byte or word. */
code[1] = randnum ();
WRITE4 (2, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (addil_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000011010111001"); /* Randomly either byte or word. */
WRITE4 (1, randnum ());
WRITE4 (3, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (addq_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrr000000rrr") | RANDOM_SIZE ();
}
TEST (addq_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrr000001rrr") | (randint (1, 2) << 6); /* word or long */
}
TEST (addq_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0101rrr000000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3)); /* random amode [2, 4] */
}
TEST (addq_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0101rrr000101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (addq_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrr000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (addx_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1101rrr100000rrr") | RANDOM_SIZE ();
}
TEST (addx_mem, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1101rrr100001rrr") | RANDOM_SIZE ();
}
TEST (and_dreg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1100rrr000000rrr") | RANDOM_SIZE ();
}
TEST (and_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1100rrr000000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3));
}
TEST (and_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1100rrr000101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (and_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("1100rrr000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (andbw_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1100rrr00r111100"); /* randomly byte or word */
code[1] = randnum ();
}
TEST (andl_const_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1100rrr010111100");
WRITE4 (1, randnum ());
}
TEST (and_dreg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1100rrr100000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3));
}
TEST (and_dreg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1100rrr100101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (and_dreg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1100rrr100111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (andibw_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000000100r000rrr");
code[1] = randnum ();
}
TEST (andil_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000001010000rrr");
WRITE4 (1, randnum ());
}
TEST (andibw_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000000100r000rrr") | (randint (2, 4) << 3);
code[1] = randnum ();
}
TEST (andil_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000001010000rrr") | (randint (2, 4) << 3);
WRITE4 (1, randnum ());
}
TEST (andibw_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000000100r101rrr"); /* randomly either byte or word. */
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (andil_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000001010101rrr");
WRITE4 (1, randnum ());
code[3] = randint (-290, 290) & ~1;
}
TEST (andibw_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000000100r111001");
code[1] = randnum ();
WRITE4 (2, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (andil_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0000001010111001");
WRITE4 (1, randnum ());
WRITE4 (3, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (andi_to_ccr, ALL_CCS, 2, WONT_CHANGE_MEMORY, 32)
{
code[0] = B ("0000001000111100");
code[1] = times_called;
}
TEST (asl_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100100rrr") | RANDOM_SIZE ();
}
TEST (asl_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100000rrr") | RANDOM_SIZE ();
}
TEST (asl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110000111000rrr") | (randint (2, 4) << 3);
}
TEST (asl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110000111101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (asl_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110000111111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (asr_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000100rrr") | RANDOM_SIZE ();
}
TEST (asr_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000000rrr") | RANDOM_SIZE ();
}
TEST (asr_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110000011000rrr") | (randint (2, 4) << 3);
}
TEST (asr_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110000011101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (asr_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110000011111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (lsl_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100101rrr") | RANDOM_SIZE ();
}
TEST (lsl_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100001rrr") | RANDOM_SIZE ();
}
TEST (lsl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110001111000rrr") | (randint (2, 4) << 3);
}
TEST (lsl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110001111101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (lsl_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110001111111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (lsr_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000101rrr") | RANDOM_SIZE ();
}
TEST (lsr_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000001rrr") | RANDOM_SIZE ();
}
TEST (lsr_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110001011000rrr") | (randint (2, 4) << 3);
}
TEST (lsr_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110001011101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (lsr_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110001011111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
#define BCC_TEST_B(bits) \
code[0] = 0x6004 | ((bits) << 8); /* b?? * + 4 */ \
code[1] = B ("0111000000000000"); /* moveq #0,d0 */ \
code[2] = 0x6002; /* bra * + 2 */ \
code[3] = B ("0111000000000001"); /* moveq #1,d0 */ \
code[4] = NOP_OPCODE /* nop */
TEST (bra_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x0); }
/* 0x1 is reserved for bsr */
TEST (bhi_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x2); }
TEST (bls_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x3); }
TEST (bcc_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x4); }
TEST (bcs_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x5); }
TEST (bne_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x6); }
TEST (beq_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x7); }
TEST (bvc_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x8); }
TEST (bvs_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x9); }
TEST (bpl_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xA); }
TEST (bmi_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xB); }
TEST (bge_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xC); }
TEST (blt_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xD); }
TEST (bgt_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xE); }
TEST (ble_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xF); }
#undef BCC_TEST_B
#define BCC_TEST_W(bits) \
code[0] = 0x6000 | ((bits) << 8); /* b?? * + 8 */ \
code[1] = 0x0006; /* (offset) */ \
code[2] = B ("0111000000000000"); /* moveq #0,d0 */ \
code[3] = 0x6002; /* bra * + 2 */ \
code[4] = B ("0111000000000001"); /* moveq #1,d0 */ \
code[5] = NOP_OPCODE /* nop */
TEST (bra_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x0); }
/* 0x1 is reserved for bsr */
TEST (bhi_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x2); }
TEST (bls_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x3); }
TEST (bcc_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x4); }
TEST (bcs_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x5); }
TEST (bne_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x6); }
TEST (beq_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x7); }
TEST (bvc_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x8); }
TEST (bvs_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x9); }
TEST (bpl_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xA); }
TEST (bmi_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xB); }
TEST (bge_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xC); }
TEST (blt_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xD); }
TEST (bgt_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xE); }
TEST (ble_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xF); }
#undef BCC_TEST_W
#define BCC_TEST_L(bits) \
code[0] = 0x60FF | ((bits) << 8); /* b?? * + 8 */ \
code[1] = 0x0000; /* (offset hi) */ \
code[2] = 0x0008; /* (offset lo) */ \
code[3] = B ("0111000000000000"); /* moveq #0,d0 */ \
code[4] = 0x6002; /* bra * + 2 */ \
code[5] = B ("0111000000000001"); /* moveq #1,d0 */ \
code[6] = NOP_OPCODE /* nop */
TEST (bra_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x0); }
/* 0x1 is reserved for bsr */
TEST (bhi_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x2); }
TEST (bls_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x3); }
TEST (bcc_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x4); }
TEST (bcs_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x5); }
TEST (bne_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x6); }
TEST (beq_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x7); }
TEST (bvc_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x8); }
TEST (bvs_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x9); }
TEST (bpl_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xA); }
TEST (bmi_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xB); }
TEST (bge_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xC); }
TEST (blt_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xD); }
TEST (bgt_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xE); }
TEST (ble_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xF); }
#undef BCC_TEST_L
TEST (bchg_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000rrr101000rrr");
}
TEST (bchg_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000100001000rrr");
code[1] = randint (0, 65535);
}
TEST (bchg_reg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000rrr101000rrr") | (randint (2, 4) << 3);
}
TEST (bchg_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000100001000rrr") | (randint (2, 4) << 3);
code[1] = randint (0, 65535);
}
TEST (bchg_reg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000rrr101101rrr");
code[1] = randint (-290, 290);
}
TEST (bchg_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000100001101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-290, 290);
}
TEST (bchg_reg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000rrr101111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4));
}
TEST (bchg_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000100001111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 4, MEMEND - 4));
}
TEST (bclr_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000rrr110000rrr");
}
TEST (bclr_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000100010000rrr");
code[1] = randint (0, 65535);
}
TEST (bclr_reg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000rrr110000rrr") | (randint (2, 4) << 3);
}
TEST (bclr_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000100010000rrr") | (randint (2, 4) << 3);
code[1] = randint (0, 65535);
}
TEST (bclr_reg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000rrr110101rrr");
code[1] = randint (-290, 290);
}
TEST (bclr_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000100010101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-290, 290);
}
TEST (bclr_reg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000rrr110111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4));
}
TEST (bclr_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000100010111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 4, MEMEND - 4));
}
TEST (bset_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000rrr111000rrr");
}
TEST (bset_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000100011000rrr");
code[1] = randint (0, 65535);
}
TEST (bset_reg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000rrr111000rrr") | (randint (2, 4) << 3);
}
TEST (bset_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000100011000rrr") | (randint (2, 4) << 3);
code[1] = randint (0, 65535);
}
TEST (bset_reg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000rrr111101rrr");
code[1] = randint (-290, 290);
}
TEST (bset_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000100011101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-290, 290);
}
TEST (bset_reg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000rrr111111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4));
}
TEST (bset_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000100011111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 4, MEMEND - 4));
}
TEST (btst_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000rrr100000rrr");
}
TEST (btst_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000100000000rrr");
code[1] = randint (0, 65535);
}
TEST (btst_reg_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000rrr100000rrr") | (randint (2, 4) << 3);
}
TEST (btst_const_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0000100000000rrr") | (randint (2, 4) << 3);
code[1] = randint (0, 65535);
}
TEST (btst_reg_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000rrr100101rrr");
code[1] = randint (-290, 290);
}
TEST (btst_const_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000100000101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-290, 290);
}
TEST (btst_reg_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("0000rrr100111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4));
}
TEST (btst_const_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = B ("0000100000111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 4, MEMEND - 4));
}
TEST (bfchg_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110101011000rrr");
code[1] = randint (0, 65535);
}
TEST (bfchg_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110101011010rrr");
code[1] = randint (0, 65535);
}
TEST (bfchg_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110101011101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bfchg_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
code[0] = B ("1110101011111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bfclr_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110110011000rrr");
code[1] = randint (0, 65535);
}
TEST (bfclr_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110110011010rrr");
code[1] = randint (0, 65535);
}
TEST (bfclr_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110110011101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bfclr_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
code[0] = B ("1110110011111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bfset_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110111011000rrr");
code[1] = randint (0, 65535);
}
TEST (bfset_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110111011010rrr");
code[1] = randint (0, 65535);
}
TEST (bfset_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110111011101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bfset_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
code[0] = B ("1110111011111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bftst_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110100011000rrr");
code[1] = randint (0, 65535);
}
TEST (bftst_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110100011010rrr");
code[1] = randint (0, 65535);
}
TEST (bftst_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110100011101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bftst_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
code[0] = B ("1110100011111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bfexts_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110101111000rrr");
code[1] = randint (0, 65535);
}
TEST (bfexts_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110101111010rrr");
code[1] = randint (0, 65535);
}
TEST (bfexts_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110101111101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bfexts_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
code[0] = B ("1110101111111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bfextu_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110100111000rrr");
code[1] = randint (0, 65535);
}
TEST (bfextu_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110100111010rrr");
code[1] = randint (0, 65535);
}
TEST (bfextu_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110100111101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bfextu_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
code[0] = B ("1110100111111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bfffo_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110110111000rrr");
code[1] = randint (0, 65535);
}
TEST (bfffo_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110110111010rrr");
code[1] = randint (0, 65535);
}
TEST (bfffo_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110110111101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bfffo_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_mem ();
code[0] = B ("1110110111111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bfins_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110111111000rrr");
code[1] = randint (0, 65535);
}
TEST (bfins_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -250 * 8, 250 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110111111010rrr");
code[1] = randint (0, 65535);
}
TEST (bfins_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
code[0] = R ("1110111111101rrr");
code[1] = randint (0, 65535);
code[2] = randint (-130, 130);
}
TEST (bfins_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7, -130 * 8, 130 * 8, 0); /* Offset/width */
code[0] = B ("1110111111111001");
code[1] = randint (0, 65535);
WRITE4 (2, randint (MEM + 200, MEMEND - 200));
}
TEST (bsr_b, ALL_CCS, 6, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (15, 15, MEM + 50, MEMEND - 50, 1); /* random sp */
code[0] = 0x6104; /* bsr * + 4 */
code[1] = 0x5280; /* addql #1,d0 */
code[2] = 0x6004; /* bra * + 4 */
code[3] = R ("01110000rrrrrrrr"); /* moveq #<random>,d0 */
code[4] = 0x4E75; /* rts */
code[5] = NOP_OPCODE; /* nop */
}
TEST (bsr_w, ALL_CCS, 7, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (15, 15, MEM + 50, MEMEND - 50, 1); /* random sp */
code[0] = 0x6100; /* bsr * + 6 */
code[1] = 0x0006;
code[2] = 0x5280; /* addql #1,d0 */
code[3] = 0x6004; /* bra * + 4 */
code[4] = R ("01110000rrrrrrrr"); /* moveq #<random>,d0 */
code[5] = 0x4E75; /* rts */
code[6] = NOP_OPCODE; /* nop */
}
TEST (bsr_l, ALL_CCS, 8, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (15, 15, MEM + 50, MEMEND - 50, 1); /* random sp */
code[0] = 0x61FF; /* bsr * + 8 */
code[1] = 0x0000;
code[2] = 0x0008;
code[3] = 0x5280; /* addql #1,d0 */
code[4] = 0x6004; /* bra * + 4 */
code[5] = R ("01110000rrrrrrrr"); /* moveq #<random>,d0 */
code[6] = 0x4E75; /* rts */
code[7] = NOP_OPCODE; /* nop */
}
TEST (cas_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0000100011000rrr")
| (randint (1, 3) << 9) /* Random size */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
code[1] = randint (0, 65535);
}
TEST (cas2_areg, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 1);
code[0] = R ("000011r011111100"); /* Randomly either word or long. */
code[1] = R ("1rrr000rrr000rrr");
code[2] = R ("1rrr000rrr000rrr");
}
TEST (cas2_anyreg, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (0, 7 + 8, MEM + 50, MEMEND - 50, 1);
code[0] = R ("000011r011111100"); /* Randomly either word or long. */
code[1] = R ("rrrr000rrr000rrr");
code[2] = R ("rrrr000rrr000rrr");
}
TEST (clr_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100001000000rrr") | RANDOM_SIZE ();
}
TEST (clrb_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0100001000000rrr") | (randint (2, 4) << 3);
}
TEST (clrwl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0100001000000rrr")
| (randint (1, 2) << 6) /* Randomly either word or long. */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (clrb_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0100001000111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (clrwl_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0100001000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (cmp_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1011rrr000000rrr") | RANDOM_SIZE ();
}
TEST (cmp_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1011rrr000001rrr") | RANDOM_SIZE ();
}
TEST (cmpb_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1011rrr000000rrr") | (randint (2, 4) << 3);
}
TEST (cmpwl_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1011rrr000000rrr")
| (randint (1, 2) << 6) /* Randomly either word or long. */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (cmpb_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("1011rrr000101rrr");
code[1] = randint (-250, 250);
}
TEST (cmpwl_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1011rrr000101rrr") | (randint (1, 2) << 6);
code[1] = randint (-250, 250) & ~1;
}
TEST (cmpa_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1011rrrr1100rrrr");
}
TEST (cmpa_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1011rrrr11000rrr") | (randint (2, 4) << 3);
}
/* This compares an arbitrary value in a0 vs. memory indirected through
* some odd register, as opposed to comparing a legitimate address with memory.
*/
TEST (cmpa_ind2, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (9, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1011000r11000rr1") | (randint (2, 4) << 3);
}
TEST (cmpa_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1011rrrr11101rrr");
code[1] = randint (-250, 250) & ~1;
}
/* This compares an arbitrary value in a0 vs. memory indirected through
* some odd register, as opposed to comparing a legitimate address with memory.
*/
TEST (cmpa_d16_2, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (9, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1011000r11101rr1");
code[1] = randint (-250, 250) & ~1;
}
TEST (cmpa_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("1011rrrr11111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (cmpibw_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000011000r000rrr"); /* Randomly either byte or word. */
code[1] = randnum ();
}
TEST (cmpil_reg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000110010000rrr");
WRITE4 (1, randnum ());
}
TEST (cmpib_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
randomize_mem ();
code[0] = R ("0000110000000rrr") | (randint (2, 4) << 3);
code[1] = randnum ();
}
TEST (cmpiw_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
randomize_mem ();
code[0] = R ("0000110001000rrr") | (randint (2, 4) << 3);
code[1] = randnum ();
}
TEST (cmpil_ind, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
randomize_mem ();
code[0] = R ("0000110010000rrr") | (randint (2, 4) << 3);
WRITE4 (1, randnum ());
}
TEST (cmpmb, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1011rrr100001rrr");
}
TEST (cmpmwl, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1011rrr100001rrr") | (randint (1, 2) << 6); /* Word or long */
}
TEST (cmp2b_ind, X_BIT | Z_BIT | C_BIT, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
randomize_mem ();
code[0] = R ("0000000011010rrr");
code[1] = randint (0, 15) << 12;
}
TEST (cmp2wl_ind, X_BIT | Z_BIT | C_BIT, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
randomize_mem ();
code[0] = R ("0000000011010rrr") | (randint (1, 2) << 9);
code[1] = randint (0, 15) << 12;
}
TEST (dbcc, ALL_CCS, 3, WONT_CHANGE_MEMORY, 16)
{
code[0] = 0x5480; /* addql #2,d0 */
code[1] = (R ("0101000011001000") /* dbra *-4 */
| randint (1, 7)
| ((times_called & 0xF) << 8));
code[2] = -4;
}
/* NOTE! All div's are special cased in the test driver so that if the V bit
* is set by the real CPU, the N and Z bits are ignored.
*/
TEST (divs_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1, r2;
r1 = randint (0, 7);
r2 = (r1 + randint (1, 7)) & 7;
EM_DREG (r1) = randnum ();
do { EM_DREG (r2) = randnum (); } while (cpu_state.regs[r2].uw.n == 0);
code[0] = B ("1000000111000000") | (r1 << 9) | r2;
}
TEST (divs_same_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1;
r1 = randint (0, 7);
do { EM_DREG (r1) = randnum (); } while (cpu_state.regs[r1].uw.n == 0);
code[0] = B ("1000000111000000") | (r1 << 9) | r1;
}
TEST (divs_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = R ("1000rrr111000rrr") | (randint (2, 4) << 3);
}
TEST (divs_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = R ("1000rrr111111001") | (randint (2, 4) << 3);
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (divu_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1, r2;
r1 = randint (0, 7);
r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
EM_DREG (r1) = randnum ();
do { EM_DREG (r2) = randnum (); } while (cpu_state.regs[r2].uw.n == 0);
code[0] = B ("1000000011000000") | (r1 << 9) | r2;
}
TEST (divu_same_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1;
r1 = randint (0, 7);
do { EM_DREG (r1) = randnum (); } while (cpu_state.regs[r1].uw.n == 0);
code[0] = B ("1000000011000000") | (r1 << 9) | r1;
}
TEST (divu_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = R ("1000rrr011000rrr") | (randint (2, 4) << 3);
}
TEST (divu_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = R ("1000rrr011111001") | (randint (2, 4) << 3);
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (divul_ll_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int divisor_reg = randint (0, 7);
do
{
EM_DREG (divisor_reg) = randnum ();
}
while (EM_DREG (divisor_reg) == 0);
code[0] = B ("0100110001000000") | divisor_reg;
code[1] = R ("0rrr0r0000000rrr");
}
TEST (divul_ll_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = R ("0100110001000rrr") | (randint (2, 4) << 3);
code[1] = R ("0rrr0r0000000rrr");
}
TEST (divul_ll_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint16 *p;
int i;
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
*p++ = SWAPUW_IFLE (randint (1, 65535));
code[0] = B ("0100110001111001");
code[1] = R ("0rrr0r0000000rrr");
WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (eor_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1011rrr100000rrr") | RANDOM_SIZE ();
}
TEST (eor_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1011rrr100000rrr")
| RANDOM_SIZE ()
| randint (2, 4) << 3);
}
TEST (eor_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1011rrr100101rrr") | RANDOM_SIZE ();
code[1] = randint (-250, 250) & ~1;
}
TEST (eor_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1011rrr100111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (eoribw_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000010100r000rrr");
code[1] = randnum ();
}
TEST (eoril_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000101010000rrr");
WRITE4 (1, randnum ());
}
TEST (eoribw_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000010100r000rrr") | (randint (2, 4) << 3);
code[1] = randnum ();
}
TEST (eoril_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000101010000rrr") | (randint (2, 4) << 3);
WRITE4 (1, randnum ());
}
TEST (eoribw_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000010100r101rrr"); /* randomly either byte or word. */
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (eoril_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000101010101rrr");
WRITE4 (1, randnum ());
code[3] = randint (-290, 290) & ~1;
}
TEST (eoribw_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000010100r111001");
code[1] = randnum ();
WRITE4 (2, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (eoril_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0000101010111001");
WRITE4 (1, randnum ());
WRITE4 (3, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (eori_to_ccr, ALL_CCS, 2, WONT_CHANGE_MEMORY, 32)
{
code[0] = B ("0000101000111100");
code[1] = times_called;
}
TEST (exg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
static int mode[] = { 8, 9, 17 };
code[0] = R ("1100rrr100000rrr") | (mode[randint (0, 2)] << 3);
}
TEST (ext, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
static int mode[] = { 2, 3, 7 };
code[0] = R ("0100100000000rrr") | (mode[randint (0, 2)] << 6);
}
TEST (jmp_absl, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2)
{
code[0] = B ("0100111011111001");
WRITE4 (1, US_TO_SYN68K (&code[4]));
code[3] = 0x5480; /* addql #2,d0 */
code[4] = 0x5480; /* addql #2,d0 */
}
TEST (jmp_ind, ALL_CCS, 3, WONT_CHANGE_MEMORY, 8)
{
EM_AREG (times_called & 7) = US_TO_SYN68K (&code[2]);
code[0] = B ("0100111011010000") | (times_called & 7);
code[1] = 0x5480; /* addql #2,d0 */
code[2] = 0x5480; /* addql #2,d0 */
}
TEST (jmp_d16, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
EM_AREG (times_called & 7) = randint (US_TO_SYN68K (&code[3] - 100),
US_TO_SYN68K (&code[3] + 100)) & ~1;
code[0] = B ("0100111011101000") | (times_called & 7);
code[1] = US_TO_SYN68K (&code[3]) - EM_AREG (times_called & 7);
code[2] = 0x5480; /* addql #2,d0 */
code[3] = 0x5480; /* addql #2,d0 */
}
TEST (jsr_absl, ALL_CCS, 7, MIGHT_CHANGE_MEMORY, 2)
{
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = B ("0100111010111001");
WRITE4 (1, US_TO_SYN68K (&code[6]));
code[3] = 0x5480; /* addql #2,d0 */
code[4] = 0x5480; /* addql #2,d0 */
code[5] = 0x6002; /* bra *+2 */
code[6] = 0x4E75; /* rts */
}
TEST (jsr_ind, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, 8)
{
EM_AREG (times_called % 7) = US_TO_SYN68K (&code[4]);
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = B ("0100111010010000") | (times_called % 7);
code[1] = 0x5480; /* addql #2,d0 */
code[2] = 0x5480; /* addql #2,d0 */
code[3] = 0x6002; /* bra *+2 */
code[4] = 0x4E75; /* rts */
}
TEST (jsr_d16, ALL_CCS, 6, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
EM_AREG (times_called % 7) = randint (US_TO_SYN68K (&code[5] - 100),
US_TO_SYN68K (&code[5] + 100)) & ~1;
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = B ("0100111010101000") | (times_called % 7);
code[1] = US_TO_SYN68K (&code[5]) - EM_AREG (times_called % 7);
code[2] = 0x5480; /* addql #2,d0 */
code[3] = 0x5480; /* addql #2,d0 */
code[4] = 0x6002; /* bra *+2 */
code[5] = 0x4E75; /* rts */
}
TEST (lea_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100rrr111010rrr");
}
TEST (lea_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100rrr111101rrr");
code[1] = randnum ();
}
TEST (lea_absw, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100rrr111111000");
code[1] = randnum ();
}
TEST (lea_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100rrr111111001");
WRITE4 (1, randnum ());
}
TEST (linkw, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = R ("0100111001010rrr");
code[1] = randnum ();
}
TEST (linkl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = R ("0100100000001rrr");
WRITE4 (1, randnum ());
}
TEST (move16_postinc_postinc, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1111011000100rrr");
code[1] = R ("1rrr000000000000");
}
TEST (move16_absl_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1111011000011rrr");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (move16_absl_postinc, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1111011000001rrr");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (move16_ind_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1111011000010rrr");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (move16_postinc_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1111011000000rrr");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (moveb_dreg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0001rrr000000rrr");
}
TEST (movewl_reg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("001rrrr00000rrrr"); /* Randomly either word or long. */
}
TEST (moveb_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = (R ("0001rrr000000rrr")
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (movewl_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("001rrrr000000rrr") /* Randomly word or long. */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (moveb_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001rrr000101rrr");
code[1] = randint (-290, 290);
}
TEST (movewl_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001rrrr000101rrr"); /* Randomly either word or long. */
code[1] = randint (-290, 290) & ~1;
}
TEST (moveb_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("0001rrr000111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (movewl_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("001rrrr000111001"); /* Randomly either word or long. */
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (movebw_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("00r1rrr000111100"); /* Randomly either byte or word. */
code[1] = randnum ();
}
TEST (movel_const_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0010rrr000111100");
WRITE4 (1, randnum ());
}
TEST (moveb_dreg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = (R ("0001rrr000000rrr")
| (randint (2, 4) << 6)); /* Random amode [2, 4] */
}
TEST (movewl_reg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("001rrrr00000rrrr") /* Randomly word or long. */
| (randint (2, 4) << 6)); /* Random amode [2, 4] */
}
TEST (moveb_dreg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001rrr101000rrr");
code[1] = randint (-290, 290);
}
TEST (movewl_reg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001rrrr10100rrrr"); /* Randomly either word or long. */
code[1] = randint (-290, 290) & ~1;
}
TEST (moveb_dreg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0001001111000rrr");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (movewl_reg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("001r00111100rrrr"); /* Randomly either word or long. */
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (moveb_ind_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = (R ("0001rrr000000rrr")
| (randint (2, 4) << 6)
| (randint (2, 4) << 3));
}
TEST (moveb_ind_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001rrr101000rrr") | (randint (2, 4) << 3);
code[1] = randint (-290, 290);
}
TEST (moveb_d16_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001rrr000101rrr") | (randint (2, 4) << 6);
code[1] = randint (-290, 290);
}
TEST (movewl_ind_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001rrrr101000rrr") | (randint (2, 4) << 3);
code[1] = randint (-290, 290) & ~1;
}
TEST (movewl_d16_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001rrrr000101rrr") | (randint (2, 4) << 6);
code[1] = randint (-290, 290) & ~1;
}
TEST (moveb_d16_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001rrr101101rrr");
code[1] = randint (-290, 290);
code[2] = randint (-290, 290);
}
TEST (movewl_d16_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001rrrr101101rrr");
code[1] = randint (-290, 290) & ~1;
code[2] = randint (-290, 290) & ~1;
}
TEST (moveb_ind_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0001001111000rrr") | (randint (2, 4) << 3);
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (movewl_ind_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("001r001111000rrr") | (randint (2, 4) << 3);
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (moveb_absl_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0001rrr000111001") | (randint (2, 4) << 6);
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (movewl_absl_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("001rrrr000111001") | (randint (2, 4) << 6);
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (moveb_absl_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0001001111111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
WRITE4 (3, randint (MEM + 50, MEMEND - 50));
}
TEST (movewl_absl_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("001r001111111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
WRITE4 (3, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (moveb_d16_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001001111101rrr");
code[1] = randint (-290, 290);
WRITE4 (2, randint (MEM + 50, MEMEND - 50));
}
TEST (movewl_d16_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001r001111101rrr");
code[1] = randint (-290, 290) & ~1;
WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (moveb_absl_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001rrr101111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
code[3] = randint (-290, 290);
}
TEST (movewl_absl_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001rrrr101111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
code[3] = randint (-290, 290) & ~1;
}
TEST (moveb_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0001rrr000111100") | (randint (2, 4) << 6);
code[1] = randnum ();
}
TEST (moveb_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0001rrr101111100");
code[1] = randnum ();
code[2] = randint (-290, 290);
}
TEST (moveb_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0001001111111100");
code[1] = randnum ();
WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (movew_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("0011rrr000111100") | (randint (2, 4) << 6);
code[1] = randnum ();
}
TEST (movew_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0011rrr101111100");
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (movew_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0011001111111100");
code[1] = randnum ();
WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (movel_const_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("0010rrr000111100") | (randint (2, 4) << 6);
WRITE4 (1, randnum ());
}
TEST (movel_const_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0010rrr101111100");
WRITE4 (1, randnum ());
code[3] = randint (-290, 290) & ~1;
}
TEST (movel_const_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0010001111111100");
WRITE4 (1, randnum ());
WRITE4 (3, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (movea_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("001rrrr00100rrrr");
}
TEST (movea_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("001rrrr001000rrr") | (randint (2, 4) << 3);
}
TEST (movea_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("001rrrr001101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (movea_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("001rrrr001111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (moveaw_const, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0011rrr001111100");
code[1] = randnum ();
}
TEST (moveal_const, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0010rrr001111100");
WRITE4 (1, randnum ());
}
TEST (move_from_ccr_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100001011000rrr");
}
TEST (move_from_ccr_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("0100001011000rrr") | (randint (2, 4) << 3);
}
TEST (move_from_ccr_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0100001011101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (move_to_ccr_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100010011000rrr");
}
TEST (move_to_ccr_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("0100010011000rrr") | (randint (2, 4) << 3);
}
TEST (movem_to_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
int indreg = randint (0, 7);
EM_AREG (indreg) = randint (MEM + 100, MEMEND - 100) & ~1;
code[0] = R ("010010001r010000") | indreg;
code[1] = randnum ();
}
TEST (movem_to_predec, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
int indreg = randint (0, 7);
EM_AREG (indreg) = randint (MEM + 100, MEMEND - 100) & ~1;
code[0] = R ("010010001r100000") | indreg;
code[1] = randnum ();
}
TEST (movem_to_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
int indreg = randint (0, 7);
EM_AREG (indreg) = randint (MEM + 500, MEMEND - 500) & ~1;
code[0] = R ("010010001r101000") | indreg;
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (movem_to_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("010010001r111001");
code[1] = randnum ();
WRITE4 (2, randint (MEM + 100, MEMEND - 100) & ~1);
}
TEST (movem_from_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int indreg = randint (0, 7);
randomize_mem ();
EM_AREG (indreg) = randint (MEM + 500, MEMEND - 500) & ~1;
code[0] = R ("010011001r101000") | indreg;
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (movem_from_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int indreg = randint (0, 7);
randomize_mem ();
EM_AREG (indreg) = randint (MEM + 100, MEMEND - 100) & ~1;
code[0] = R ("010011001r01r000") | indreg; /* Randomly an@ or an@+ */
code[1] = randnum ();
}
TEST (movem_from_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("010011001r111001");
code[1] = randnum ();
WRITE4 (2, randint (MEM + 100, MEMEND - 100) & ~1);
}
TEST (movep_to_mem, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000rrr11r001rrr");
code[1] = randint (-290, 290);
}
TEST (movep_from_mem, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0000rrr10r001rrr");
code[1] = randint (-290, 290);
}
TEST (moveq, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0111rrr0rrrrrrrr");
}
TEST (mulsw_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1100rrr111000rrr");
}
TEST (mulsw_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1100rrr111000rrr") | (randint (2, 4) << 3);
}
TEST (mulsw_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1100rrr111101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (mulsw_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("1100rrr111111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (muluw_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1100rrr011000rrr");
}
TEST (muluw_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1100rrr011000rrr") | (randint (2, 4) << 3);
}
TEST (muluw_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1100rrr011101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (muluw_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("1100rrr011111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (mulsl_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
code[0] = R ("0100110000000rrr");
code[1] = R ("00001r0000000000") | (r1 << 12) | r2;
}
TEST (mulsl_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("0100110000000rrr") | (randint (2, 4) << 3);
code[1] = R ("00001r0000000000") | (r1 << 12) | r2;
}
TEST (mulsl_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0100110000101rrr");
code[1] = R ("00001r0000000000") | (r1 << 12) | r2;
code[2] = randint (-290, 290) & ~1;
}
TEST (mulsl_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
randomize_mem ();
code[0] = B ("0100110000111001");
code[1] = R ("00001r0000000000") | (r1 << 12) | r2;
WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (mulul_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
code[0] = R ("0100110000000rrr");
code[1] = R ("00000r0000000000") | (r1 << 12) | r2;
}
TEST (mulul_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("0100110000000rrr") | (randint (2, 4) << 3);
code[1] = R ("00000r0000000000") | (r1 << 12) | r2;
}
TEST (mulul_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0100110000101rrr");
code[1] = R ("00000r0000000000") | (r1 << 12) | r2;
code[2] = randint (-290, 290) & ~1;
}
TEST (mulul_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
{
int r1 = randint (0, 7);
int r2 = (r1 + randint (1, 7)) & 7; /* Assure r1 != r2 */
randomize_mem ();
code[0] = R ("0100110000111001");
code[1] = R ("00000r0000000000") | (r1 << 12) | r2;
WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (nbcd_reg, X_BIT | Z_BIT | C_BIT, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100100000000rrr");
}
TEST (nbcd_ind, X_BIT | Z_BIT | C_BIT, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0100100000000rrr") | (randint (2, 4) << 3);
}
TEST (nbcd_d16, X_BIT | Z_BIT | C_BIT, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0100100000101rrr");
code[1] = randint (-290, 290);
}
TEST (nbcd_absl, X_BIT | Z_BIT | C_BIT, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0100100000111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (neg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100010000000rrr") | RANDOM_SIZE ();
}
TEST (negb_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0100010000000rrr") | (randint (2, 4) << 3);
}
TEST (negwl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0100010000000rrr")
| (randint (2, 4) << 3)
| (randint (1, 2) << 6));
}
TEST (negb_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0100010000101rrr");
code[1] = randint (-290, 290);
}
TEST (negwl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = (R ("0100010000101rrr") | (randint (1, 2) << 6));
code[1] = randint (-290, 290) & ~1;
}
TEST (neg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0100010000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (negx_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100000000000rrr") | RANDOM_SIZE ();
}
TEST (negxb_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0100000000000rrr") | (randint (2, 4) << 3);
}
TEST (negxwl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0100000000000rrr")
| (randint (2, 4) << 3)
| (randint (1, 2) << 6));
}
TEST (negxb_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0100000000101rrr");
code[1] = randint (-290, 290);
}
TEST (negxwl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = (R ("0100000000101rrr") | (randint (1, 2) << 6));
code[1] = randint (-290, 290) & ~1;
}
TEST (negx_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0100000000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (nop, ALL_CCS, 1, WONT_CHANGE_MEMORY, 1)
{
code[0] = B ("0100111001110001");
}
TEST (not_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100011000000rrr") | RANDOM_SIZE ();
}
TEST (notb_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0100011000000rrr") | (randint (2, 4) << 3);
}
TEST (notwl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0100011000000rrr")
| (randint (2, 4) << 3)
| (randint (1, 2) << 6));
}
TEST (notb_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0100011000101rrr");
code[1] = randint (-290, 290);
}
TEST (notwl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = (R ("0100011000101rrr") | (randint (1, 2) << 6));
code[1] = randint (-290, 290) & ~1;
}
TEST (not_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0100011000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
TEST (or_dreg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1000rrr000000rrr") | RANDOM_SIZE ();
}
TEST (or_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1000rrr000000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3));
}
TEST (or_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1000rrr000101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (or_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("1000rrr000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (orbw_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1000rrr00r111100"); /* randomly byte or word */
code[1] = randnum ();
}
TEST (orl_const_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1000rrr010111100");
WRITE4 (1, randnum ());
}
TEST (or_dreg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1000rrr100000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3));
}
TEST (or_dreg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1000rrr100101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (or_dreg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1000rrr100111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (oribw_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000000000r000rrr");
code[1] = randnum ();
}
TEST (oril_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000000010000rrr");
WRITE4 (1, randnum ());
}
TEST (oribw_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000000000r000rrr") | (randint (2, 4) << 3);
code[1] = randnum ();
}
TEST (oril_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000000010000rrr") | (randint (2, 4) << 3);
WRITE4 (1, randnum ());
}
TEST (oribw_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000000000r101rrr"); /* randomly either byte or word. */
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (oril_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000000010101rrr");
WRITE4 (1, randnum ());
code[3] = randint (-290, 290) & ~1;
}
TEST (oribw_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000000000r111001");
code[1] = randnum ();
WRITE4 (2, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (oril_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0000000010111001");
WRITE4 (1, randnum ());
WRITE4 (3, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (ori_to_ccr, ALL_CCS, 2, WONT_CHANGE_MEMORY, 32)
{
code[0] = B ("0000000000111100");
code[1] = times_called;
}
TEST (pack_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1000rrr101000rrr");
code[1] = randnum ();
}
TEST (pack_mem, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1000rrr101001rrr");
code[1] = randnum ();
}
TEST (pea_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = R ("0100100001010rrr");
}
TEST (pea_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = R ("0100100001101rrr");
code[1] = randnum ();
}
TEST (pea_absw, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = B ("0100100001111000");
code[1] = randnum ();
}
TEST (pea_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
code[0] = B ("0100100001111001");
WRITE4 (1, randnum ());
}
TEST (rol_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100111rrr") | RANDOM_SIZE ();
}
TEST (rol_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100011rrr") | RANDOM_SIZE ();
}
TEST (rol_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110011111000rrr") | (randint (2, 4) << 3);
}
TEST (rol_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110011111101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (rol_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110011111111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (ror_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000111rrr") | RANDOM_SIZE ();
}
TEST (ror_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000011rrr") | RANDOM_SIZE ();
}
TEST (ror_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110011011000rrr") | (randint (2, 4) << 3);
}
TEST (ror_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110011011101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (ror_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110011011111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (roxl_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100110rrr") | RANDOM_SIZE ();
}
TEST (roxl_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr100010rrr") | RANDOM_SIZE ();
}
TEST (roxl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110010111000rrr") | (randint (2, 4) << 3);
}
TEST (roxl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110010111101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (roxl_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110010111111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (roxr_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000110rrr") | RANDOM_SIZE ();
}
TEST (roxr_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1110rrr000010rrr") | RANDOM_SIZE ();
}
TEST (roxr_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1110010011000rrr") | (randint (2, 4) << 3);
}
TEST (roxr_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1110010011101rrr");
code[1] = randint (-290, 290) & ~1;
}
TEST (roxr_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("1110010011111001");
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (rtd, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint32 addr;
randomize_mem ();
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
addr = US_TO_SYN68K (&code[2]);
((uint8 *)(SYN68K_TO_US (EM_A7)))[0] = addr >> 24;
((uint8 *)(SYN68K_TO_US (EM_A7)))[1] = addr >> 16;
((uint8 *)(SYN68K_TO_US (EM_A7)))[2] = addr >> 8;
((uint8 *)(SYN68K_TO_US (EM_A7)))[3] = addr;
code[0] = B ("0100111001110100");
code[1] = randnum ();
}
TEST (rtr, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint32 addr, randcc;
randomize_mem ();
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
addr = US_TO_SYN68K (&code[1]);
randcc = randnum ();
((uint8 *)(SYN68K_TO_US (EM_A7)))[0] = randcc >> 8;
((uint8 *)(SYN68K_TO_US (EM_A7)))[1] = randcc;
((uint8 *)(SYN68K_TO_US (EM_A7)))[2] = addr >> 24;
((uint8 *)(SYN68K_TO_US (EM_A7)))[3] = addr >> 16;
((uint8 *)(SYN68K_TO_US (EM_A7)))[4] = addr >> 8;
((uint8 *)(SYN68K_TO_US (EM_A7)))[5] = addr;
code[0] = B ("0100111001110111");
}
TEST (rts, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
uint32 addr;
randomize_mem ();
EM_A7 = randint (MEM + 50, MEMEND - 50) & ~1;
addr = US_TO_SYN68K (&code[1]);
((uint8 *)(SYN68K_TO_US (EM_A7)))[0] = addr >> 24;
((uint8 *)(SYN68K_TO_US (EM_A7)))[1] = addr >> 16;
((uint8 *)(SYN68K_TO_US (EM_A7)))[2] = addr >> 8;
((uint8 *)(SYN68K_TO_US (EM_A7)))[3] = addr;
code[0] = B ("0100111001110101");
}
TEST (sbcd_reg, X_BIT | Z_BIT | C_BIT, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1000rrr100000rrr");
}
TEST (sbcd_mem, X_BIT | Z_BIT | C_BIT, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("1000rrr100001rrr");
}
TEST (Scc_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrrr11000rrr");
}
TEST (Scc_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0101rrrr11000rrr") | (randint (2, 4) << 3);
}
TEST (Scc_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0101rrrr11101rrr");
code[1] = randint (-290, 290);
}
TEST (Scc_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrrr11111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (subb_dreg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr000000rrr");
}
TEST (subw_reg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr00100rrrr");
}
TEST (subl_reg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr01000rrrr");
}
TEST (sub_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1001rrr000000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (sub_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1001rrr000101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (sub_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1001rrr000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (subb_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr000111100");
code[1] = randint (0, 65535);
}
TEST (subw_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr001111100");
code[1] = randint (0, 65535);
}
TEST (subl_const_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1001rrr010111100");
code[1] = randint (0, 65535);
code[2] = randint (0, 65535);
}
TEST (sub_dreg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1001rrr100000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (sub_dreg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1001rrr100101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (sub_dreg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1001rrr100111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (subaw_reg_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr01100rrrr");
}
TEST (subal_reg_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr11100rrrr");
}
TEST (suba_ind_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("1001rrrr11000rrr") /* Random size. */
| (randint (2, 4) << 3)); /* Random amode [2, 4]; */
}
TEST (suba_d16_areg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1001rrrr11101rrr"); /* Random size. */
code[1] = randint (-290, 290) & ~1;
}
TEST (suba_absl_areg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("1001rrrr11111001"); /* Random size. */
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (subaw_const_areg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr011111100");
code[1] = randint (0, 65535);
}
TEST (subal_const_areg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr111111100");
code[1] = randint (0, 65535);
code[2] = randint (0, 65535);
}
TEST (subibw_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000001000r000rrr"); /* Randomly either byte or word */
code[1] = randnum ();
}
TEST (subil_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000010010000rrr");
WRITE4 (1, randnum ());
}
TEST (subibw_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("000001000r000rrr") /* Randomly either byte or word. */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
code[1] = randnum ();
}
TEST (subil_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0000010010000rrr")
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
WRITE4 (1, randnum ());
}
TEST (subibw_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("000001000r101rrr"); /* Randomly either byte or word. */
code[1] = randnum ();
code[2] = randint (-290, 290) & ~1;
}
TEST (subil_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0000010010101rrr");
WRITE4 (1, randnum ());
code[3] = randint (-290, 290) & ~1;
}
TEST (subibw_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("000001000r111001"); /* Randomly either byte or word. */
code[1] = randnum ();
WRITE4 (2, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (subil_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0000010010111001"); /* Randomly either byte or word. */
WRITE4 (1, randnum ());
WRITE4 (3, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (subq_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrr100000rrr") | RANDOM_SIZE ();
}
TEST (subq_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrr100001rrr") | (randint (1, 2) << 6); /* word or long */
}
TEST (subq_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0101rrr100000rrr")
| RANDOM_SIZE ()
| (randint (2, 4) << 3)); /* random amode [2, 4] */
}
TEST (subq_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0101rrr100101rrr") | RANDOM_SIZE ();
code[1] = randint (-290, 290) & ~1;
}
TEST (subq_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0101rrr100111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
}
TEST (subx_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("1001rrr100000rrr") | RANDOM_SIZE ();
}
TEST (subx_mem, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = R ("1001rrr100001rrr") | RANDOM_SIZE ();
}
TEST (swap, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100100001000rrr");
}
TEST (tas_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = R ("0100101011000rrr");
}
TEST (tas_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0100101011000rrr") | (randint (2, 4) << 3);
}
TEST (tas_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0100101011101rrr");
code[1] = randint (-290, 290);
}
TEST (tas_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
{
code[0] = B ("0100101011111001");
WRITE4 (1, randint (MEM + 50, MEMEND - 50));
}
TEST (tstb_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("0100101000000rrr");
}
TEST (tstwl_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = R ("010010100000rrrr") | (randint (1, 2) << 6);
}
TEST (tstb_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
code[0] = R ("0100101000000rrr") | (randint (2, 4) << 3);
}
TEST (tstwl_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
code[0] = (R ("0100101000000rrr")
| (randint (1, 2) << 6) /* Randomly word or long */
| (randint (2, 4) << 3)); /* Random amode [2, 4] */
}
TEST (tstb_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
code[0] = R ("0100101000101rrr");
code[1] = randint (-290, 290);
}
TEST (tstwl_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
code[0] = R ("0100101000101rrr");
code[1] = randint (-290, 290);
}
TEST (tst_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
{
randomize_mem ();
code[0] = B ("0100101000111001") | RANDOM_SIZE ();
WRITE4 (1, randint (MEM + 50, MEMEND - 50) & ~1);
}
Reference in New Issue Copy Permalink