PageRenderTime 52ms CodeModel.GetById 18ms RepoModel.GetById 0ms app.codeStats 0ms

/test/tests.c

https://github.com/salty-horse/syn68k
C | 4105 lines | 3077 code | 960 blank | 68 comment | 84 complexity | da3e32b1e548277369befce9a7478c91 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. #include "syn68k_public.h"
    2. 

  2. #include "driver.h"
    3. 

  3. #include "setup.h"
    4. 

  4. #include <stdio.h>
    5. 

  5. 

  6. 

  7. #define TEST(f, cc_mask, size, changes_memory, max_calls) void f (uint16 *code)
    8. 

  8. #define MEM (US_TO_SYN68K (&mem[0]))
    9. 

  9. #define MEMEND (US_TO_SYN68K (&mem[MEM_SIZE - 1]))
    10. 

  10. #define MEMMID (US_TO_SYN68K (&mem[(MEM_SIZE) / 2]))
    11. 

  11. 

  12. #define GNUC_LOSES_WITH_EXPONENTIAL_GROWTH
    13. 

  13. #ifdef GNUC_LOSES_WITH_EXPONENTIAL_GROWTH
    14. 

  14. static inline int
    15. 

  15. MASK (const char *s, int c)
    16. 

  16. {
    17. 

  17.   int i, ret;
    18. 

  18.   
    19. 

  19.   for (i = 0, ret = 0; i < 16; i++)
    20. 

  20.     ret |= ((s[i] == c) << (15 - i));
    21. 

  21.   return ret;
    22. 

  22. }
    23. 

  23. #else
    24. 

  24. #define MASK(s,c) ((  (s[0 ] == (c)) << 15) | ((s[1 ] == (c)) << 14) \
    25. 

  25. 		   | ((s[2 ] == (c)) << 13) | ((s[3 ] == (c)) << 12) \
    26. 

  26. 		   | ((s[4 ] == (c)) << 11) | ((s[5 ] == (c)) << 10) \
    27. 

  27. 		   | ((s[6 ] == (c)) <<  9) | ((s[7 ] == (c)) <<  8) \
    28. 

  28. 		   | ((s[8 ] == (c)) <<  7) | ((s[9 ] == (c)) <<  6) \
    29. 

  29. 		   | ((s[10] == (c)) <<  5) | ((s[11] == (c)) <<  4) \
    30. 

  30. 		   | ((s[12] == (c)) <<  3) | ((s[13] == (c)) <<  2) \
    31. 

  31. 		   | ((s[14] == (c)) <<  1) | ((s[15] == (c))))
    32. 

  32. #endif
    33. 

  33. #define B(s) MASK(s, '1')
    34. 

  34. #define R(s) (B(s) | (MASK(s, 'r') & randint (0, 65535)))
    35. 

  35. 

  36. #define NOP_OPCODE 0x4E71
    37. 

  37. 

  38. #define RANDOM_SIZE() (randint (0, 2) << 6)
    39. 

  39. 

  40. /* The WRITE4 macro does not write out values in big-endian!  Rather, it
    41. 

  41.  * writes out the words in big endian format and leaves the bytes within
    42. 

  42.  * each word in whatever format.  This is because we always byte swap
    43. 

  43.  * words later, if appropriate.
    44. 

  44.  */
    45. 

  45. #define WRITE4(c,n)    \
    46. 

  46. {                      \
    47. 

  47.   uint32 tmp = (n);    \
    48. 

  48.   code[c] = tmp >> 16; \
    49. 

  49.   code[(c) + 1] = tmp; \
    50. 

  50. }
    51. 

  51. 

  52. 

  53. 

  54. TEST (unpk_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    55. 

  55. {
    56. 

  56.   code[0] = R ("1000rrr110000rrr");
    57. 

  57.   code[1] = randnum ();
    58. 

  58. }
    59. 

  59. 

  60. 

  61. TEST (unpk_mem, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    62. 

  62. {
    63. 

  63.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    64. 

  64.   code[0] = R ("1000rrr110001rrr");
    65. 

  65.   code[1] = randnum ();
    66. 

  66. }
    67. 

  67. 

  68. 

  69. TEST (unlk, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    70. 

  70. {
    71. 

  71.   uint8 *p;
    72. 

  72. 

  73.   for (p = mem; p < mem + MEM_SIZE; )
    74. 

  74.     {
    75. 

  75.       uint32 addr = randint (MEM + 50, MEMEND - 50) & ~1;
    76. 

  76.       *p++ = addr >> 24;
    77. 

  77.       *p++ = addr >> 16;
    78. 

  78.       *p++ = addr >> 8;
    79. 

  79.       *p++ = addr;
    80. 

  80.     }
    81. 

  81. 

  82.   /* NOTE: "unlk a7" wedges my 68040 NeXT, so I am skipping that test here.
    83. 

  83.    * "unlk a7" works on a 68030 NeXT, so it may be worth modifying this
    84. 

  84.    * code to test that case when we run it on a non-68040 based machine.
    85. 

  85.    */
    86. 

  86. 

  87.   /* WARNING!  Assumes that mem is aligned % 4 */
    88. 

  88.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 3);
    89. 

  89.   code[0] = R ("0100111001011000") | randint (0, 6);
    90. 

  90. }
    91. 

  91. 

  92. TEST (movewl_ind_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    93. 

  93. {
    94. 

  94.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    95. 

  95.   code[0] = (R ("001rrrr000000rrr")   /* Randomly either word or long. */
    96. 

  96. 	     | (randint (2, 4) << 6)    /* Random amode [2, 4] */
    97. 

  97. 	     | (randint (2, 4) << 3));  /* Random amode [2, 4] */
    98. 

  98. }
    99. 

  99. 

  100. 

  101. TEST (divsl_ll_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    102. 

  102. {
    103. 

  103.   int divisor_reg = randint (0, 7);
    104. 

  104.   do { EM_DREG (divisor_reg) = randnum ();} while (EM_DREG (divisor_reg) == 0);
    105. 

  105.   code[0] = B ("0100110001000000") | divisor_reg;
    106. 

  106.   code[1] = R ("0rrr1r0000000rrr");
    107. 

  107. }
    108. 

  108. 

  109. 

  110. TEST (divsl_ll_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    111. 

  111. {
    112. 

  112.   uint16 *p;
    113. 

  113.   int i;
    114. 

  114. 

  115.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    116. 

  116.   for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
    117. 

  117.     *p++ = SWAPUW_IFLE (randint (1, 65535));
    118. 

  118.   code[0] = R ("0100110001000rrr") | (randint (2, 4) << 3);
    119. 

  119.   code[1] = R ("0rrr1r0000000rrr");
    120. 

  120. }
    121. 

  121. 

  122. 

  123. TEST (divsl_ll_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
    124. 

  124. {
    125. 

  125.   uint16 *p;
    126. 

  126.   int i;
    127. 

  127. 

  128.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    129. 

  129.   for (i = 0, p = (uint16 *)mem; i < MEM_SIZE / sizeof (uint16); i++)
    130. 

  130.     *p++ = SWAPUW_IFLE (randint (1, 65535));
    131. 

  131.   code[0] = B ("0100110001111001");
    132. 

  132.   code[1] = R ("0rrr1r0000000rrr");
    133. 

  133.   WRITE4 (2, randint (MEM + 50, MEMEND - 50) & ~1);
    134. 

  134. }
    135. 

  135. 

  136. 

  137. TEST (lea_pc_ind_preix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
    138. 

  138. {
    139. 

  139.   int i;
    140. 

  140.   int bd_size = randint (2, 3), od_size = randint (1, 3);
    141. 

  141.   int scale = randint (0, 3);
    142. 

  142. 

  143.   randomize_mem ();
    144. 

  144.   randomize_regs (0, 15, 0, 8 >> scale, (4 >> scale) - 1);
    145. 

  145. 

  146.   /* Put out some initial NOPs */
    147. 

  147.   for (i = 0; i < 4; i++)
    148. 

  148.     code[i] = NOP_OPCODE;  /* nop */
    149. 

  149. 

  150.   /* Output the main opcode. */
    151. 

  151.   code[i] = R ("0100rrr111111011");
    152. 

  152.   code[i + 1] = (R ("rrrrr0010r000000") | (scale << 9)
    153. 

  153. 		 | (bd_size << 4) | od_size);
    154. 

  154.   i += 2;
    155. 

  155. 

  156.   /* Output the base displacement. */
    157. 

  157.   switch (bd_size) {
    158. 

  158.   case 2:
    159. 

  159.     code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
    160. 

  160.     i++;
    161. 

  161.     break;
    162. 

  162.   case 3:
    163. 

  163.     WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
    164. 

  164.     i += 2;
    165. 

  165.     break;
    166. 

  166.   }
    167. 

  167. 

  168.   /* Output outer displacement (if any). */
    169. 

  169.   switch (od_size) {
    170. 

  170.   case 1:
    171. 

  171.     break;
    172. 

  172.   case 2:
    173. 

  173.     code[i] = randint (-20, 20);
    174. 

  174.     i++;
    175. 

  175.     break;
    176. 

  176.   case 3:
    177. 

  177.     WRITE4 (i, randint (-20, 20));
    178. 

  178.     i += 2;
    179. 

  179.     break;
    180. 

  180.   }
    181. 

  181. 

  182.   /* Skip over array of addresses. */
    183. 

  183.   code[i] = 0x4EF9;  /* jmp absl */
    184. 

  184.   WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
    185. 

  185.   
    186. 

  186.   for (i += 3; i < 49; i += 2)
    187. 

  187.     WRITE4 (i, randint (MEM + 50, MEMEND - 50));
    188. 

  188. }
    189. 

  189. 

  190. 

  191. TEST (lea_pc_ind_postix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
    192. 

  192. {
    193. 

  193.   int i;
    194. 

  194.   int bd_size = randint (2, 3), od_size = randint (1, 3);
    195. 

  195.   int scale = randint (0, 3);
    196. 

  196. 

  197.   randomize_mem ();
    198. 

  198.   randomize_regs (0, 15, -6, 6, 0);
    199. 

  199. 

  200.   /* Put out some initial NOPs */
    201. 

  201.   for (i = 0; i < 4; i++)
    202. 

  202.     code[i] = NOP_OPCODE;  /* nop */
    203. 

  203. 

  204.   /* Output the main opcode. */
    205. 

  205.   code[i] = R ("0100rrr111111011");
    206. 

  206.   code[i + 1] = (R ("rrrrr0010r000100") | (scale << 9)
    207. 

  207. 		 | (bd_size << 4) | od_size);
    208. 

  208.   i += 2;
    209. 

  209. 

  210.   /* Output the base displacement. */
    211. 

  211.   switch (bd_size) {
    212. 

  212.   case 2:
    213. 

  213.     code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
    214. 

  214.     i++;
    215. 

  215.     break;
    216. 

  216.   case 3:
    217. 

  217.     WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
    218. 

  218.     i += 2;
    219. 

  219.     break;
    220. 

  220.   }
    221. 

  221. 

  222.   /* Output outer displacement (if any). */
    223. 

  223.   switch (od_size) {
    224. 

  224.   case 1:
    225. 

  225.     break;
    226. 

  226.   case 2:
    227. 

  227.     code[i] = randint (-20, 20);
    228. 

  228.     i++;
    229. 

  229.     break;
    230. 

  230.   case 3:
    231. 

  231.     WRITE4 (i, randint (-20, 20));
    232. 

  232.     i += 2;
    233. 

  233.     break;
    234. 

  234.   }
    235. 

  235. 

  236.   /* Skip over array of addresses. */
    237. 

  237.   code[i] = 0x4EF9;  /* jmp absl */
    238. 

  238.   WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
    239. 

  239.   
    240. 

  240.   for (i += 3; i < 49; i += 2)
    241. 

  241.     WRITE4 (i, randint (MEM + 100, MEMEND - 100));
    242. 

  242. }
    243. 

  243. 

  244. 

  245. TEST (moveb_pc_ind_preix_dreg, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
    246. 

  246. {
    247. 

  247.   int i;
    248. 

  248.   int bd_size = randint (2, 3), od_size = randint (1, 3);
    249. 

  249.   int scale = randint (0, 3);
    250. 

  250. 

  251.   randomize_mem ();
    252. 

  252.   randomize_regs (0, 15, 0, 8 >> scale, (4 >> scale) - 1);
    253. 

  253. 

  254.   /* Put out some initial NOPs */
    255. 

  255.   for (i = 0; i < 4; i++)
    256. 

  256.     code[i] = NOP_OPCODE;  /* nop */
    257. 

  257. 

  258.   /* Output the main opcode. */
    259. 

  259.   code[i] = R ("0001rrr000111011");
    260. 

  260.   code[i + 1] = (R ("rrrrr0010r000000") | (scale << 9)
    261. 

  261. 		 | (bd_size << 4) | od_size);
    262. 

  262.   i += 2;
    263. 

  263. 

  264.   /* Output the base displacement. */
    265. 

  265.   switch (bd_size) {
    266. 

  266.   case 2:
    267. 

  267.     code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
    268. 

  268.     i++;
    269. 

  269.     break;
    270. 

  270.   case 3:
    271. 

  271.     WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
    272. 

  272.     i += 2;
    273. 

  273.     break;
    274. 

  274.   }
    275. 

  275. 

  276.   /* Output outer displacement (if any). */
    277. 

  277.   switch (od_size) {
    278. 

  278.   case 1:
    279. 

  279.     break;
    280. 

  280.   case 2:
    281. 

  281.     code[i] = randint (-20, 20);
    282. 

  282.     i++;
    283. 

  283.     break;
    284. 

  284.   case 3:
    285. 

  285.     WRITE4 (i, randint (-20, 20));
    286. 

  286.     i += 2;
    287. 

  287.     break;
    288. 

  288.   }
    289. 

  289. 

  290.   /* Skip over array of addresses. */
    291. 

  291.   code[i] = 0x4EF9;  /* jmp absl */
    292. 

  292.   WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
    293. 

  293.   
    294. 

  294.   for (i += 3; i < 49; i += 2)
    295. 

  295.     WRITE4 (i, randint (MEM + 50, MEMEND - 50));
    296. 

  296. }
    297. 

  297. 

  298. 

  299. TEST (moveb_pc_ind_postix_dreg, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
    300. 

  300. {
    301. 

  301.   int i;
    302. 

  302.   int bd_size = randint (2, 3), od_size = randint (1, 3);
    303. 

  303.   int scale = randint (0, 3);
    304. 

  304. 

  305.   randomize_mem ();
    306. 

  306.   randomize_regs (0, 15, -6, 6, 0);
    307. 

  307. 

  308.   /* Put out some initial NOPs */
    309. 

  309.   for (i = 0; i < 4; i++)
    310. 

  310.     code[i] = NOP_OPCODE;  /* nop */
    311. 

  311. 

  312.   /* Output the main opcode. */
    313. 

  313.   code[i] = R ("0001rrr000111011");
    314. 

  314.   code[i + 1] = (R ("rrrrr0010r000100") | (scale << 9)
    315. 

  315. 		 | (bd_size << 4) | od_size);
    316. 

  316.   i += 2;
    317. 

  317. 

  318.   /* Output the base displacement. */
    319. 

  319.   switch (bd_size) {
    320. 

  320.   case 2:
    321. 

  321.     code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
    322. 

  322.     i++;
    323. 

  323.     break;
    324. 

  324.   case 3:
    325. 

  325.     WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
    326. 

  326.     i += 2;
    327. 

  327.     break;
    328. 

  328.   }
    329. 

  329. 

  330.   /* Output outer displacement (if any). */
    331. 

  331.   switch (od_size) {
    332. 

  332.   case 1:
    333. 

  333.     break;
    334. 

  334.   case 2:
    335. 

  335.     code[i] = randint (-20, 20);
    336. 

  336.     i++;
    337. 

  337.     break;
    338. 

  338.   case 3:
    339. 

  339.     WRITE4 (i, randint (-20, 20));
    340. 

  340.     i += 2;
    341. 

  341.     break;
    342. 

  342.   }
    343. 

  343. 

  344.   /* Skip over array of addresses. */
    345. 

  345.   code[i] = 0x4EF9;  /* jmp absl */
    346. 

  346.   WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
    347. 

  347.   
    348. 

  348.   for (i += 3; i < 49; i += 2)
    349. 

  349.     WRITE4 (i, randint (MEM + 100, MEMEND - 100));
    350. 

  350. }
    351. 

  351. 

  352. 

  353. TEST (moveb_pcd16_dreg, ALL_CCS, 6, WONT_CHANGE_MEMORY, NO_LIMIT)
    354. 

  354. {
    355. 

  355.   randomize_mem ();
    356. 

  356.   code[0] = NOP_OPCODE;  /* nop */
    357. 

  357.   code[1] = NOP_OPCODE;  /* nop */
    358. 

  358.   code[2] = R ("0001rrr000111010");
    359. 

  359.   code[3] = randint (-4, 4);
    360. 

  360.   code[4] = NOP_OPCODE;  /* nop */
    361. 

  361.   code[5] = NOP_OPCODE;  /* nop */
    362. 

  362. }
    363. 

  363. 

  364. 

  365. TEST (movewl_pcd16_dreg, ALL_CCS, 6, WONT_CHANGE_MEMORY, NO_LIMIT)
    366. 

  366. {
    367. 

  367.   randomize_mem ();
    368. 

  368.   code[0] = NOP_OPCODE;  /* nop */
    369. 

  369.   code[1] = NOP_OPCODE;  /* nop */
    370. 

  370.   code[2] = R ("001rrrr000111010");
    371. 

  371.   code[3] = randint (-4, 4) & ~1;
    372. 

  372.   code[4] = NOP_OPCODE;  /* nop */
    373. 

  373.   code[5] = NOP_OPCODE;  /* nop */
    374. 

  374. }
    375. 

  375. 

  376. 

  377. TEST (moveb_pcd8_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
    378. 

  378. {
    379. 

  379.   int i;
    380. 

  380.   int long_ix = randint (0, 1);    /* Are we using a index reg as a long? */
    381. 

  381. 

  382.   randomize_mem ();
    383. 

  383.   randomize_regs (0, 15, -2, 2, 0);
    384. 

  384. 

  385.   /* If we have a word sized index, blow away high word of all regs so
    386. 

  386.    * that we know the high word is being properly ignored.
    387. 

  387.    */
    388. 

  388.   if (!long_ix)
    389. 

  389.     {
    390. 

  390.       for (i = 0; i < 16; i++)
    391. 

  391. 	cpu_state.regs[i].ul.n = ((cpu_state.regs[i].ul.n & 0xFFFF)
    392. 

  392. 				  | (randnum () << 16));
    393. 

  393.     }
    394. 

  394. 

  395.   for (i = 0; i < 20; i++)
    396. 

  396.     code[i] = NOP_OPCODE;  /* nop */
    397. 

  397.   code[i] = R ("0001rrr000111011");
    398. 

  398.   code[i + 1] = (R ("rrrr0rr000000000") | (long_ix << 11)
    399. 

  399. 		 | (randint (-4, 4) & 0xFF));
    400. 

  400.   for (i += 2; i < 40; i++)
    401. 

  401.     code[i] = NOP_OPCODE;  /* nop */
    402. 

  402. }
    403. 

  403. 

  404. 

  405. TEST (movewl_pcd8_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
    406. 

  406. {
    407. 

  407.   int i;
    408. 

  408. 

  409.   randomize_mem ();
    410. 

  410.   randomize_regs (0, 15, -2, 2, 1);
    411. 

  411. 

  412.   for (i = 0; i < 20; i++)
    413. 

  413.     code[i] = NOP_OPCODE;  /* nop */
    414. 

  414.   code[i] = R ("001rrrr000111011");
    415. 

  415.   code[i + 1] = R ("rrrrrrr000000000") | (randint (-4, 4) & 0xFE);
    416. 

  416.   for (i += 2; i < 40; i++)
    417. 

  417.     code[i] = NOP_OPCODE;  /* nop */
    418. 

  418. }
    419. 

  419. 

  420. 

  421. TEST (moveb_pc_ind_ix_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
    422. 

  422. {
    423. 

  423.   int i;
    424. 

  424.   int bd_size = randint (1, 3);
    425. 

  425. 

  426.   randomize_mem ();
    427. 

  427.   randomize_regs (0, 15, -2, 2, 0);
    428. 

  428. 

  429.   for (i = 0; i < 20; i++)
    430. 

  430.     code[i] = NOP_OPCODE;  /* nop */
    431. 

  431.   code[i] = R ("0001rrr000111011");
    432. 

  432.   code[i + 1] = R ("rrrrrrr10r000000") | (bd_size << 4);
    433. 

  433.   switch (bd_size) {
    434. 

  434.   case 1:
    435. 

  435.     i += 2;
    436. 

  436.     break;
    437. 

  437.   case 2:
    438. 

  438.     code[i + 2] = randint (-4, 4);
    439. 

  439.     i += 3;
    440. 

  440.     break;
    441. 

  441.   case 3:
    442. 

  442.     WRITE4 (i + 2, randint (-4, 4));
    443. 

  443.     i += 4;
    444. 

  444.     break;
    445. 

  445.   }
    446. 

  446. 

  447.   for (; i < 40; i++)
    448. 

  448.     code[i] = NOP_OPCODE;  /* nop */
    449. 

  449. }
    450. 

  450. 

  451. 

  452. TEST (movewl_pc_ind_ix_dreg, ALL_CCS, 40, WONT_CHANGE_MEMORY, NO_LIMIT)
    453. 

  453. {
    454. 

  454.   int i;
    455. 

  455.   int bd_size = randint (1, 3);
    456. 

  456. 

  457.   randomize_mem ();
    458. 

  458.   randomize_regs (0, 15, -2, 2, 1);
    459. 

  459. 

  460.   for (i = 0; i < 20; i++)
    461. 

  461.     code[i] = NOP_OPCODE;  /* nop */
    462. 

  462.   code[i] = R ("001rrrr000111011");
    463. 

  463.   code[i + 1] = R ("rrrrrrr10r000000") | (bd_size << 4);
    464. 

  464.   switch (bd_size) {
    465. 

  465.   case 1:
    466. 

  466.     i += 2;
    467. 

  467.     break;
    468. 

  468.   case 2:
    469. 

  469.     code[i + 2] = randint (-4, 4) & ~1;
    470. 

  470.     i += 3;
    471. 

  471.     break;
    472. 

  472.   case 3:
    473. 

  473.     WRITE4 (i + 2, randint (-4, 4) & ~1);
    474. 

  474.     i += 4;
    475. 

  475.     break;
    476. 

  476.   }
    477. 

  477. 

  478.   for (; i < 40; i++)
    479. 

  479.     code[i] = NOP_OPCODE;  /* nop */
    480. 

  480. }
    481. 

  481. 

  482. 

  483. TEST (lea_ind_preix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
    484. 

  484. {
    485. 

  485.   int i;
    486. 

  486.   int bd_size, od_size = randint (1, 3);
    487. 

  487.   int scale = randint (0, 3);
    488. 

  488.   int base_address_reg = randint (0, 7);
    489. 

  489.   int base_suppress = randint (0, 1);
    490. 

  490.   int ixreg_specifier;
    491. 

  491. 

  492.   randomize_mem ();
    493. 

  493.   randomize_regs (0, 15, 0, 8 >> scale, (4 >> scale) - 1);
    494. 

  494. 

  495.   /* Put out some initial NOPs */
    496. 

  496.   for (i = 0; i < 4; i++)
    497. 

  497.     code[i] = NOP_OPCODE;  /* nop */
    498. 

  498. 

  499.   /* Determine the index reg.  Make sure it's not the same as our base reg. */
    500. 

  500.   do
    501. 

  501.     {
    502. 

  502.       ixreg_specifier = randint (0, 15);
    503. 

  503.     }
    504. 

  504.   while ((ixreg_specifier & 8) && (ixreg_specifier & 7) == base_address_reg);
    505. 

  505. 

  506.   if (base_suppress)
    507. 

  507.     bd_size = 3;
    508. 

  508.   else
    509. 

  509.     bd_size = randint (2, 3);
    510. 

  510. 

  511.   /* Output the main opcode. */
    512. 

  512.   code[i] = R ("0100rrr111110000") | base_address_reg;
    513. 

  513.   code[i + 1] = (R ("0000r0010r000000") | (ixreg_specifier << 12)
    514. 

  514. 		 | (base_suppress << 7) | (scale << 9) | (bd_size << 4)
    515. 

  515. 		 | od_size);
    516. 

  516.   i += 2;
    517. 

  517. 

  518.   /* Put the address of a block of random memory into our base register. */
    519. 

  519.   cpu_state.regs[8 + base_address_reg].ul.n
    520. 

  520.     = randint (MEM + 32, MEM + 128) & ~1;
    521. 

  521. 

  522.   /* Output the base displacement. */
    523. 

  523.   if (!base_suppress)
    524. 

  524.     {
    525. 

  525.       /* Since we aren't suppressing the base, make this a small offset. */
    526. 

  526.       switch (bd_size) {
    527. 

  527.       case 2:
    528. 

  528. 	code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
    529. 

  529. 	i++;
    530. 

  530. 	break;
    531. 

  531.       case 3:
    532. 

  532. 	WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
    533. 

  533. 	i += 2;
    534. 

  534. 	break;
    535. 

  535.       }
    536. 

  536.     }
    537. 

  537.   else  /* base_suppress */
    538. 

  538.     {
    539. 

  539.       /* Since we're suppressing the base, we must make it larger and
    540. 

  540.        * point directly to the base of the addresses in which we
    541. 

  541.        * are interested.
    542. 

  542.        */
    543. 

  543.       WRITE4 (i, MEM + 32 + (randint (0, 50) * 4));
    544. 

  544.       i += 2;
    545. 

  545.     }
    546. 

  546. 

  547.   /* Output outer displacement (if any). */
    548. 

  548.   switch (od_size) {
    549. 

  549.   case 1:
    550. 

  550.     break;
    551. 

  551.   case 2:
    552. 

  552.     code[i] = randint (-20, 20);
    553. 

  553.     i++;
    554. 

  554.     break;
    555. 

  555.   case 3:
    556. 

  556.     WRITE4 (i, randint (-20, 20));
    557. 

  557.     i += 2;
    558. 

  558.     break;
    559. 

  559.   }
    560. 

  560. 

  561.   /* Skip over array of addresses. */
    562. 

  562.   code[i] = 0x4EF9;  /* jmp absl */
    563. 

  563.   WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
    564. 

  564.   
    565. 

  565.   for (i += 3; i < 49; i += 2)
    566. 

  566.     WRITE4 (i, randint (MEM + 50, MEMEND - 50));
    567. 

  567. }
    568. 

  568. 

  569. 

  570. TEST (lea_ind_postix, ALL_CCS, 50, WONT_CHANGE_MEMORY, NO_LIMIT)
    571. 

  571. {
    572. 

  572.   int i;
    573. 

  573.   int bd_size, od_size = randint (1, 3);
    574. 

  574.   int scale = randint (0, 3);
    575. 

  575.   int base_address_reg = randint (0, 7);
    576. 

  576.   int base_suppress = randint (0, 1);
    577. 

  577.   int ixreg_specifier = randint (0, 15);
    578. 

  578. 

  579.   randomize_mem ();
    580. 

  580.   randomize_regs (0, 15, -1024, 1024, 1);
    581. 

  581. 

  582.   /* Put out some initial NOPs */
    583. 

  583.   for (i = 0; i < 4; i++)
    584. 

  584.     code[i] = NOP_OPCODE;  /* nop */
    585. 

  585. 

  586.   if (base_suppress)
    587. 

  587.     bd_size = 3;
    588. 

  588.   else
    589. 

  589.     bd_size = randint (2, 3);
    590. 

  590. 

  591.   /* Output the main opcode. */
    592. 

  592.   code[i] = R ("0100rrr111110000") | base_address_reg;
    593. 

  593.   code[i + 1] = (R ("0000r0010r000100") | (ixreg_specifier << 12)
    594. 

  594. 		 | (base_suppress << 7) | (scale << 9) | (bd_size << 4)
    595. 

  595. 		 | od_size);
    596. 

  596.   i += 2;
    597. 

  597. 

  598.   /* Put the address of a block of random memory into our base register. */
    599. 

  599.   cpu_state.regs[8 + base_address_reg].ul.n
    600. 

  600.     = randint (MEM + 32, MEMEND - 128) & ~1;
    601. 

  601. 

  602.   /* Output the base displacement. */
    603. 

  603.   if (!base_suppress)
    604. 

  604.     {
    605. 

  605.       /* Since we aren't suppressing the base, make this a small offset. */
    606. 

  606.       switch (bd_size) {
    607. 

  607.       case 2:
    608. 

  608. 	code[i] = (5 + (od_size - 1)) * 2 + (randint (0, 5) * 4);
    609. 

  609. 	i++;
    610. 

  610. 	break;
    611. 

  611.       case 3:
    612. 

  612. 	WRITE4 (i, (6 + (od_size - 1)) * 2 + (randint (0, 5) * 4));
    613. 

  613. 	i += 2;
    614. 

  614. 	break;
    615. 

  615.       }
    616. 

  616.     }
    617. 

  617.   else  /* base_suppress */
    618. 

  618.     {
    619. 

  619.       /* Since we're suppressing the base, we must make it larger and
    620. 

  620.        * point directly to the base of the addresses in which we
    621. 

  621.        * are interested.
    622. 

  622.        */
    623. 

  623.       WRITE4 (i, MEM + 32 + (randint (0, 50) * 4));
    624. 

  624.       i += 2;
    625. 

  625.     }
    626. 

  626. 

  627.   /* Output outer displacement (if any). */
    628. 

  628.   switch (od_size) {
    629. 

  629.   case 1:
    630. 

  630.     break;
    631. 

  631.   case 2:
    632. 

  632.     code[i] = randint (-20, 20);
    633. 

  633.     i++;
    634. 

  634.     break;
    635. 

  635.   case 3:
    636. 

  636.     WRITE4 (i, randint (-20, 20));
    637. 

  637.     i += 2;
    638. 

  638.     break;
    639. 

  639.   }
    640. 

  640. 

  641.   /* Skip over array of addresses. */
    642. 

  642.   code[i] = 0x4EF9;  /* jmp absl */
    643. 

  643.   WRITE4 (i + 1, (unsigned long) (code - (MEMORY_OFFSET / 2) + 50));
    644. 

  644.   
    645. 

  645.   for (i += 3; i < 49; i += 2)
    646. 

  646.     WRITE4 (i, randint (MEM + 50, MEMEND - 50));
    647. 

  647. }
    648. 

  648. 

  649. 

  650. TEST (add_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    651. 

  651. {
    652. 

  652.   randomize_mem ();
    653. 

  653.   code[0] = R ("1101rrr000111001") | RANDOM_SIZE ();
    654. 

  654.   WRITE4 (1, randint (MEM + 8, MEMEND - 8) & ~1);
    655. 

  655. }
    656. 

  656. 

  657. 

  658. TEST (abcd_reg, C_BIT | Z_BIT | X_BIT, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    659. 

  659. {
    660. 

  660.   code[0] = R ("1100rrr100000rrr");
    661. 

  661. }
    662. 

  662. 

  663. 

  664. TEST (abcd_mem, C_BIT | Z_BIT | X_BIT, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    665. 

  665. {
    666. 

  666.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    667. 

  667.   code[0] = R ("1100rrr100001rrr");
    668. 

  668. }
    669. 

  669. 

  670. 

  671. TEST (addb_dreg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    672. 

  672. {
    673. 

  673.   code[0] = R ("1101rrr000000rrr");
    674. 

  674. }
    675. 

  675. 

  676. 

  677. TEST (addw_reg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    678. 

  678. {
    679. 

  679.   code[0] = R ("1101rrr00100rrrr");
    680. 

  680. }
    681. 

  681. 

  682. 

  683. TEST (addl_reg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    684. 

  684. {
    685. 

  685.   code[0] = R ("1101rrr01000rrrr");
    686. 

  686. }
    687. 

  687. 

  688. 

  689. TEST (add_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    690. 

  690. {
    691. 

  691.   randomize_mem ();
    692. 

  692.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    693. 

  693.   code[0] = R ("1101rrr000101rrr") | RANDOM_SIZE ();
    694. 

  694.   code[1] = randint (-290, 290) & ~1;
    695. 

  695. }
    696. 

  696. 

  697. 

  698. TEST (addb_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    699. 

  699. {
    700. 

  700.   code[0] = R ("1101rrr000111100");
    701. 

  701.   code[1] = randint (0, 65535);
    702. 

  702. }
    703. 

  703. 

  704. 

  705. TEST (addw_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    706. 

  706. {
    707. 

  707.   code[0] = R ("1101rrr001111100");
    708. 

  708.   code[1] = randint (0, 65535);
    709. 

  709. }
    710. 

  710. 

  711. 

  712. TEST (add_dreg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    713. 

  713. {
    714. 

  714.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    715. 

  715.   code[0] = (R ("1101rrr100000rrr")
    716. 

  716. 	     | RANDOM_SIZE ()
    717. 

  717. 	     | (randint (2, 4) << 3));  /* Random amode [2, 4] */
    718. 

  718. }
    719. 

  719. 

  720. 

  721. TEST (add_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    722. 

  722. {
    723. 

  723.   randomize_mem ();
    724. 

  724.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    725. 

  725.   code[0] = (R ("1101rrr000000rrr")
    726. 

  726. 	     | RANDOM_SIZE ()
    727. 

  727. 	     | (randint (2, 4) << 3)); /* Random amode [2, 4] */
    728. 

  728. }
    729. 

  729. 

  730. TEST (addl_const_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    731. 

  731. {
    732. 

  732.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    733. 

  733.   code[0] = R ("1101rrr010111100");
    734. 

  734.   WRITE4 (1, randnum ());
    735. 

  735. }
    736. 

  736. 

  737. 

  738. TEST (add_dreg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    739. 

  739. {
    740. 

  740.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    741. 

  741.   code[0] = R ("1101rrr100101rrr") | RANDOM_SIZE ();
    742. 

  742.   code[1] = randint (-290, 290) & ~1;
    743. 

  743. }
    744. 

  744. 

  745. 

  746. TEST (add_dreg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    747. 

  747. {
    748. 

  748.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    749. 

  749.   code[0] = R ("1101rrr100111001") | RANDOM_SIZE ();
    750. 

  750.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    751. 

  751. }
    752. 

  752. 

  753. 

  754. TEST (addaw_reg_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    755. 

  755. {
    756. 

  756.   code[0] = R ("1101rrr01100rrrr");
    757. 

  757. }
    758. 

  758. 

  759. 

  760. TEST (addal_reg_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    761. 

  761. {
    762. 

  762.   code[0] = R ("1101rrr11100rrrr");
    763. 

  763. }
    764. 

  764. 

  765. 

  766. TEST (adda_ind_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    767. 

  767. {
    768. 

  768.   randomize_mem ();
    769. 

  769.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    770. 

  770.   code[0] = (R ("1101rrrr11000rrr")   /* Random size. */
    771. 

  771. 	     | (randint (2, 4) << 3));  /* Random amode [2, 4]; */
    772. 

  772. }
    773. 

  773. 

  774. 

  775. TEST (adda_d16_areg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    776. 

  776. {
    777. 

  777.   randomize_mem ();
    778. 

  778.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    779. 

  779.   code[0] = R ("1101rrrr11101rrr");  /* Random size. */
    780. 

  780.   code[1] = randint (-290, 290) & ~1;
    781. 

  781. }
    782. 

  782. 

  783. 

  784. TEST (adda_absl_areg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    785. 

  785. {
    786. 

  786.   randomize_mem ();
    787. 

  787.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    788. 

  788.   code[0] = R ("1101rrrr11111001");  /* Random size. */
    789. 

  789.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    790. 

  790. }
    791. 

  791. 

  792. 

  793. TEST (addaw_const_areg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    794. 

  794. {
    795. 

  795.   code[0] = R ("1101rrr011111100");
    796. 

  796.   code[1] = randint (0, 65535);
    797. 

  797. }
    798. 

  798. 

  799. 

  800. TEST (addal_const_areg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    801. 

  801. {
    802. 

  802.   code[0] = R ("1101rrr111111100");
    803. 

  803.   code[1] = randint (0, 65535);
    804. 

  804.   code[2] = randint (0, 65535);
    805. 

  805. }
    806. 

  806. 

  807. 

  808. TEST (addibw_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    809. 

  809. {
    810. 

  810.   code[0] = R ("000001100r000rrr");  /* Randomly either byte or word */
    811. 

  811.   code[1] = randnum ();
    812. 

  812. }
    813. 

  813. 

  814. 

  815. TEST (addil_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    816. 

  816. {
    817. 

  817.   code[0] = R ("0000011010000rrr");
    818. 

  818.   WRITE4 (1, randnum ());
    819. 

  819. }
    820. 

  820. 

  821. 

  822. TEST (addibw_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    823. 

  823. {
    824. 

  824.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    825. 

  825.   code[0] = (R ("000001100r000rrr")    /* Randomly either byte or word. */
    826. 

  826. 	     | (randint (2, 4) << 3));  /* Random amode [2, 4] */
    827. 

  827.   code[1] = randnum ();
    828. 

  828. }
    829. 

  829. 

  830. 

  831. TEST (addil_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    832. 

  832. {
    833. 

  833.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    834. 

  834.   code[0] = (R ("0000011010000rrr")
    835. 

  835. 	     | (randint (2, 4) << 3));  /* Random amode [2, 4] */
    836. 

  836.   WRITE4 (1, randnum ());
    837. 

  837. }
    838. 

  838. 

  839. 

  840. TEST (addibw_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    841. 

  841. {
    842. 

  842.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    843. 

  843.   code[0] = R ("000001100r101rrr");  /* Randomly either byte or word. */
    844. 

  844.   code[1] = randnum ();
    845. 

  845.   code[2] = randint (-290, 290) & ~1;
    846. 

  846. }
    847. 

  847. 

  848. 

  849. TEST (addil_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    850. 

  850. {
    851. 

  851.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    852. 

  852.   code[0] = R ("0000011010101rrr");
    853. 

  853.   WRITE4 (1, randnum ());
    854. 

  854.   code[3] = randint (-290, 290) & ~1;
    855. 

  855. }
    856. 

  856. 

  857. 

  858. TEST (addibw_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    859. 

  859. {
    860. 

  860.   code[0] = R ("000001100r111001");  /* Randomly either byte or word. */
    861. 

  861.   code[1] = randnum ();
    862. 

  862. 

  863.   WRITE4 (2, randint (MEM + 4, MEMEND - 4) & ~1);
    864. 

  864. }
    865. 

  865. 

  866. 

  867. TEST (addil_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    868. 

  868. {
    869. 

  869.   code[0] = R ("0000011010111001");  /* Randomly either byte or word. */
    870. 

  870.   WRITE4 (1, randnum ());
    871. 

  871.   WRITE4 (3, randint (MEM + 4, MEMEND - 4) & ~1);
    872. 

  872. }
    873. 

  873. 

  874. 

  875. TEST (addq_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    876. 

  876. {
    877. 

  877.   code[0] = R ("0101rrr000000rrr") | RANDOM_SIZE ();
    878. 

  878. }
    879. 

  879. 

  880. 

  881. TEST (addq_areg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    882. 

  882. {
    883. 

  883.   code[0] = R ("0101rrr000001rrr") | (randint (1, 2) << 6); /* word or long */
    884. 

  884. }
    885. 

  885. 

  886. 

  887. TEST (addq_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    888. 

  888. {
    889. 

  889.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    890. 

  890.   code[0] = (R ("0101rrr000000rrr")
    891. 

  891. 	     | RANDOM_SIZE ()
    892. 

  892. 	     | (randint (2, 4) << 3));  /* random amode [2, 4] */
    893. 

  893. }
    894. 

  894. 

  895. 

  896. TEST (addq_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    897. 

  897. {
    898. 

  898.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    899. 

  899.   code[0] = R ("0101rrr000101rrr") | RANDOM_SIZE ();
    900. 

  900.   code[1] = randint (-290, 290) & ~1;
    901. 

  901. }
    902. 

  902. 

  903. 

  904. TEST (addq_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    905. 

  905. {
    906. 

  906.   code[0] = R ("0101rrr000111001") | RANDOM_SIZE ();
    907. 

  907.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    908. 

  908. }
    909. 

  909. 

  910. 

  911. TEST (addx_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    912. 

  912. {
    913. 

  913.   code[0] = R ("1101rrr100000rrr") | RANDOM_SIZE ();
    914. 

  914. }
    915. 

  915. 

  916. 

  917. TEST (addx_mem, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    918. 

  918. {
    919. 

  919.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    920. 

  920.   code[0] = R ("1101rrr100001rrr") | RANDOM_SIZE ();
    921. 

  921. }
    922. 

  922. 

  923. 

  924. TEST (and_dreg_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    925. 

  925. {
    926. 

  926.   code[0] = R ("1100rrr000000rrr") | RANDOM_SIZE ();
    927. 

  927. }
    928. 

  928. 

  929. 

  930. TEST (and_ind_dreg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    931. 

  931. {
    932. 

  932.   randomize_mem ();
    933. 

  933.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    934. 

  934.   code[0] = (R ("1100rrr000000rrr")
    935. 

  935. 	     | RANDOM_SIZE ()
    936. 

  936. 	     | (randint (2, 4) << 3));
    937. 

  937. }
    938. 

  938. 

  939. 

  940. TEST (and_d16_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    941. 

  941. {
    942. 

  942.   randomize_mem ();
    943. 

  943.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    944. 

  944.   code[0] = R ("1100rrr000101rrr") | RANDOM_SIZE ();
    945. 

  945.   code[1] = randint (-290, 290) & ~1;
    946. 

  946. }
    947. 

  947. 

  948. 

  949. TEST (and_absl_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    950. 

  950. {
    951. 

  951.   randomize_mem ();
    952. 

  952.   code[0] = R ("1100rrr000111001") | RANDOM_SIZE ();
    953. 

  953.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    954. 

  954. }
    955. 

  955. 

  956. 

  957. TEST (andbw_const_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    958. 

  958. {
    959. 

  959.   code[0] = R ("1100rrr00r111100");  /* randomly byte or word */
    960. 

  960.   code[1] = randnum ();
    961. 

  961. }
    962. 

  962. 

  963. 

  964. TEST (andl_const_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    965. 

  965. {
    966. 

  966.   code[0] = R ("1100rrr010111100");
    967. 

  967.   WRITE4 (1, randnum ());
    968. 

  968. }
    969. 

  969. 

  970. 

  971. TEST (and_dreg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    972. 

  972. {
    973. 

  973.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    974. 

  974.   code[0] = (R ("1100rrr100000rrr")
    975. 

  975. 	     | RANDOM_SIZE ()
    976. 

  976. 	     | (randint (2, 4) << 3));
    977. 

  977. }
    978. 

  978. 

  979. 

  980. TEST (and_dreg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    981. 

  981. {
    982. 

  982.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    983. 

  983.   code[0] = R ("1100rrr100101rrr") | RANDOM_SIZE ();
    984. 

  984.   code[1] = randint (-290, 290) & ~1;
    985. 

  985. }
    986. 

  986. 

  987. 

  988. TEST (and_dreg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    989. 

  989. {
    990. 

  990.   code[0] = R ("1100rrr100111001") | RANDOM_SIZE ();
    991. 

  991.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    992. 

  992. }
    993. 

  993. 

  994. 

  995. TEST (andibw_dreg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    996. 

  996. {
    997. 

  997.   code[0] = R ("000000100r000rrr");
    998. 

  998.   code[1] = randnum ();
    999. 

  999. }
    1000. 

  1000. 

  1001. 

  1002. TEST (andil_dreg, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    1003. 

  1003. {
    1004. 

  1004.   code[0] = R ("0000001010000rrr");
    1005. 

  1005.   WRITE4 (1, randnum ());
    1006. 

  1006. }
    1007. 

  1007. 

  1008. 

  1009. TEST (andibw_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1010. 

  1010. {
    1011. 

  1011.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1012. 

  1012.   code[0] = R ("000000100r000rrr") | (randint (2, 4) << 3);
    1013. 

  1013.   code[1] = randnum ();
    1014. 

  1014. }
    1015. 

  1015. 

  1016. 

  1017. TEST (andil_ind, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1018. 

  1018. {
    1019. 

  1019.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1020. 

  1020.   code[0] = R ("0000001010000rrr") | (randint (2, 4) << 3);
    1021. 

  1021.   WRITE4 (1, randnum ());
    1022. 

  1022. }
    1023. 

  1023. 

  1024. 

  1025. TEST (andibw_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1026. 

  1026. {
    1027. 

  1027.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1028. 

  1028.   code[0] = R ("000000100r101rrr");  /* randomly either byte or word. */
    1029. 

  1029.   code[1] = randnum ();
    1030. 

  1030.   code[2] = randint (-290, 290) & ~1;
    1031. 

  1031. }
    1032. 

  1032. 

  1033. 

  1034. TEST (andil_d16, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1035. 

  1035. {
    1036. 

  1036.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1037. 

  1037.   code[0] = R ("0000001010101rrr");
    1038. 

  1038.   WRITE4 (1, randnum ());
    1039. 

  1039.   code[3] = randint (-290, 290) & ~1;
    1040. 

  1040. }
    1041. 

  1041. 

  1042. 

  1043. TEST (andibw_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1044. 

  1044. {
    1045. 

  1045.   code[0] = R ("000000100r111001");
    1046. 

  1046.   code[1] = randnum ();
    1047. 

  1047.   WRITE4 (2, randint (MEM + 4, MEMEND - 4) & ~1);
    1048. 

  1048. }
    1049. 

  1049. 

  1050. 

  1051. TEST (andil_absl, ALL_CCS, 5, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1052. 

  1052. {
    1053. 

  1053.   code[0] = B ("0000001010111001");
    1054. 

  1054.   WRITE4 (1, randnum ());
    1055. 

  1055.   WRITE4 (3, randint (MEM + 4, MEMEND - 4) & ~1);
    1056. 

  1056. }
    1057. 

  1057. 

  1058. 

  1059. TEST (andi_to_ccr, ALL_CCS, 2, WONT_CHANGE_MEMORY, 32)
    1060. 

  1060. {
    1061. 

  1061.   code[0] = B ("0000001000111100");
    1062. 

  1062.   code[1] = times_called;
    1063. 

  1063. }
    1064. 

  1064. 

  1065. 

  1066. TEST (asl_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1067. 

  1067. {
    1068. 

  1068.   code[0] = R ("1110rrr100100rrr") | RANDOM_SIZE ();
    1069. 

  1069. }
    1070. 

  1070. 

  1071. 

  1072. TEST (asl_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1073. 

  1073. {
    1074. 

  1074.   code[0] = R ("1110rrr100000rrr") | RANDOM_SIZE ();
    1075. 

  1075. }
    1076. 

  1076. 

  1077. 

  1078. TEST (asl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1079. 

  1079. {
    1080. 

  1080.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    1081. 

  1081.   code[0] = R ("1110000111000rrr") | (randint (2, 4) << 3);
    1082. 

  1082. }
    1083. 

  1083. 

  1084. 

  1085. TEST (asl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1086. 

  1086. {
    1087. 

  1087.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1088. 

  1088.   code[0] = R ("1110000111101rrr");
    1089. 

  1089.   code[1] = randint (-290, 290) & ~1;
    1090. 

  1090. }
    1091. 

  1091. 

  1092. 

  1093. TEST (asl_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1094. 

  1094. {
    1095. 

  1095.   code[0] = B ("1110000111111001");
    1096. 

  1096.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    1097. 

  1097. }
    1098. 

  1098. 

  1099. 

  1100. TEST (asr_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1101. 

  1101. {
    1102. 

  1102.   code[0] = R ("1110rrr000100rrr") | RANDOM_SIZE ();
    1103. 

  1103. }
    1104. 

  1104. 

  1105. 

  1106. TEST (asr_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1107. 

  1107. {
    1108. 

  1108.   code[0] = R ("1110rrr000000rrr") | RANDOM_SIZE ();
    1109. 

  1109. }
    1110. 

  1110. 

  1111. 

  1112. TEST (asr_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1113. 

  1113. {
    1114. 

  1114.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    1115. 

  1115.   code[0] = R ("1110000011000rrr") | (randint (2, 4) << 3);
    1116. 

  1116. }
    1117. 

  1117. 

  1118. 

  1119. TEST (asr_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1120. 

  1120. {
    1121. 

  1121.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1122. 

  1122.   code[0] = R ("1110000011101rrr");
    1123. 

  1123.   code[1] = randint (-290, 290) & ~1;
    1124. 

  1124. }
    1125. 

  1125. 

  1126. 

  1127. TEST (asr_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1128. 

  1128. {
    1129. 

  1129.   code[0] = B ("1110000011111001");
    1130. 

  1130.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    1131. 

  1131. }
    1132. 

  1132. 

  1133. 

  1134. TEST (lsl_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1135. 

  1135. {
    1136. 

  1136.   code[0] = R ("1110rrr100101rrr") | RANDOM_SIZE ();
    1137. 

  1137. }
    1138. 

  1138. 

  1139. 

  1140. TEST (lsl_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1141. 

  1141. {
    1142. 

  1142.   code[0] = R ("1110rrr100001rrr") | RANDOM_SIZE ();
    1143. 

  1143. }
    1144. 

  1144. 

  1145. 

  1146. TEST (lsl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1147. 

  1147. {
    1148. 

  1148.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    1149. 

  1149.   code[0] = R ("1110001111000rrr") | (randint (2, 4) << 3);
    1150. 

  1150. }
    1151. 

  1151. 

  1152. 

  1153. TEST (lsl_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1154. 

  1154. {
    1155. 

  1155.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1156. 

  1156.   code[0] = R ("1110001111101rrr");
    1157. 

  1157.   code[1] = randint (-290, 290) & ~1;
    1158. 

  1158. }
    1159. 

  1159. 

  1160. 

  1161. TEST (lsl_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1162. 

  1162. {
    1163. 

  1163.   code[0] = B ("1110001111111001");
    1164. 

  1164.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    1165. 

  1165. }
    1166. 

  1166. 

  1167. 

  1168. TEST (lsr_dx_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1169. 

  1169. {
    1170. 

  1170.   code[0] = R ("1110rrr000101rrr") | RANDOM_SIZE ();
    1171. 

  1171. }
    1172. 

  1172. 

  1173. 

  1174. TEST (lsr_const_dy, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1175. 

  1175. {
    1176. 

  1176.   code[0] = R ("1110rrr000001rrr") | RANDOM_SIZE ();
    1177. 

  1177. }
    1178. 

  1178. 

  1179. 

  1180. TEST (lsr_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1181. 

  1181. {
    1182. 

  1182.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 1);
    1183. 

  1183.   code[0] = R ("1110001011000rrr") | (randint (2, 4) << 3);
    1184. 

  1184. }
    1185. 

  1185. 

  1186. 

  1187. TEST (lsr_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1188. 

  1188. {
    1189. 

  1189.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 1);
    1190. 

  1190.   code[0] = R ("1110001011101rrr");
    1191. 

  1191.   code[1] = randint (-290, 290) & ~1;
    1192. 

  1192. }
    1193. 

  1193. 

  1194. 

  1195. TEST (lsr_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1196. 

  1196. {
    1197. 

  1197.   code[0] = B ("1110001011111001");
    1198. 

  1198.   WRITE4 (1, randint (MEM + 4, MEMEND - 4) & ~1);
    1199. 

  1199. }
    1200. 

  1200. 

  1201. 

  1202. #define BCC_TEST_B(bits) \
    1203. 

  1203.   code[0] = 0x6004 | ((bits) << 8);  /* b?? * + 4 */   \
    1204. 

  1204.   code[1] = B ("0111000000000000");  /* moveq #0,d0 */ \
    1205. 

  1205.   code[2] = 0x6002;                  /* bra * + 2 */   \
    1206. 

  1206.   code[3] = B ("0111000000000001");  /* moveq #1,d0 */ \
    1207. 

  1207.   code[4] = NOP_OPCODE               /* nop */
    1208. 

  1208. 

  1209. TEST (bra_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x0); }
    1210. 

  1210. /* 0x1 is reserved for bsr */
    1211. 

  1211. TEST (bhi_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x2); }
    1212. 

  1212. TEST (bls_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x3); }
    1213. 

  1213. TEST (bcc_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x4); }
    1214. 

  1214. TEST (bcs_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x5); }
    1215. 

  1215. TEST (bne_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x6); }
    1216. 

  1216. TEST (beq_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x7); }
    1217. 

  1217. TEST (bvc_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x8); }
    1218. 

  1218. TEST (bvs_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0x9); }
    1219. 

  1219. TEST (bpl_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xA); }
    1220. 

  1220. TEST (bmi_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xB); }
    1221. 

  1221. TEST (bge_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xC); }
    1222. 

  1222. TEST (blt_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xD); }
    1223. 

  1223. TEST (bgt_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xE); }
    1224. 

  1224. TEST (ble_b, ALL_CCS, 5, WONT_CHANGE_MEMORY, 2) { BCC_TEST_B (0xF); }
    1225. 

  1225. 

  1226. #undef BCC_TEST_B
    1227. 

  1227. 

  1228. #define BCC_TEST_W(bits) \
    1229. 

  1229.   code[0] = 0x6000 | ((bits) << 8);    /* b?? * + 8   */ \
    1230. 

  1230.   code[1] = 0x0006;                    /* (offset)    */ \
    1231. 

  1231.   code[2] = B ("0111000000000000");    /* moveq #0,d0 */ \
    1232. 

  1232.   code[3] = 0x6002;                    /* bra * + 2   */ \
    1233. 

  1233.   code[4] = B ("0111000000000001");    /* moveq #1,d0 */ \
    1234. 

  1234.   code[5] = NOP_OPCODE                 /* nop         */
    1235. 

  1235. 

  1236. TEST (bra_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x0); }
    1237. 

  1237. /* 0x1 is reserved for bsr */
    1238. 

  1238. TEST (bhi_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x2); }
    1239. 

  1239. TEST (bls_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x3); }
    1240. 

  1240. TEST (bcc_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x4); }
    1241. 

  1241. TEST (bcs_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x5); }
    1242. 

  1242. TEST (bne_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x6); }
    1243. 

  1243. TEST (beq_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x7); }
    1244. 

  1244. TEST (bvc_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x8); }
    1245. 

  1245. TEST (bvs_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0x9); }
    1246. 

  1246. TEST (bpl_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xA); }
    1247. 

  1247. TEST (bmi_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xB); }
    1248. 

  1248. TEST (bge_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xC); }
    1249. 

  1249. TEST (blt_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xD); }
    1250. 

  1250. TEST (bgt_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xE); }
    1251. 

  1251. TEST (ble_w, ALL_CCS, 6, WONT_CHANGE_MEMORY, 2) { BCC_TEST_W (0xF); }
    1252. 

  1252. 

  1253. #undef BCC_TEST_W
    1254. 

  1254. 

  1255. #define BCC_TEST_L(bits) \
    1256. 

  1256.   code[0] = 0x60FF | ((bits) << 8);    /* b?? * + 8   */ \
    1257. 

  1257.   code[1] = 0x0000;                    /* (offset hi) */ \
    1258. 

  1258.   code[2] = 0x0008;                    /* (offset lo) */ \
    1259. 

  1259.   code[3] = B ("0111000000000000");    /* moveq #0,d0 */ \
    1260. 

  1260.   code[4] = 0x6002;                    /* bra * + 2   */ \
    1261. 

  1261.   code[5] = B ("0111000000000001");    /* moveq #1,d0 */ \
    1262. 

  1262.   code[6] = NOP_OPCODE                 /* nop         */
    1263. 

  1263. 

  1264. TEST (bra_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x0); }
    1265. 

  1265. /* 0x1 is reserved for bsr */
    1266. 

  1266. TEST (bhi_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x2); }
    1267. 

  1267. TEST (bls_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x3); }
    1268. 

  1268. TEST (bcc_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x4); }
    1269. 

  1269. TEST (bcs_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x5); }
    1270. 

  1270. TEST (bne_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x6); }
    1271. 

  1271. TEST (beq_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x7); }
    1272. 

  1272. TEST (bvc_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x8); }
    1273. 

  1273. TEST (bvs_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0x9); }
    1274. 

  1274. TEST (bpl_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xA); }
    1275. 

  1275. TEST (bmi_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xB); }
    1276. 

  1276. TEST (bge_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xC); }
    1277. 

  1277. TEST (blt_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xD); }
    1278. 

  1278. TEST (bgt_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xE); }
    1279. 

  1279. TEST (ble_l, ALL_CCS, 7, WONT_CHANGE_MEMORY, 2) { BCC_TEST_L (0xF); }
    1280. 

  1280. 

  1281. #undef BCC_TEST_L
    1282. 

  1282. 

  1283. 

  1284. TEST (bchg_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1285. 

  1285. {
    1286. 

  1286.   code[0] = R ("0000rrr101000rrr");
    1287. 

  1287. }
    1288. 

  1288. 

  1289. 

  1290. TEST (bchg_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1291. 

  1291. {
    1292. 

  1292.   code[0] = R ("0000100001000rrr");
    1293. 

  1293.   code[1] = randint (0, 65535);
    1294. 

  1294. }
    1295. 

  1295. 

  1296. 

  1297. TEST (bchg_reg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1298. 

  1298. {
    1299. 

  1299.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1300. 

  1300.   code[0] = R ("0000rrr101000rrr") | (randint (2, 4) << 3);
    1301. 

  1301. }
    1302. 

  1302. 

  1303. 

  1304. TEST (bchg_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1305. 

  1305. {
    1306. 

  1306.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1307. 

  1307.   code[0] = R ("0000100001000rrr") | (randint (2, 4) << 3);
    1308. 

  1308.   code[1] = randint (0, 65535);
    1309. 

  1309. }
    1310. 

  1310. 

  1311. 

  1312. TEST (bchg_reg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1313. 

  1313. {
    1314. 

  1314.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1315. 

  1315.   code[0] = R ("0000rrr101101rrr");
    1316. 

  1316.   code[1] = randint (-290, 290);
    1317. 

  1317. }
    1318. 

  1318. 

  1319. 

  1320. TEST (bchg_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1321. 

  1321. {
    1322. 

  1322.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1323. 

  1323.   code[0] = R ("0000100001101rrr");
    1324. 

  1324.   code[1] = randint (0, 65535);
    1325. 

  1325.   code[2] = randint (-290, 290);
    1326. 

  1326. }
    1327. 

  1327. 

  1328. 

  1329. TEST (bchg_reg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1330. 

  1330. {
    1331. 

  1331.   code[0] = R ("0000rrr101111001");
    1332. 

  1332.   WRITE4 (1, randint (MEM + 4, MEMEND - 4));
    1333. 

  1333. }
    1334. 

  1334. 

  1335. 

  1336. TEST (bchg_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1337. 

  1337. {
    1338. 

  1338.   code[0] = R ("0000100001111001");
    1339. 

  1339.   code[1] = randint (0, 65535);
    1340. 

  1340.   WRITE4 (2, randint (MEM + 4, MEMEND - 4));
    1341. 

  1341. }
    1342. 

  1342. 

  1343. 

  1344. TEST (bclr_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1345. 

  1345. {
    1346. 

  1346.   code[0] = R ("0000rrr110000rrr");
    1347. 

  1347. }
    1348. 

  1348. 

  1349. 

  1350. TEST (bclr_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1351. 

  1351. {
    1352. 

  1352.   code[0] = R ("0000100010000rrr");
    1353. 

  1353.   code[1] = randint (0, 65535);
    1354. 

  1354. }
    1355. 

  1355. 

  1356. 

  1357. TEST (bclr_reg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1358. 

  1358. {
    1359. 

  1359.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1360. 

  1360.   code[0] = R ("0000rrr110000rrr") | (randint (2, 4) << 3);
    1361. 

  1361. }
    1362. 

  1362. 

  1363. 

  1364. TEST (bclr_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1365. 

  1365. {
    1366. 

  1366.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1367. 

  1367.   code[0] = R ("0000100010000rrr") | (randint (2, 4) << 3);
    1368. 

  1368.   code[1] = randint (0, 65535);
    1369. 

  1369. }
    1370. 

  1370. 

  1371. 

  1372. TEST (bclr_reg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1373. 

  1373. {
    1374. 

  1374.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1375. 

  1375.   code[0] = R ("0000rrr110101rrr");
    1376. 

  1376.   code[1] = randint (-290, 290);
    1377. 

  1377. }
    1378. 

  1378. 

  1379. 

  1380. TEST (bclr_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1381. 

  1381. {
    1382. 

  1382.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1383. 

  1383.   code[0] = R ("0000100010101rrr");
    1384. 

  1384.   code[1] = randint (0, 65535);
    1385. 

  1385.   code[2] = randint (-290, 290);
    1386. 

  1386. }
    1387. 

  1387. 

  1388. 

  1389. TEST (bclr_reg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1390. 

  1390. {
    1391. 

  1391.   code[0] = R ("0000rrr110111001");
    1392. 

  1392.   WRITE4 (1, randint (MEM + 4, MEMEND - 4));
    1393. 

  1393. }
    1394. 

  1394. 

  1395. 

  1396. TEST (bclr_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1397. 

  1397. {
    1398. 

  1398.   code[0] = R ("0000100010111001");
    1399. 

  1399.   code[1] = randint (0, 65535);
    1400. 

  1400.   WRITE4 (2, randint (MEM + 4, MEMEND - 4));
    1401. 

  1401. }
    1402. 

  1402. 

  1403. 

  1404. TEST (bset_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1405. 

  1405. {
    1406. 

  1406.   code[0] = R ("0000rrr111000rrr");
    1407. 

  1407. }
    1408. 

  1408. 

  1409. 

  1410. TEST (bset_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1411. 

  1411. {
    1412. 

  1412.   code[0] = R ("0000100011000rrr");
    1413. 

  1413.   code[1] = randint (0, 65535);
    1414. 

  1414. }
    1415. 

  1415. 

  1416. 

  1417. TEST (bset_reg_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1418. 

  1418. {
    1419. 

  1419.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1420. 

  1420.   code[0] = R ("0000rrr111000rrr") | (randint (2, 4) << 3);
    1421. 

  1421. }
    1422. 

  1422. 

  1423. 

  1424. TEST (bset_const_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1425. 

  1425. {
    1426. 

  1426.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1427. 

  1427.   code[0] = R ("0000100011000rrr") | (randint (2, 4) << 3);
    1428. 

  1428.   code[1] = randint (0, 65535);
    1429. 

  1429. }
    1430. 

  1430. 

  1431. 

  1432. TEST (bset_reg_d16, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1433. 

  1433. {
    1434. 

  1434.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1435. 

  1435.   code[0] = R ("0000rrr111101rrr");
    1436. 

  1436.   code[1] = randint (-290, 290);
    1437. 

  1437. }
    1438. 

  1438. 

  1439. 

  1440. TEST (bset_const_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1441. 

  1441. {
    1442. 

  1442.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1443. 

  1443.   code[0] = R ("0000100011101rrr");
    1444. 

  1444.   code[1] = randint (0, 65535);
    1445. 

  1445.   code[2] = randint (-290, 290);
    1446. 

  1446. }
    1447. 

  1447. 

  1448. 

  1449. TEST (bset_reg_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1450. 

  1450. {
    1451. 

  1451.   code[0] = R ("0000rrr111111001");
    1452. 

  1452.   WRITE4 (1, randint (MEM + 4, MEMEND - 4));
    1453. 

  1453. }
    1454. 

  1454. 

  1455. 

  1456. TEST (bset_const_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1457. 

  1457. {
    1458. 

  1458.   code[0] = R ("0000100011111001");
    1459. 

  1459.   code[1] = randint (0, 65535);
    1460. 

  1460.   WRITE4 (2, randint (MEM + 4, MEMEND - 4));
    1461. 

  1461. }
    1462. 

  1462. 

  1463. 

  1464. TEST (btst_reg_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1465. 

  1465. {
    1466. 

  1466.   code[0] = R ("0000rrr100000rrr");
    1467. 

  1467. }
    1468. 

  1468. 

  1469. 

  1470. TEST (btst_const_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1471. 

  1471. {
    1472. 

  1472.   code[0] = R ("0000100000000rrr");
    1473. 

  1473.   code[1] = randint (0, 65535);
    1474. 

  1474. }
    1475. 

  1475. 

  1476. 

  1477. TEST (btst_reg_ind, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1478. 

  1478. {
    1479. 

  1479.   randomize_mem ();
    1480. 

  1480.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1481. 

  1481.   code[0] = R ("0000rrr100000rrr") | (randint (2, 4) << 3);
    1482. 

  1482. }
    1483. 

  1483. 

  1484. 

  1485. TEST (btst_const_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1486. 

  1486. {
    1487. 

  1487.   randomize_mem ();
    1488. 

  1488.   randomize_regs (8, 8 + 7, MEM + 50, MEMEND - 50, 0);
    1489. 

  1489.   code[0] = R ("0000100000000rrr") | (randint (2, 4) << 3);
    1490. 

  1490.   code[1] = randint (0, 65535);
    1491. 

  1491. }
    1492. 

  1492. 

  1493. 

  1494. TEST (btst_reg_d16, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1495. 

  1495. {
    1496. 

  1496.   randomize_mem ();
    1497. 

  1497.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1498. 

  1498.   code[0] = R ("0000rrr100101rrr");
    1499. 

  1499.   code[1] = randint (-290, 290);
    1500. 

  1500. }
    1501. 

  1501. 

  1502. 

  1503. TEST (btst_const_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    1504. 

  1504. {
    1505. 

  1505.   randomize_mem ();
    1506. 

  1506.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0);
    1507. 

  1507.   code[0] = R ("0000100000101rrr");
    1508. 

  1508.   code[1] = randint (0, 65535);
    1509. 

  1509.   code[2] = randint (-290, 290);
    1510. 

  1510. }
    1511. 

  1511. 

  1512. 

  1513. TEST (btst_reg_absl, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    1514. 

  1514. {
    1515. 

  1515.   randomize_mem ();
    1516. 

  1516.   code[0] = R ("0000rrr100111001");
    1517. 

  1517.   WRITE4 (1, randint (MEM + 4, MEMEND - 4));
    1518. 

  1518. }
    1519. 

  1519. 

  1520. 

  1521. TEST (btst_const_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
    1522. 

  1522. {
    1523. 

  1523.   randomize_mem ();
    1524. 

  1524.   code[0] = B ("0000100000111001");
    1525. 

  1525.   code[1] = randint (0, 65535);
    1526. 

  1526.   WRITE4 (2, randint (MEM + 4, MEMEND - 4));
    1527. 

  1527. }
    1528. 

  1528. 

  1529. 

  1530. TEST (bfchg_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1531. 

  1531. {
    1532. 

  1532.   code[0] = R ("1110101011000rrr");
    1533. 

  1533.   code[1] = randint (0, 65535);
    1534. 

  1534. }
    1535. 

  1535. 

  1536. 

  1537. TEST (bfchg_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1538. 

  1538. {
    1539. 

  1539.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1540. 

  1540.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1541. 

  1541.   code[0] = R ("1110101011010rrr");
    1542. 

  1542.   code[1] = randint (0, 65535);
    1543. 

  1543. }
    1544. 

  1544. 

  1545. 

  1546. TEST (bfchg_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1547. 

  1547. {
    1548. 

  1548.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1549. 

  1549.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1550. 

  1550.   code[0] = R ("1110101011101rrr");
    1551. 

  1551.   code[1] = randint (0, 65535);
    1552. 

  1552.   code[2] = randint (-130, 130);
    1553. 

  1553. }
    1554. 

  1554. 

  1555. 

  1556. TEST (bfchg_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1557. 

  1557. {
    1558. 

  1558.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1559. 

  1559.   code[0] = B ("1110101011111001");
    1560. 

  1560.   code[1] = randint (0, 65535);
    1561. 

  1561.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1562. 

  1562. }
    1563. 

  1563. 

  1564. 

  1565. TEST (bfclr_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1566. 

  1566. {
    1567. 

  1567.   code[0] = R ("1110110011000rrr");
    1568. 

  1568.   code[1] = randint (0, 65535);
    1569. 

  1569. }
    1570. 

  1570. 

  1571. 

  1572. TEST (bfclr_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1573. 

  1573. {
    1574. 

  1574.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1575. 

  1575.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1576. 

  1576.   code[0] = R ("1110110011010rrr");
    1577. 

  1577.   code[1] = randint (0, 65535);
    1578. 

  1578. }
    1579. 

  1579. 

  1580. 

  1581. TEST (bfclr_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1582. 

  1582. {
    1583. 

  1583.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1584. 

  1584.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1585. 

  1585.   code[0] = R ("1110110011101rrr");
    1586. 

  1586.   code[1] = randint (0, 65535);
    1587. 

  1587.   code[2] = randint (-130, 130);
    1588. 

  1588. }
    1589. 

  1589. 

  1590. 

  1591. TEST (bfclr_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1592. 

  1592. {
    1593. 

  1593.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1594. 

  1594.   code[0] = B ("1110110011111001");
    1595. 

  1595.   code[1] = randint (0, 65535);
    1596. 

  1596.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1597. 

  1597. }
    1598. 

  1598. 

  1599. 

  1600. TEST (bfset_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1601. 

  1601. {
    1602. 

  1602.   code[0] = R ("1110111011000rrr");
    1603. 

  1603.   code[1] = randint (0, 65535);
    1604. 

  1604. }
    1605. 

  1605. 

  1606. 

  1607. TEST (bfset_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1608. 

  1608. {
    1609. 

  1609.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1610. 

  1610.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1611. 

  1611.   code[0] = R ("1110111011010rrr");
    1612. 

  1612.   code[1] = randint (0, 65535);
    1613. 

  1613. }
    1614. 

  1614. 

  1615. 

  1616. TEST (bfset_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1617. 

  1617. {
    1618. 

  1618.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1619. 

  1619.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1620. 

  1620.   code[0] = R ("1110111011101rrr");
    1621. 

  1621.   code[1] = randint (0, 65535);
    1622. 

  1622.   code[2] = randint (-130, 130);
    1623. 

  1623. }
    1624. 

  1624. 

  1625. 

  1626. TEST (bfset_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1627. 

  1627. {
    1628. 

  1628.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1629. 

  1629.   code[0] = B ("1110111011111001");
    1630. 

  1630.   code[1] = randint (0, 65535);
    1631. 

  1631.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1632. 

  1632. }
    1633. 

  1633. 

  1634. 

  1635. TEST (bftst_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1636. 

  1636. {
    1637. 

  1637.   code[0] = R ("1110100011000rrr");
    1638. 

  1638.   code[1] = randint (0, 65535);
    1639. 

  1639. }
    1640. 

  1640. 

  1641. 

  1642. TEST (bftst_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1643. 

  1643. {
    1644. 

  1644.   randomize_mem ();
    1645. 

  1645.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1646. 

  1646.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1647. 

  1647.   code[0] = R ("1110100011010rrr");
    1648. 

  1648.   code[1] = randint (0, 65535);
    1649. 

  1649. }
    1650. 

  1650. 

  1651. 

  1652. TEST (bftst_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    1653. 

  1653. {
    1654. 

  1654.   randomize_mem ();
    1655. 

  1655.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1656. 

  1656.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1657. 

  1657.   code[0] = R ("1110100011101rrr");
    1658. 

  1658.   code[1] = randint (0, 65535);
    1659. 

  1659.   code[2] = randint (-130, 130);
    1660. 

  1660. }
    1661. 

  1661. 

  1662. 

  1663. TEST (bftst_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
    1664. 

  1664. {
    1665. 

  1665.   randomize_mem ();
    1666. 

  1666.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1667. 

  1667.   code[0] = B ("1110100011111001");
    1668. 

  1668.   code[1] = randint (0, 65535);
    1669. 

  1669.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1670. 

  1670. }
    1671. 

  1671. 

  1672. 

  1673. TEST (bfexts_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1674. 

  1674. {
    1675. 

  1675.   code[0] = R ("1110101111000rrr");
    1676. 

  1676.   code[1] = randint (0, 65535);
    1677. 

  1677. }
    1678. 

  1678. 

  1679. 

  1680. TEST (bfexts_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1681. 

  1681. {
    1682. 

  1682.   randomize_mem ();
    1683. 

  1683.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1684. 

  1684.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1685. 

  1685.   code[0] = R ("1110101111010rrr");
    1686. 

  1686.   code[1] = randint (0, 65535);
    1687. 

  1687. }
    1688. 

  1688. 

  1689. 

  1690. TEST (bfexts_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    1691. 

  1691. {
    1692. 

  1692.   randomize_mem ();
    1693. 

  1693.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1694. 

  1694.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1695. 

  1695.   code[0] = R ("1110101111101rrr");
    1696. 

  1696.   code[1] = randint (0, 65535);
    1697. 

  1697.   code[2] = randint (-130, 130);
    1698. 

  1698. }
    1699. 

  1699. 

  1700. 

  1701. TEST (bfexts_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
    1702. 

  1702. {
    1703. 

  1703.   randomize_mem ();
    1704. 

  1704.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1705. 

  1705.   code[0] = B ("1110101111111001");
    1706. 

  1706.   code[1] = randint (0, 65535);
    1707. 

  1707.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1708. 

  1708. }
    1709. 

  1709. 

  1710. 

  1711. TEST (bfextu_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1712. 

  1712. {
    1713. 

  1713.   code[0] = R ("1110100111000rrr");
    1714. 

  1714.   code[1] = randint (0, 65535);
    1715. 

  1715. }
    1716. 

  1716. 

  1717. 

  1718. TEST (bfextu_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1719. 

  1719. {
    1720. 

  1720.   randomize_mem ();
    1721. 

  1721.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1722. 

  1722.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1723. 

  1723.   code[0] = R ("1110100111010rrr");
    1724. 

  1724.   code[1] = randint (0, 65535);
    1725. 

  1725. }
    1726. 

  1726. 

  1727. 

  1728. TEST (bfextu_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    1729. 

  1729. {
    1730. 

  1730.   randomize_mem ();
    1731. 

  1731.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1732. 

  1732.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1733. 

  1733.   code[0] = R ("1110100111101rrr");
    1734. 

  1734.   code[1] = randint (0, 65535);
    1735. 

  1735.   code[2] = randint (-130, 130);
    1736. 

  1736. }
    1737. 

  1737. 

  1738. 

  1739. TEST (bfextu_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
    1740. 

  1740. {
    1741. 

  1741.   randomize_mem ();
    1742. 

  1742.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1743. 

  1743.   code[0] = B ("1110100111111001");
    1744. 

  1744.   code[1] = randint (0, 65535);
    1745. 

  1745.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1746. 

  1746. }
    1747. 

  1747. 

  1748. 

  1749. TEST (bfffo_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1750. 

  1750. {
    1751. 

  1751.   code[0] = R ("1110110111000rrr");
    1752. 

  1752.   code[1] = randint (0, 65535);
    1753. 

  1753. }
    1754. 

  1754. 

  1755. 

  1756. TEST (bfffo_ind, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1757. 

  1757. {
    1758. 

  1758.   randomize_mem ();
    1759. 

  1759.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1760. 

  1760.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1761. 

  1761.   code[0] = R ("1110110111010rrr");
    1762. 

  1762.   code[1] = randint (0, 65535);
    1763. 

  1763. }
    1764. 

  1764. 

  1765. 

  1766. TEST (bfffo_d16, ALL_CCS, 3, WONT_CHANGE_MEMORY, NO_LIMIT)
    1767. 

  1767. {
    1768. 

  1768.   randomize_mem ();
    1769. 

  1769.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1770. 

  1770.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1771. 

  1771.   code[0] = R ("1110110111101rrr");
    1772. 

  1772.   code[1] = randint (0, 65535);
    1773. 

  1773.   code[2] = randint (-130, 130);
    1774. 

  1774. }
    1775. 

  1775. 

  1776. 

  1777. TEST (bfffo_absl, ALL_CCS, 4, WONT_CHANGE_MEMORY, NO_LIMIT)
    1778. 

  1778. {
    1779. 

  1779.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1780. 

  1780.   randomize_mem ();
    1781. 

  1781.   code[0] = B ("1110110111111001");
    1782. 

  1782.   code[1] = randint (0, 65535);
    1783. 

  1783.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1784. 

  1784. }
    1785. 

  1785. 

  1786. 

  1787. TEST (bfins_reg, ALL_CCS, 2, WONT_CHANGE_MEMORY, NO_LIMIT)
    1788. 

  1788. {
    1789. 

  1789.   code[0] = R ("1110111111000rrr");
    1790. 

  1790.   code[1] = randint (0, 65535);
    1791. 

  1791. }
    1792. 

  1792. 

  1793. 

  1794. TEST (bfins_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1795. 

  1795. {
    1796. 

  1796.   randomize_regs (0, 7, -250 * 8, 250 * 8, 0);           /* Offset/width */
    1797. 

  1797.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1798. 

  1798.   code[0] = R ("1110111111010rrr");
    1799. 

  1799.   code[1] = randint (0, 65535);
    1800. 

  1800. }
    1801. 

  1801. 

  1802. 

  1803. TEST (bfins_d16, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1804. 

  1804. {
    1805. 

  1805.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1806. 

  1806.   randomize_regs (8, 8 + 7, MEM + 300, MEMEND - 300, 0); /* Base */
    1807. 

  1807.   code[0] = R ("1110111111101rrr");
    1808. 

  1808.   code[1] = randint (0, 65535);
    1809. 

  1809.   code[2] = randint (-130, 130);
    1810. 

  1810. }
    1811. 

  1811. 

  1812. 

  1813. TEST (bfins_absl, ALL_CCS, 4, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1814. 

  1814. {
    1815. 

  1815.   randomize_regs (0, 7, -130 * 8, 130 * 8, 0);           /* Offset/width */
    1816. 

  1816.   code[0] = B ("1110111111111001");
    1817. 

  1817.   code[1] = randint (0, 65535);
    1818. 

  1818.   WRITE4 (2, randint (MEM + 200, MEMEND - 200));
    1819. 

  1819. }
    1820. 

  1820. 

  1821. 

  1822. TEST (bsr_b, ALL_CCS, 6, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1823. 

  1823. {
    1824. 

  1824.   randomize_regs (15, 15, MEM + 50, MEMEND - 50, 1);  /* random sp */
    1825. 

  1825.   code[0] = 0x6104;                  /* bsr * + 4   */
    1826. 

  1826.   code[1] = 0x5280;                  /* addql #1,d0 */
    1827. 

  1827.   code[2] = 0x6004;                  /* bra * + 4 */
    1828. 

  1828.   code[3] = R ("01110000rrrrrrrr");  /* moveq #<random>,d0 */
    1829. 

  1829.   code[4] = 0x4E75;                  /* rts */
    1830. 

  1830.   code[5] = NOP_OPCODE;              /* nop */
    1831. 

  1831. }
    1832. 

  1832. 

  1833. 

  1834. TEST (bsr_w, ALL_CCS, 7, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1835. 

  1835. {
    1836. 

  1836.   randomize_regs (15, 15, MEM + 50, MEMEND - 50, 1);  /* random sp */
    1837. 

  1837.   code[0] = 0x6100;                  /* bsr * + 6   */
    1838. 

  1838.   code[1] = 0x0006;
    1839. 

  1839.   code[2] = 0x5280;                  /* addql #1,d0 */
    1840. 

  1840.   code[3] = 0x6004;                  /* bra * + 4 */
    1841. 

  1841.   code[4] = R ("01110000rrrrrrrr");  /* moveq #<random>,d0 */
    1842. 

  1842.   code[5] = 0x4E75;                  /* rts */
    1843. 

  1843.   code[6] = NOP_OPCODE;              /* nop */
    1844. 

  1844. }
    1845. 

  1845. 

  1846. 

  1847. TEST (bsr_l, ALL_CCS, 8, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1848. 

  1848. {
    1849. 

  1849.   randomize_regs (15, 15, MEM + 50, MEMEND - 50, 1);  /* random sp */
    1850. 

  1850.   code[0] = 0x61FF;                  /* bsr * + 8   */
    1851. 

  1851.   code[1] = 0x0000;
    1852. 

  1852.   code[2] = 0x0008;
    1853. 

  1853.   code[3] = 0x5280;                  /* addql #1,d0 */
    1854. 

  1854.   code[4] = 0x6004;                  /* bra * + 4 */
    1855. 

  1855.   code[5] = R ("01110000rrrrrrrr");  /* moveq #<random>,d0 */
    1856. 

  1856.   code[6] = 0x4E75;                  /* rts */
    1857. 

  1857.   code[7] = NOP_OPCODE;              /* nop */
    1858. 

  1858. }
    1859. 

  1859. 

  1860. 

  1861. TEST (cas_ind, ALL_CCS, 2, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1862. 

  1862. {
    1863. 

  1863.   randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 1);
    1864. 

  1864.   code[0] = (R ("0000100011000rrr")
    1865. 

  1865. 	     | (randint (1, 3) << 9)    /* Random size */
    1866. 

  1866. 	     | (randint (2, 4) << 3));  /* Random amode [2, 4] */
    1867. 

  1867.   code[1] = randint (0, 65535);
    1868. 

  1868. }
    1869. 

  1869. 

  1870. 

  1871. TEST (cas2_areg, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1872. 

  1872. {
    1873. 

  1873.   randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 1);
    1874. 

  1874.   code[0] = R ("000011r011111100");  /* Randomly either word or long. */
    1875. 

  1875.   code[1] = R ("1rrr000rrr000rrr");
    1876. 

  1876.   code[2] = R ("1rrr000rrr000rrr");
    1877. 

  1877. }
    1878. 

  1878. 

  1879. 

  1880. TEST (cas2_anyreg, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1881. 

  1881. {
    1882. 

  1882.   randomize_regs (0, 7 + 8, MEM + 50, MEMEND - 50, 1);
    1883. 

  1883.   code[0] = R ("000011r011111100");  /* Randomly either word or long. */
    1884. 

  1884.   code[1] = R ("rrrr000rrr000rrr");
    1885. 

  1885.   code[2] = R ("rrrr000rrr000rrr");
    1886. 

  1886. }
    1887. 

  1887. 

  1888. 

  1889. TEST (clr_reg, ALL_CCS, 1, WONT_CHANGE_MEMORY, NO_LIMIT)
    1890. 

  1890. {
    1891. 

  1891.   code[0] = R ("0100001000000rrr") | RANDOM_SIZE ();
    1892. 

  1892. }
    1893. 

  1893. 

  1894. 

  1895. TEST (clrb_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1896. 

  1896. {
    1897. 

  1897.   randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 0);
    1898. 

  1898.   code[0] = R ("0100001000000rrr") | (randint (2, 4) << 3);
    1899. 

  1899. }
    1900. 

  1900. 

  1901. 

  1902. TEST (clrwl_ind, ALL_CCS, 1, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1903. 

  1903. {
    1904. 

  1904.   randomize_regs (7, 7 + 8, MEM + 50, MEMEND - 50, 1);
    1905. 

  1905.   code[0] = (R ("0100001000000rrr")
    1906. 

  1906. 	     | (randint (1, 2) << 6)   /* Randomly either word or long. */
    1907. 

  1907. 	     | (randint (2, 4) << 3)); /* Random amode [2, 4] */
    1908. 

  1908. }
    1909. 

  1909. 

  1910. 

  1911. TEST (clrb_absl, ALL_CCS, 3, MIGHT_CHANGE_MEMORY, NO_LIMIT)
    1912. 

  1912. {
    1913. 

  1913.   code[0] = B ("0100001000111001");
    1914. 

  1914.   WRITE4 (1, randint…
    1915.

Large files files are truncated, but you can click here to view the full file