1.1 diff -r 000000000000 -r 8bf1bf91a36d src/musashi/m68k_in.c 1.2 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 1.3 +++ b/src/musashi/m68k_in.c Sat Nov 27 01:13:12 2010 +0000 1.4 @@ -0,0 +1,9989 @@ 1.5 +/* ======================================================================== */ 1.6 +/* ========================= LICENSING & COPYRIGHT ======================== */ 1.7 +/* ======================================================================== */ 1.8 +/* 1.9 + * MUSASHI 1.10 + * Version 3.3 1.11 + * 1.12 + * A portable Motorola M680x0 processor emulation engine. 1.13 + * Copyright 1998-2001 Karl Stenerud. All rights reserved. 1.14 + * 1.15 + * This code may be freely used for non-commercial purposes as long as this 1.16 + * copyright notice remains unaltered in the source code and any binary files 1.17 + * containing this code in compiled form. 1.18 + * 1.19 + * All other lisencing terms must be negotiated with the author 1.20 + * (Karl Stenerud). 1.21 + * 1.22 + * The latest version of this code can be obtained at: 1.23 + * http://kstenerud.cjb.net 1.24 + */ 1.25 + 1.26 + 1.27 + 1.28 +/* Input file for m68kmake 1.29 + * ----------------------- 1.30 + * 1.31 + * All sections begin with 80 X's in a row followed by an end-of-line 1.32 + * sequence. 1.33 + * After this, m68kmake will expect to find one of the following section 1.34 + * identifiers: 1.35 + * M68KMAKE_PROTOTYPE_HEADER - header for opcode handler prototypes 1.36 + * M68KMAKE_PROTOTYPE_FOOTER - footer for opcode handler prototypes 1.37 + * M68KMAKE_TABLE_HEADER - header for opcode handler jumptable 1.38 + * M68KMAKE_TABLE_FOOTER - footer for opcode handler jumptable 1.39 + * M68KMAKE_TABLE_BODY - the table itself 1.40 + * M68KMAKE_OPCODE_HANDLER_HEADER - header for opcode handler implementation 1.41 + * M68KMAKE_OPCODE_HANDLER_FOOTER - footer for opcode handler implementation 1.42 + * M68KMAKE_OPCODE_HANDLER_BODY - body section for opcode handler implementation 1.43 + * 1.44 + * NOTE: M68KMAKE_OPCODE_HANDLER_BODY must be last in the file and 1.45 + * M68KMAKE_TABLE_BODY must be second last in the file. 1.46 + * 1.47 + * The M68KMAKE_OPHANDLER_BODY section contains the opcode handler 1.48 + * primitives themselves. Each opcode handler begins with: 1.49 + * M68KMAKE_OP(A, B, C, D) 1.50 + * 1.51 + * where A is the opcode handler name, B is the size of the operation, 1.52 + * C denotes any special processing mode, and D denotes a specific 1.53 + * addressing mode. 1.54 + * For C and D where nothing is specified, use "." 1.55 + * 1.56 + * Example: 1.57 + * M68KMAKE_OP(abcd, 8, rr, .) abcd, size 8, register to register, default EA 1.58 + * M68KMAKE_OP(abcd, 8, mm, ax7) abcd, size 8, memory to memory, register X is A7 1.59 + * M68KMAKE_OP(tst, 16, ., pcix) tst, size 16, PCIX addressing 1.60 + * 1.61 + * All opcode handler primitives end with a closing curly brace "}" at column 1 1.62 + * 1.63 + * NOTE: Do not place a M68KMAKE_OP() directive inside the opcode handler, 1.64 + * and do not put a closing curly brace at column 1 unless it is 1.65 + * marking the end of the handler! 1.66 + * 1.67 + * Inside the handler, m68kmake will recognize M68KMAKE_GET_OPER_xx_xx, 1.68 + * M68KMAKE_GET_EA_xx_xx, and M68KMAKE_CC directives, and create multiple 1.69 + * opcode handlers to handle variations in the opcode handler. 1.70 + * Note: M68KMAKE_CC will only be interpreted in condition code opcodes. 1.71 + * As well, M68KMAKE_GET_EA_xx_xx and M68KMAKE_GET_OPER_xx_xx will only 1.72 + * be interpreted on instructions where the corresponding table entry 1.73 + * specifies multiple effective addressing modes. 1.74 + * Example: 1.75 + * clr 32 . . 0100001010...... A+-DXWL... U U U 12 6 4 1.76 + * 1.77 + * This table entry says that the clr.l opcde has 7 variations (A+-DXWL). 1.78 + * It is run in user or supervisor mode for all CPUs, and uses 12 cycles for 1.79 + * 68000, 6 cycles for 68010, and 4 cycles for 68020. 1.80 + */ 1.81 + 1.82 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.83 +M68KMAKE_PROTOTYPE_HEADER 1.84 + 1.85 +#ifndef M68KOPS__HEADER 1.86 +#define M68KOPS__HEADER 1.87 + 1.88 +/* ======================================================================== */ 1.89 +/* ============================ OPCODE HANDLERS =========================== */ 1.90 +/* ======================================================================== */ 1.91 + 1.92 + 1.93 + 1.94 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.95 +M68KMAKE_PROTOTYPE_FOOTER 1.96 + 1.97 + 1.98 +/* Build the opcode handler table */ 1.99 +void m68ki_build_opcode_table(void); 1.100 + 1.101 +extern void (*m68ki_instruction_jump_table[0x10000])(void); /* opcode handler jump table */ 1.102 +extern unsigned char m68ki_cycles[][0x10000]; 1.103 + 1.104 + 1.105 +/* ======================================================================== */ 1.106 +/* ============================== END OF FILE ============================= */ 1.107 +/* ======================================================================== */ 1.108 + 1.109 +#endif /* M68KOPS__HEADER */ 1.110 + 1.111 + 1.112 + 1.113 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.114 +M68KMAKE_TABLE_HEADER 1.115 + 1.116 +/* ======================================================================== */ 1.117 +/* ========================= OPCODE TABLE BUILDER ========================= */ 1.118 +/* ======================================================================== */ 1.119 + 1.120 +#include "m68kops.h" 1.121 + 1.122 +#define NUM_CPU_TYPES 3 1.123 + 1.124 +void (*m68ki_instruction_jump_table[0x10000])(void); /* opcode handler jump table */ 1.125 +unsigned char m68ki_cycles[NUM_CPU_TYPES][0x10000]; /* Cycles used by CPU type */ 1.126 + 1.127 +/* This is used to generate the opcode handler jump table */ 1.128 +typedef struct 1.129 +{ 1.130 + void (*opcode_handler)(void); /* handler function */ 1.131 + unsigned int mask; /* mask on opcode */ 1.132 + unsigned int match; /* what to match after masking */ 1.133 + unsigned char cycles[NUM_CPU_TYPES]; /* cycles each cpu type takes */ 1.134 +} opcode_handler_struct; 1.135 + 1.136 + 1.137 +/* Opcode handler table */ 1.138 +static opcode_handler_struct m68k_opcode_handler_table[] = 1.139 +{ 1.140 +/* function mask match 000 010 020 */ 1.141 + 1.142 + 1.143 + 1.144 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.145 +M68KMAKE_TABLE_FOOTER 1.146 + 1.147 + {0, 0, 0, {0, 0, 0}} 1.148 +}; 1.149 + 1.150 + 1.151 +/* Build the opcode handler jump table */ 1.152 +void m68ki_build_opcode_table(void) 1.153 +{ 1.154 + opcode_handler_struct *ostruct; 1.155 + int instr; 1.156 + int i; 1.157 + int j; 1.158 + int k; 1.159 + 1.160 + for(i = 0; i < 0x10000; i++) 1.161 + { 1.162 + /* default to illegal */ 1.163 + m68ki_instruction_jump_table[i] = m68k_op_illegal; 1.164 + for(k=0;k<NUM_CPU_TYPES;k++) 1.165 + m68ki_cycles[k][i] = 0; 1.166 + } 1.167 + 1.168 + ostruct = m68k_opcode_handler_table; 1.169 + while(ostruct->mask != 0xff00) 1.170 + { 1.171 + for(i = 0;i < 0x10000;i++) 1.172 + { 1.173 + if((i & ostruct->mask) == ostruct->match) 1.174 + { 1.175 + m68ki_instruction_jump_table[i] = ostruct->opcode_handler; 1.176 + for(k=0;k<NUM_CPU_TYPES;k++) 1.177 + m68ki_cycles[k][i] = ostruct->cycles[k]; 1.178 + } 1.179 + } 1.180 + ostruct++; 1.181 + } 1.182 + while(ostruct->mask == 0xff00) 1.183 + { 1.184 + for(i = 0;i <= 0xff;i++) 1.185 + { 1.186 + m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler; 1.187 + for(k=0;k<NUM_CPU_TYPES;k++) 1.188 + m68ki_cycles[k][ostruct->match | i] = ostruct->cycles[k]; 1.189 + } 1.190 + ostruct++; 1.191 + } 1.192 + while(ostruct->mask == 0xf1f8) 1.193 + { 1.194 + for(i = 0;i < 8;i++) 1.195 + { 1.196 + for(j = 0;j < 8;j++) 1.197 + { 1.198 + instr = ostruct->match | (i << 9) | j; 1.199 + m68ki_instruction_jump_table[instr] = ostruct->opcode_handler; 1.200 + for(k=0;k<NUM_CPU_TYPES;k++) 1.201 + m68ki_cycles[k][instr] = ostruct->cycles[k]; 1.202 + if((instr & 0xf000) == 0xe000 && (!(instr & 0x20))) 1.203 + m68ki_cycles[0][instr] = m68ki_cycles[1][instr] = ostruct->cycles[k] + ((((j-1)&7)+1)<<1); 1.204 + } 1.205 + } 1.206 + ostruct++; 1.207 + } 1.208 + while(ostruct->mask == 0xfff0) 1.209 + { 1.210 + for(i = 0;i <= 0x0f;i++) 1.211 + { 1.212 + m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler; 1.213 + for(k=0;k<NUM_CPU_TYPES;k++) 1.214 + m68ki_cycles[k][ostruct->match | i] = ostruct->cycles[k]; 1.215 + } 1.216 + ostruct++; 1.217 + } 1.218 + while(ostruct->mask == 0xf1ff) 1.219 + { 1.220 + for(i = 0;i <= 0x07;i++) 1.221 + { 1.222 + m68ki_instruction_jump_table[ostruct->match | (i << 9)] = ostruct->opcode_handler; 1.223 + for(k=0;k<NUM_CPU_TYPES;k++) 1.224 + m68ki_cycles[k][ostruct->match | (i << 9)] = ostruct->cycles[k]; 1.225 + } 1.226 + ostruct++; 1.227 + } 1.228 + while(ostruct->mask == 0xfff8) 1.229 + { 1.230 + for(i = 0;i <= 0x07;i++) 1.231 + { 1.232 + m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler; 1.233 + for(k=0;k<NUM_CPU_TYPES;k++) 1.234 + m68ki_cycles[k][ostruct->match | i] = ostruct->cycles[k]; 1.235 + } 1.236 + ostruct++; 1.237 + } 1.238 + while(ostruct->mask == 0xffff) 1.239 + { 1.240 + m68ki_instruction_jump_table[ostruct->match] = ostruct->opcode_handler; 1.241 + for(k=0;k<NUM_CPU_TYPES;k++) 1.242 + m68ki_cycles[k][ostruct->match] = ostruct->cycles[k]; 1.243 + ostruct++; 1.244 + } 1.245 +} 1.246 + 1.247 + 1.248 +/* ======================================================================== */ 1.249 +/* ============================== END OF FILE ============================= */ 1.250 +/* ======================================================================== */ 1.251 + 1.252 + 1.253 + 1.254 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.255 +M68KMAKE_OPCODE_HANDLER_HEADER 1.256 + 1.257 +#include "m68kcpu.h" 1.258 + 1.259 +/* ======================================================================== */ 1.260 +/* ========================= INSTRUCTION HANDLERS ========================= */ 1.261 +/* ======================================================================== */ 1.262 + 1.263 + 1.264 + 1.265 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.266 +M68KMAKE_OPCODE_HANDLER_FOOTER 1.267 + 1.268 +/* ======================================================================== */ 1.269 +/* ============================== END OF FILE ============================= */ 1.270 +/* ======================================================================== */ 1.271 + 1.272 + 1.273 + 1.274 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.275 +M68KMAKE_TABLE_BODY 1.276 + 1.277 +The following table is arranged as follows: 1.278 + 1.279 +name: Opcode mnemonic 1.280 + 1.281 +size: Operation size 1.282 + 1.283 +spec proc: Special processing mode: 1.284 + .: normal 1.285 + s: static operand 1.286 + r: register operand 1.287 + rr: register to register 1.288 + mm: memory to memory 1.289 + er: effective address to register 1.290 + re: register to effective address 1.291 + dd: data register to data register 1.292 + da: data register to address register 1.293 + aa: address register to address register 1.294 + cr: control register to register 1.295 + rc: register to control register 1.296 + toc: to condition code register 1.297 + tos: to status register 1.298 + tou: to user stack pointer 1.299 + frc: from condition code register 1.300 + frs: from status register 1.301 + fru: from user stack pointer 1.302 + * for move.x, the special processing mode is a specific 1.303 + destination effective addressing mode. 1.304 + 1.305 +spec ea: Specific effective addressing mode: 1.306 + .: normal 1.307 + i: immediate 1.308 + d: data register 1.309 + a: address register 1.310 + ai: address register indirect 1.311 + pi: address register indirect with postincrement 1.312 + pd: address register indirect with predecrement 1.313 + di: address register indirect with displacement 1.314 + ix: address register indirect with index 1.315 + aw: absolute word address 1.316 + al: absolute long address 1.317 + pcdi: program counter relative with displacement 1.318 + pcix: program counter relative with index 1.319 + a7: register specified in instruction is A7 1.320 + ax7: register field X of instruction is A7 1.321 + ay7: register field Y of instruction is A7 1.322 + axy7: register fields X and Y of instruction are A7 1.323 + 1.324 +bit pattern: Pattern to recognize this opcode. "." means don't care. 1.325 + 1.326 +allowed ea: List of allowed addressing modes: 1.327 + .: not present 1.328 + A: address register indirect 1.329 + +: ARI (address register indirect) with postincrement 1.330 + -: ARI with predecrement 1.331 + D: ARI with displacement 1.332 + X: ARI with index 1.333 + W: absolute word address 1.334 + L: absolute long address 1.335 + d: program counter indirect with displacement 1.336 + x: program counter indirect with index 1.337 + I: immediate 1.338 +mode: CPU operating mode for each cpu type. U = user or supervisor, 1.339 + S = supervisor only, "." = opcode not present. 1.340 + 1.341 +cpu cycles: Base number of cycles required to execute this opcode on the 1.342 + specified CPU type. 1.343 + Use "." if CPU does not have this opcode. 1.344 + 1.345 + 1.346 + 1.347 + spec spec allowed ea mode cpu cycles 1.348 +name size proc ea bit pattern A+-DXWLdxI 0 1 2 000 010 020 comments 1.349 +====== ==== ==== ==== ================ ========== = = = === === === ============= 1.350 +M68KMAKE_TABLE_START 1.351 +1010 0 . . 1010............ .......... U U U 4 4 4 1.352 +1111 0 . . 1111............ .......... U U U 4 4 4 1.353 +abcd 8 rr . 1100...100000... .......... U U U 6 6 4 1.354 +abcd 8 mm ax7 1100111100001... .......... U U U 18 18 16 1.355 +abcd 8 mm ay7 1100...100001111 .......... U U U 18 18 16 1.356 +abcd 8 mm axy7 1100111100001111 .......... U U U 18 18 16 1.357 +abcd 8 mm . 1100...100001... .......... U U U 18 18 16 1.358 +add 8 er d 1101...000000... .......... U U U 4 4 2 1.359 +add 8 er . 1101...000...... A+-DXWLdxI U U U 4 4 2 1.360 +add 16 er d 1101...001000... .......... U U U 4 4 2 1.361 +add 16 er a 1101...001001... .......... U U U 4 4 2 1.362 +add 16 er . 1101...001...... A+-DXWLdxI U U U 4 4 2 1.363 +add 32 er d 1101...010000... .......... U U U 6 6 2 1.364 +add 32 er a 1101...010001... .......... U U U 6 6 2 1.365 +add 32 er . 1101...010...... A+-DXWLdxI U U U 6 6 2 1.366 +add 8 re . 1101...100...... A+-DXWL... U U U 8 8 4 1.367 +add 16 re . 1101...101...... A+-DXWL... U U U 8 8 4 1.368 +add 32 re . 1101...110...... A+-DXWL... U U U 12 12 4 1.369 +adda 16 . d 1101...011000... .......... U U U 8 8 2 1.370 +adda 16 . a 1101...011001... .......... U U U 8 8 2 1.371 +adda 16 . . 1101...011...... A+-DXWLdxI U U U 8 8 2 1.372 +adda 32 . d 1101...111000... .......... U U U 6 6 2 1.373 +adda 32 . a 1101...111001... .......... U U U 6 6 2 1.374 +adda 32 . . 1101...111...... A+-DXWLdxI U U U 6 6 2 1.375 +addi 8 . d 0000011000000... .......... U U U 8 8 2 1.376 +addi 8 . . 0000011000...... A+-DXWL... U U U 12 12 4 1.377 +addi 16 . d 0000011001000... .......... U U U 8 8 2 1.378 +addi 16 . . 0000011001...... A+-DXWL... U U U 12 12 4 1.379 +addi 32 . d 0000011010000... .......... U U U 16 14 2 1.380 +addi 32 . . 0000011010...... A+-DXWL... U U U 20 20 4 1.381 +addq 8 . d 0101...000000... .......... U U U 4 4 2 1.382 +addq 8 . . 0101...000...... A+-DXWL... U U U 8 8 4 1.383 +addq 16 . d 0101...001000... .......... U U U 4 4 2 1.384 +addq 16 . a 0101...001001... .......... U U U 4 4 2 1.385 +addq 16 . . 0101...001...... A+-DXWL... U U U 8 8 4 1.386 +addq 32 . d 0101...010000... .......... U U U 8 8 2 1.387 +addq 32 . a 0101...010001... .......... U U U 8 8 2 1.388 +addq 32 . . 0101...010...... A+-DXWL... U U U 12 12 4 1.389 +addx 8 rr . 1101...100000... .......... U U U 4 4 2 1.390 +addx 16 rr . 1101...101000... .......... U U U 4 4 2 1.391 +addx 32 rr . 1101...110000... .......... U U U 8 6 2 1.392 +addx 8 mm ax7 1101111100001... .......... U U U 18 18 12 1.393 +addx 8 mm ay7 1101...100001111 .......... U U U 18 18 12 1.394 +addx 8 mm axy7 1101111100001111 .......... U U U 18 18 12 1.395 +addx 8 mm . 1101...100001... .......... U U U 18 18 12 1.396 +addx 16 mm . 1101...101001... .......... U U U 18 18 12 1.397 +addx 32 mm . 1101...110001... .......... U U U 30 30 12 1.398 +and 8 er d 1100...000000... .......... U U U 4 4 2 1.399 +and 8 er . 1100...000...... A+-DXWLdxI U U U 4 4 2 1.400 +and 16 er d 1100...001000... .......... U U U 4 4 2 1.401 +and 16 er . 1100...001...... A+-DXWLdxI U U U 4 4 2 1.402 +and 32 er d 1100...010000... .......... U U U 6 6 2 1.403 +and 32 er . 1100...010...... A+-DXWLdxI U U U 6 6 2 1.404 +and 8 re . 1100...100...... A+-DXWL... U U U 8 8 4 1.405 +and 16 re . 1100...101...... A+-DXWL... U U U 8 8 4 1.406 +and 32 re . 1100...110...... A+-DXWL... U U U 12 12 4 1.407 +andi 16 toc . 0000001000111100 .......... U U U 20 16 12 1.408 +andi 16 tos . 0000001001111100 .......... S S S 20 16 12 1.409 +andi 8 . d 0000001000000... .......... U U U 8 8 2 1.410 +andi 8 . . 0000001000...... A+-DXWL... U U U 12 12 4 1.411 +andi 16 . d 0000001001000... .......... U U U 8 8 2 1.412 +andi 16 . . 0000001001...... A+-DXWL... U U U 12 12 4 1.413 +andi 32 . d 0000001010000... .......... U U U 14 14 2 1.414 +andi 32 . . 0000001010...... A+-DXWL... U U U 20 20 4 1.415 +asr 8 s . 1110...000000... .......... U U U 6 6 6 1.416 +asr 16 s . 1110...001000... .......... U U U 6 6 6 1.417 +asr 32 s . 1110...010000... .......... U U U 8 8 6 1.418 +asr 8 r . 1110...000100... .......... U U U 6 6 6 1.419 +asr 16 r . 1110...001100... .......... U U U 6 6 6 1.420 +asr 32 r . 1110...010100... .......... U U U 8 8 6 1.421 +asr 16 . . 1110000011...... A+-DXWL... U U U 8 8 5 1.422 +asl 8 s . 1110...100000... .......... U U U 6 6 8 1.423 +asl 16 s . 1110...101000... .......... U U U 6 6 8 1.424 +asl 32 s . 1110...110000... .......... U U U 8 8 8 1.425 +asl 8 r . 1110...100100... .......... U U U 6 6 8 1.426 +asl 16 r . 1110...101100... .......... U U U 6 6 8 1.427 +asl 32 r . 1110...110100... .......... U U U 8 8 8 1.428 +asl 16 . . 1110000111...... A+-DXWL... U U U 8 8 6 1.429 +bcc 8 . . 0110............ .......... U U U 8 8 6 1.430 +bcc 16 . . 0110....00000000 .......... U U U 10 10 6 1.431 +bcc 32 . . 0110....11111111 .......... . . U . . 6 1.432 +bchg 8 r . 0000...101...... A+-DXWL... U U U 8 8 4 1.433 +bchg 32 r d 0000...101000... .......... U U U 8 8 4 1.434 +bchg 8 s . 0000100001...... A+-DXWL... U U U 12 12 4 1.435 +bchg 32 s d 0000100001000... .......... U U U 12 12 4 1.436 +bclr 8 r . 0000...110...... A+-DXWL... U U U 8 10 4 1.437 +bclr 32 r d 0000...110000... .......... U U U 10 10 4 1.438 +bclr 8 s . 0000100010...... A+-DXWL... U U U 12 12 4 1.439 +bclr 32 s d 0000100010000... .......... U U U 14 14 4 1.440 +bfchg 32 . d 1110101011000... .......... . . U . . 12 timing not quite correct 1.441 +bfchg 32 . . 1110101011...... A..DXWL... . . U . . 20 1.442 +bfclr 32 . d 1110110011000... .......... . . U . . 12 1.443 +bfclr 32 . . 1110110011...... A..DXWL... . . U . . 20 1.444 +bfexts 32 . d 1110101111000... .......... . . U . . 8 1.445 +bfexts 32 . . 1110101111...... A..DXWLdx. . . U . . 15 1.446 +bfextu 32 . d 1110100111000... .......... . . U . . 8 1.447 +bfextu 32 . . 1110100111...... A..DXWLdx. . . U . . 15 1.448 +bfffo 32 . d 1110110111000... .......... . . U . . 18 1.449 +bfffo 32 . . 1110110111...... A..DXWLdx. . . U . . 28 1.450 +bfins 32 . d 1110111111000... .......... . . U . . 10 1.451 +bfins 32 . . 1110111111...... A..DXWL... . . U . . 17 1.452 +bfset 32 . d 1110111011000... .......... . . U . . 12 1.453 +bfset 32 . . 1110111011...... A..DXWL... . . U . . 20 1.454 +bftst 32 . d 1110100011000... .......... . . U . . 6 1.455 +bftst 32 . . 1110100011...... A..DXWLdx. . . U . . 13 1.456 +bkpt 0 . . 0100100001001... .......... . U U . 10 10 1.457 +bra 8 . . 01100000........ .......... U U U 10 10 10 1.458 +bra 16 . . 0110000000000000 .......... U U U 10 10 10 1.459 +bra 32 . . 0110000011111111 .......... U U U . . 10 1.460 +bset 32 r d 0000...111000... .......... U U U 8 8 4 1.461 +bset 8 r . 0000...111...... A+-DXWL... U U U 8 8 4 1.462 +bset 8 s . 0000100011...... A+-DXWL... U U U 12 12 4 1.463 +bset 32 s d 0000100011000... .......... U U U 12 12 4 1.464 +bsr 8 . . 01100001........ .......... U U U 18 18 7 1.465 +bsr 16 . . 0110000100000000 .......... U U U 18 18 7 1.466 +bsr 32 . . 0110000111111111 .......... . . U . . 7 1.467 +btst 8 r . 0000...100...... A+-DXWLdxI U U U 4 4 4 1.468 +btst 32 r d 0000...100000... .......... U U U 6 6 4 1.469 +btst 8 s . 0000100000...... A+-DXWLdx. U U U 8 8 4 1.470 +btst 32 s d 0000100000000... .......... U U U 10 10 4 1.471 +callm 32 . . 0000011011...... A..DXWLdx. . . U . . 60 not properly emulated 1.472 +cas 8 . . 0000101011...... A+-DXWL... . . U . . 12 1.473 +cas 16 . . 0000110011...... A+-DXWL... . . U . . 12 1.474 +cas 32 . . 0000111011...... A+-DXWL... . . U . . 12 1.475 +cas2 16 . . 0000110011111100 .......... . . U . . 12 1.476 +cas2 32 . . 0000111011111100 .......... . . U . . 12 1.477 +chk 16 . d 0100...110000... .......... U U U 10 8 8 1.478 +chk 16 . . 0100...110...... A+-DXWLdxI U U U 10 8 8 1.479 +chk 32 . d 0100...100000... .......... . . U . . 8 1.480 +chk 32 . . 0100...100...... A+-DXWLdxI . . U . . 8 1.481 +chk2cmp2 8 . . 0000000011...... A..DXWLdx. . . U . . 18 1.482 +chk2cmp2 16 . . 0000001011...... A..DXWLdx. . . U . . 18 1.483 +chk2cmp2 32 . . 0000010011...... A..DXWLdx. . . U . . 18 1.484 +clr 8 . d 0100001000000... .......... U U U 4 4 2 1.485 +clr 8 . . 0100001000...... A+-DXWL... U U U 8 4 4 1.486 +clr 16 . d 0100001001000... .......... U U U 4 4 2 1.487 +clr 16 . . 0100001001...... A+-DXWL... U U U 8 4 4 1.488 +clr 32 . d 0100001010000... .......... U U U 6 6 2 1.489 +clr 32 . . 0100001010...... A+-DXWL... U U U 12 6 4 1.490 +cmp 8 . d 1011...000000... .......... U U U 4 4 2 1.491 +cmp 8 . . 1011...000...... A+-DXWLdxI U U U 4 4 2 1.492 +cmp 16 . d 1011...001000... .......... U U U 4 4 2 1.493 +cmp 16 . a 1011...001001... .......... U U U 4 4 2 1.494 +cmp 16 . . 1011...001...... A+-DXWLdxI U U U 4 4 2 1.495 +cmp 32 . d 1011...010000... .......... U U U 6 6 2 1.496 +cmp 32 . a 1011...010001... .......... U U U 6 6 2 1.497 +cmp 32 . . 1011...010...... A+-DXWLdxI U U U 6 6 2 1.498 +cmpa 16 . d 1011...011000... .......... U U U 6 6 4 1.499 +cmpa 16 . a 1011...011001... .......... U U U 6 6 4 1.500 +cmpa 16 . . 1011...011...... A+-DXWLdxI U U U 6 6 4 1.501 +cmpa 32 . d 1011...111000... .......... U U U 6 6 4 1.502 +cmpa 32 . a 1011...111001... .......... U U U 6 6 4 1.503 +cmpa 32 . . 1011...111...... A+-DXWLdxI U U U 6 6 4 1.504 +cmpi 8 . d 0000110000000... .......... U U U 8 8 2 1.505 +cmpi 8 . . 0000110000...... A+-DXWL... U U U 8 8 2 1.506 +cmpi 8 . pcdi 0000110000111010 .......... . . U . . 7 1.507 +cmpi 8 . pcix 0000110000111011 .......... . . U . . 9 1.508 +cmpi 16 . d 0000110001000... .......... U U U 8 8 2 1.509 +cmpi 16 . . 0000110001...... A+-DXWL... U U U 8 8 2 1.510 +cmpi 16 . pcdi 0000110001111010 .......... . . U . . 7 1.511 +cmpi 16 . pcix 0000110001111011 .......... . . U . . 9 1.512 +cmpi 32 . d 0000110010000... .......... U U U 14 12 2 1.513 +cmpi 32 . . 0000110010...... A+-DXWL... U U U 12 12 2 1.514 +cmpi 32 . pcdi 0000110010111010 .......... . . U . . 7 1.515 +cmpi 32 . pcix 0000110010111011 .......... . . U . . 9 1.516 +cmpm 8 . ax7 1011111100001... .......... U U U 12 12 9 1.517 +cmpm 8 . ay7 1011...100001111 .......... U U U 12 12 9 1.518 +cmpm 8 . axy7 1011111100001111 .......... U U U 12 12 9 1.519 +cmpm 8 . . 1011...100001... .......... U U U 12 12 9 1.520 +cmpm 16 . . 1011...101001... .......... U U U 12 12 9 1.521 +cmpm 32 . . 1011...110001... .......... U U U 20 20 9 1.522 +cpbcc 32 . . 1111...01....... .......... . . U . . 4 unemulated 1.523 +cpdbcc 32 . . 1111...001001... .......... . . U . . 4 unemulated 1.524 +cpgen 32 . . 1111...000...... .......... . . U . . 4 unemulated 1.525 +cpscc 32 . . 1111...001...... .......... . . U . . 4 unemulated 1.526 +cptrapcc 32 . . 1111...001111... .......... . . U . . 4 unemulated 1.527 +dbt 16 . . 0101000011001... .......... U U U 12 12 6 1.528 +dbf 16 . . 0101000111001... .......... U U U 14 14 6 1.529 +dbcc 16 . . 0101....11001... .......... U U U 12 12 6 1.530 +divs 16 . d 1000...111000... .......... U U U 158 122 56 1.531 +divs 16 . . 1000...111...... A+-DXWLdxI U U U 158 122 56 1.532 +divu 16 . d 1000...011000... .......... U U U 140 108 44 1.533 +divu 16 . . 1000...011...... A+-DXWLdxI U U U 140 108 44 1.534 +divl 32 . d 0100110001000... .......... . . U . . 84 1.535 +divl 32 . . 0100110001...... A+-DXWLdxI . . U . . 84 1.536 +eor 8 . d 1011...100000... .......... U U U 4 4 2 1.537 +eor 8 . . 1011...100...... A+-DXWL... U U U 8 8 4 1.538 +eor 16 . d 1011...101000... .......... U U U 4 4 2 1.539 +eor 16 . . 1011...101...... A+-DXWL... U U U 8 8 4 1.540 +eor 32 . d 1011...110000... .......... U U U 8 6 2 1.541 +eor 32 . . 1011...110...... A+-DXWL... U U U 12 12 4 1.542 +eori 16 toc . 0000101000111100 .......... U U U 20 16 12 1.543 +eori 16 tos . 0000101001111100 .......... S S S 20 16 12 1.544 +eori 8 . d 0000101000000... .......... U U U 8 8 2 1.545 +eori 8 . . 0000101000...... A+-DXWL... U U U 12 12 4 1.546 +eori 16 . d 0000101001000... .......... U U U 8 8 2 1.547 +eori 16 . . 0000101001...... A+-DXWL... U U U 12 12 4 1.548 +eori 32 . d 0000101010000... .......... U U U 16 14 2 1.549 +eori 32 . . 0000101010...... A+-DXWL... U U U 20 20 4 1.550 +exg 32 dd . 1100...101000... .......... U U U 6 6 2 1.551 +exg 32 aa . 1100...101001... .......... U U U 6 6 2 1.552 +exg 32 da . 1100...110001... .......... U U U 6 6 2 1.553 +ext 16 . . 0100100010000... .......... U U U 4 4 4 1.554 +ext 32 . . 0100100011000... .......... U U U 4 4 4 1.555 +extb 32 . . 0100100111000... .......... . . U . . 4 1.556 +illegal 0 . . 0100101011111100 .......... U U U 4 4 4 1.557 +jmp 32 . . 0100111011...... A..DXWLdx. U U U 4 4 0 1.558 +jsr 32 . . 0100111010...... A..DXWLdx. U U U 12 12 0 1.559 +lea 32 . . 0100...111...... A..DXWLdx. U U U 0 0 2 1.560 +link 16 . a7 0100111001010111 .......... U U U 16 16 5 1.561 +link 16 . . 0100111001010... .......... U U U 16 16 5 1.562 +link 32 . a7 0100100000001111 .......... . . U . . 6 1.563 +link 32 . . 0100100000001... .......... . . U . . 6 1.564 +lsr 8 s . 1110...000001... .......... U U U 6 6 4 1.565 +lsr 16 s . 1110...001001... .......... U U U 6 6 4 1.566 +lsr 32 s . 1110...010001... .......... U U U 8 8 4 1.567 +lsr 8 r . 1110...000101... .......... U U U 6 6 6 1.568 +lsr 16 r . 1110...001101... .......... U U U 6 6 6 1.569 +lsr 32 r . 1110...010101... .......... U U U 8 8 6 1.570 +lsr 16 . . 1110001011...... A+-DXWL... U U U 8 8 5 1.571 +lsl 8 s . 1110...100001... .......... U U U 6 6 4 1.572 +lsl 16 s . 1110...101001... .......... U U U 6 6 4 1.573 +lsl 32 s . 1110...110001... .......... U U U 8 8 4 1.574 +lsl 8 r . 1110...100101... .......... U U U 6 6 6 1.575 +lsl 16 r . 1110...101101... .......... U U U 6 6 6 1.576 +lsl 32 r . 1110...110101... .......... U U U 8 8 6 1.577 +lsl 16 . . 1110001111...... A+-DXWL... U U U 8 8 5 1.578 +move 8 d d 0001...000000... .......... U U U 4 4 2 1.579 +move 8 d . 0001...000...... A+-DXWLdxI U U U 4 4 2 1.580 +move 8 ai d 0001...010000... .......... U U U 8 8 4 1.581 +move 8 ai . 0001...010...... A+-DXWLdxI U U U 8 8 4 1.582 +move 8 pi d 0001...011000... .......... U U U 8 8 4 1.583 +move 8 pi . 0001...011...... A+-DXWLdxI U U U 8 8 4 1.584 +move 8 pi7 d 0001111011000... .......... U U U 8 8 4 1.585 +move 8 pi7 . 0001111011...... A+-DXWLdxI U U U 8 8 4 1.586 +move 8 pd d 0001...100000... .......... U U U 8 8 5 1.587 +move 8 pd . 0001...100...... A+-DXWLdxI U U U 8 8 5 1.588 +move 8 pd7 d 0001111100000... .......... U U U 8 8 5 1.589 +move 8 pd7 . 0001111100...... A+-DXWLdxI U U U 8 8 5 1.590 +move 8 di d 0001...101000... .......... U U U 12 12 5 1.591 +move 8 di . 0001...101...... A+-DXWLdxI U U U 12 12 5 1.592 +move 8 ix d 0001...110000... .......... U U U 14 14 7 1.593 +move 8 ix . 0001...110...... A+-DXWLdxI U U U 14 14 7 1.594 +move 8 aw d 0001000111000... .......... U U U 12 12 4 1.595 +move 8 aw . 0001000111...... A+-DXWLdxI U U U 12 12 4 1.596 +move 8 al d 0001001111000... .......... U U U 16 16 6 1.597 +move 8 al . 0001001111...... A+-DXWLdxI U U U 16 16 6 1.598 +move 16 d d 0011...000000... .......... U U U 4 4 2 1.599 +move 16 d a 0011...000001... .......... U U U 4 4 2 1.600 +move 16 d . 0011...000...... A+-DXWLdxI U U U 4 4 2 1.601 +move 16 ai d 0011...010000... .......... U U U 8 8 4 1.602 +move 16 ai a 0011...010001... .......... U U U 8 8 4 1.603 +move 16 ai . 0011...010...... A+-DXWLdxI U U U 8 8 4 1.604 +move 16 pi d 0011...011000... .......... U U U 8 8 4 1.605 +move 16 pi a 0011...011001... .......... U U U 8 8 4 1.606 +move 16 pi . 0011...011...... A+-DXWLdxI U U U 8 8 4 1.607 +move 16 pd d 0011...100000... .......... U U U 8 8 5 1.608 +move 16 pd a 0011...100001... .......... U U U 8 8 5 1.609 +move 16 pd . 0011...100...... A+-DXWLdxI U U U 8 8 5 1.610 +move 16 di d 0011...101000... .......... U U U 12 12 5 1.611 +move 16 di a 0011...101001... .......... U U U 12 12 5 1.612 +move 16 di . 0011...101...... A+-DXWLdxI U U U 12 12 5 1.613 +move 16 ix d 0011...110000... .......... U U U 14 14 7 1.614 +move 16 ix a 0011...110001... .......... U U U 14 14 7 1.615 +move 16 ix . 0011...110...... A+-DXWLdxI U U U 14 14 7 1.616 +move 16 aw d 0011000111000... .......... U U U 12 12 4 1.617 +move 16 aw a 0011000111001... .......... U U U 12 12 4 1.618 +move 16 aw . 0011000111...... A+-DXWLdxI U U U 12 12 4 1.619 +move 16 al d 0011001111000... .......... U U U 16 16 6 1.620 +move 16 al a 0011001111001... .......... U U U 16 16 6 1.621 +move 16 al . 0011001111...... A+-DXWLdxI U U U 16 16 6 1.622 +move 32 d d 0010...000000... .......... U U U 4 4 2 1.623 +move 32 d a 0010...000001... .......... U U U 4 4 2 1.624 +move 32 d . 0010...000...... A+-DXWLdxI U U U 4 4 2 1.625 +move 32 ai d 0010...010000... .......... U U U 12 12 4 1.626 +move 32 ai a 0010...010001... .......... U U U 12 12 4 1.627 +move 32 ai . 0010...010...... A+-DXWLdxI U U U 12 12 4 1.628 +move 32 pi d 0010...011000... .......... U U U 12 12 4 1.629 +move 32 pi a 0010...011001... .......... U U U 12 12 4 1.630 +move 32 pi . 0010...011...... A+-DXWLdxI U U U 12 12 4 1.631 +move 32 pd d 0010...100000... .......... U U U 12 14 5 1.632 +move 32 pd a 0010...100001... .......... U U U 12 14 5 1.633 +move 32 pd . 0010...100...... A+-DXWLdxI U U U 12 14 5 1.634 +move 32 di d 0010...101000... .......... U U U 16 16 5 1.635 +move 32 di a 0010...101001... .......... U U U 16 16 5 1.636 +move 32 di . 0010...101...... A+-DXWLdxI U U U 16 16 5 1.637 +move 32 ix d 0010...110000... .......... U U U 18 18 7 1.638 +move 32 ix a 0010...110001... .......... U U U 18 18 7 1.639 +move 32 ix . 0010...110...... A+-DXWLdxI U U U 18 18 7 1.640 +move 32 aw d 0010000111000... .......... U U U 16 16 4 1.641 +move 32 aw a 0010000111001... .......... U U U 16 16 4 1.642 +move 32 aw . 0010000111...... A+-DXWLdxI U U U 16 16 4 1.643 +move 32 al d 0010001111000... .......... U U U 20 20 6 1.644 +move 32 al a 0010001111001... .......... U U U 20 20 6 1.645 +move 32 al . 0010001111...... A+-DXWLdxI U U U 20 20 6 1.646 +movea 16 . d 0011...001000... .......... U U U 4 4 2 1.647 +movea 16 . a 0011...001001... .......... U U U 4 4 2 1.648 +movea 16 . . 0011...001...... A+-DXWLdxI U U U 4 4 2 1.649 +movea 32 . d 0010...001000... .......... U U U 4 4 2 1.650 +movea 32 . a 0010...001001... .......... U U U 4 4 2 1.651 +movea 32 . . 0010...001...... A+-DXWLdxI U U U 4 4 2 1.652 +move 16 frc d 0100001011000... .......... . U U . 4 4 1.653 +move 16 frc . 0100001011...... A+-DXWL... . U U . 8 4 1.654 +move 16 toc d 0100010011000... .......... U U U 12 12 4 1.655 +move 16 toc . 0100010011...... A+-DXWLdxI U U U 12 12 4 1.656 +move 16 frs d 0100000011000... .......... U S S 6 4 8 U only for 000 1.657 +move 16 frs . 0100000011...... A+-DXWL... U S S 8 8 8 U only for 000 1.658 +move 16 tos d 0100011011000... .......... S S S 12 12 8 1.659 +move 16 tos . 0100011011...... A+-DXWLdxI S S S 12 12 8 1.660 +move 32 fru . 0100111001101... .......... S S S 4 6 2 1.661 +move 32 tou . 0100111001100... .......... S S S 4 6 2 1.662 +movec 32 cr . 0100111001111010 .......... . S S . 12 6 1.663 +movec 32 rc . 0100111001111011 .......... . S S . 10 12 1.664 +movem 16 re pd 0100100010100... .......... U U U 8 8 4 1.665 +movem 16 re . 0100100010...... A..DXWL... U U U 8 8 4 1.666 +movem 32 re pd 0100100011100... .......... U U U 8 8 4 1.667 +movem 32 re . 0100100011...... A..DXWL... U U U 8 8 4 1.668 +movem 16 er pi 0100110010011... .......... U U U 12 12 8 1.669 +movem 16 er . 0100110010...... A..DXWLdx. U U U 12 12 8 1.670 +movem 32 er pi 0100110011011... .......... U U U 12 12 8 1.671 +movem 32 er . 0100110011...... A..DXWLdx. U U U 12 12 8 1.672 +movep 16 er . 0000...100001... .......... U U U 16 16 12 1.673 +movep 32 er . 0000...101001... .......... U U U 24 24 18 1.674 +movep 16 re . 0000...110001... .......... U U U 16 16 11 1.675 +movep 32 re . 0000...111001... .......... U U U 24 24 17 1.676 +moveq 32 . . 0111...0........ .......... U U U 4 4 2 1.677 +moves 8 . . 0000111000...... A+-DXWL... . S S . 14 5 1.678 +moves 16 . . 0000111001...... A+-DXWL... . S S . 14 5 1.679 +moves 32 . . 0000111010...... A+-DXWL... . S S . 16 5 1.680 +muls 16 . d 1100...111000... .......... U U U 54 32 27 1.681 +muls 16 . . 1100...111...... A+-DXWLdxI U U U 54 32 27 1.682 +mulu 16 . d 1100...011000... .......... U U U 54 30 27 1.683 +mulu 16 . . 1100...011...... A+-DXWLdxI U U U 54 30 27 1.684 +mull 32 . d 0100110000000... .......... . . U . . 43 1.685 +mull 32 . . 0100110000...... A+-DXWLdxI . . U . . 43 1.686 +nbcd 8 . d 0100100000000... .......... U U U 6 6 6 1.687 +nbcd 8 . . 0100100000...... A+-DXWL... U U U 8 8 6 1.688 +neg 8 . d 0100010000000... .......... U U U 4 4 2 1.689 +neg 8 . . 0100010000...... A+-DXWL... U U U 8 8 4 1.690 +neg 16 . d 0100010001000... .......... U U U 4 4 2 1.691 +neg 16 . . 0100010001...... A+-DXWL... U U U 8 8 4 1.692 +neg 32 . d 0100010010000... .......... U U U 6 6 2 1.693 +neg 32 . . 0100010010...... A+-DXWL... U U U 12 12 4 1.694 +negx 8 . d 0100000000000... .......... U U U 4 4 2 1.695 +negx 8 . . 0100000000...... A+-DXWL... U U U 8 8 4 1.696 +negx 16 . d 0100000001000... .......... U U U 4 4 2 1.697 +negx 16 . . 0100000001...... A+-DXWL... U U U 8 8 4 1.698 +negx 32 . d 0100000010000... .......... U U U 6 6 2 1.699 +negx 32 . . 0100000010...... A+-DXWL... U U U 12 12 4 1.700 +nop 0 . . 0100111001110001 .......... U U U 4 4 2 1.701 +not 8 . d 0100011000000... .......... U U U 4 4 2 1.702 +not 8 . . 0100011000...... A+-DXWL... U U U 8 8 4 1.703 +not 16 . d 0100011001000... .......... U U U 4 4 2 1.704 +not 16 . . 0100011001...... A+-DXWL... U U U 8 8 4 1.705 +not 32 . d 0100011010000... .......... U U U 6 6 2 1.706 +not 32 . . 0100011010...... A+-DXWL... U U U 12 12 4 1.707 +or 8 er d 1000...000000... .......... U U U 4 4 2 1.708 +or 8 er . 1000...000...... A+-DXWLdxI U U U 4 4 2 1.709 +or 16 er d 1000...001000... .......... U U U 4 4 2 1.710 +or 16 er . 1000...001...... A+-DXWLdxI U U U 4 4 2 1.711 +or 32 er d 1000...010000... .......... U U U 6 6 2 1.712 +or 32 er . 1000...010...... A+-DXWLdxI U U U 6 6 2 1.713 +or 8 re . 1000...100...... A+-DXWL... U U U 8 8 4 1.714 +or 16 re . 1000...101...... A+-DXWL... U U U 8 8 4 1.715 +or 32 re . 1000...110...... A+-DXWL... U U U 12 12 4 1.716 +ori 16 toc . 0000000000111100 .......... U U U 20 16 12 1.717 +ori 16 tos . 0000000001111100 .......... S S S 20 16 12 1.718 +ori 8 . d 0000000000000... .......... U U U 8 8 2 1.719 +ori 8 . . 0000000000...... A+-DXWL... U U U 12 12 4 1.720 +ori 16 . d 0000000001000... .......... U U U 8 8 2 1.721 +ori 16 . . 0000000001...... A+-DXWL... U U U 12 12 4 1.722 +ori 32 . d 0000000010000... .......... U U U 16 14 2 1.723 +ori 32 . . 0000000010...... A+-DXWL... U U U 20 20 4 1.724 +pack 16 rr . 1000...101000... .......... . . U . . 6 1.725 +pack 16 mm ax7 1000111101001... .......... . . U . . 13 1.726 +pack 16 mm ay7 1000...101001111 .......... . . U . . 13 1.727 +pack 16 mm axy7 1000111101001111 .......... . . U . . 13 1.728 +pack 16 mm . 1000...101001... .......... . . U . . 13 1.729 +pea 32 . . 0100100001...... A..DXWLdx. U U U 6 6 5 1.730 +reset 0 . . 0100111001110000 .......... S S S 0 0 0 1.731 +ror 8 s . 1110...000011... .......... U U U 6 6 8 1.732 +ror 16 s . 1110...001011... .......... U U U 6 6 8 1.733 +ror 32 s . 1110...010011... .......... U U U 8 8 8 1.734 +ror 8 r . 1110...000111... .......... U U U 6 6 8 1.735 +ror 16 r . 1110...001111... .......... U U U 6 6 8 1.736 +ror 32 r . 1110...010111... .......... U U U 8 8 8 1.737 +ror 16 . . 1110011011...... A+-DXWL... U U U 8 8 7 1.738 +rol 8 s . 1110...100011... .......... U U U 6 6 8 1.739 +rol 16 s . 1110...101011... .......... U U U 6 6 8 1.740 +rol 32 s . 1110...110011... .......... U U U 8 8 8 1.741 +rol 8 r . 1110...100111... .......... U U U 6 6 8 1.742 +rol 16 r . 1110...101111... .......... U U U 6 6 8 1.743 +rol 32 r . 1110...110111... .......... U U U 8 8 8 1.744 +rol 16 . . 1110011111...... A+-DXWL... U U U 8 8 7 1.745 +roxr 8 s . 1110...000010... .......... U U U 6 6 12 1.746 +roxr 16 s . 1110...001010... .......... U U U 6 6 12 1.747 +roxr 32 s . 1110...010010... .......... U U U 8 8 12 1.748 +roxr 8 r . 1110...000110... .......... U U U 6 6 12 1.749 +roxr 16 r . 1110...001110... .......... U U U 6 6 12 1.750 +roxr 32 r . 1110...010110... .......... U U U 8 8 12 1.751 +roxr 16 . . 1110010011...... A+-DXWL... U U U 8 8 5 1.752 +roxl 8 s . 1110...100010... .......... U U U 6 6 12 1.753 +roxl 16 s . 1110...101010... .......... U U U 6 6 12 1.754 +roxl 32 s . 1110...110010... .......... U U U 8 8 12 1.755 +roxl 8 r . 1110...100110... .......... U U U 6 6 12 1.756 +roxl 16 r . 1110...101110... .......... U U U 6 6 12 1.757 +roxl 32 r . 1110...110110... .......... U U U 8 8 12 1.758 +roxl 16 . . 1110010111...... A+-DXWL... U U U 8 8 5 1.759 +rtd 32 . . 0100111001110100 .......... . U U . 16 10 1.760 +rte 32 . . 0100111001110011 .......... S S S 20 24 20 bus fault not emulated 1.761 +rtm 32 . . 000001101100.... .......... . . U . . 19 not properly emulated 1.762 +rtr 32 . . 0100111001110111 .......... U U U 20 20 14 1.763 +rts 32 . . 0100111001110101 .......... U U U 16 16 10 1.764 +sbcd 8 rr . 1000...100000... .......... U U U 6 6 4 1.765 +sbcd 8 mm ax7 1000111100001... .......... U U U 18 18 16 1.766 +sbcd 8 mm ay7 1000...100001111 .......... U U U 18 18 16 1.767 +sbcd 8 mm axy7 1000111100001111 .......... U U U 18 18 16 1.768 +sbcd 8 mm . 1000...100001... .......... U U U 18 18 16 1.769 +st 8 . d 0101000011000... .......... U U U 6 4 4 1.770 +st 8 . . 0101000011...... A+-DXWL... U U U 8 8 6 1.771 +sf 8 . d 0101000111000... .......... U U U 4 4 4 1.772 +sf 8 . . 0101000111...... A+-DXWL... U U U 8 8 6 1.773 +scc 8 . d 0101....11000... .......... U U U 4 4 4 1.774 +scc 8 . . 0101....11...... A+-DXWL... U U U 8 8 6 1.775 +stop 0 . . 0100111001110010 .......... S S S 4 4 8 1.776 +sub 8 er d 1001...000000... .......... U U U 4 4 2 1.777 +sub 8 er . 1001...000...... A+-DXWLdxI U U U 4 4 2 1.778 +sub 16 er d 1001...001000... .......... U U U 4 4 2 1.779 +sub 16 er a 1001...001001... .......... U U U 4 4 2 1.780 +sub 16 er . 1001...001...... A+-DXWLdxI U U U 4 4 2 1.781 +sub 32 er d 1001...010000... .......... U U U 6 6 2 1.782 +sub 32 er a 1001...010001... .......... U U U 6 6 2 1.783 +sub 32 er . 1001...010...... A+-DXWLdxI U U U 6 6 2 1.784 +sub 8 re . 1001...100...... A+-DXWL... U U U 8 8 4 1.785 +sub 16 re . 1001...101...... A+-DXWL... U U U 8 8 4 1.786 +sub 32 re . 1001...110...... A+-DXWL... U U U 12 12 4 1.787 +suba 16 . d 1001...011000... .......... U U U 8 8 2 1.788 +suba 16 . a 1001...011001... .......... U U U 8 8 2 1.789 +suba 16 . . 1001...011...... A+-DXWLdxI U U U 8 8 2 1.790 +suba 32 . d 1001...111000... .......... U U U 6 6 2 1.791 +suba 32 . a 1001...111001... .......... U U U 6 6 2 1.792 +suba 32 . . 1001...111...... A+-DXWLdxI U U U 6 6 2 1.793 +subi 8 . d 0000010000000... .......... U U U 8 8 2 1.794 +subi 8 . . 0000010000...... A+-DXWL... U U U 12 12 4 1.795 +subi 16 . d 0000010001000... .......... U U U 8 8 2 1.796 +subi 16 . . 0000010001...... A+-DXWL... U U U 12 12 4 1.797 +subi 32 . d 0000010010000... .......... U U U 16 14 2 1.798 +subi 32 . . 0000010010...... A+-DXWL... U U U 20 20 4 1.799 +subq 8 . d 0101...100000... .......... U U U 4 4 2 1.800 +subq 8 . . 0101...100...... A+-DXWL... U U U 8 8 4 1.801 +subq 16 . d 0101...101000... .......... U U U 4 4 2 1.802 +subq 16 . a 0101...101001... .......... U U U 8 4 2 1.803 +subq 16 . . 0101...101...... A+-DXWL... U U U 8 8 4 1.804 +subq 32 . d 0101...110000... .......... U U U 8 8 2 1.805 +subq 32 . a 0101...110001... .......... U U U 8 8 2 1.806 +subq 32 . . 0101...110...... A+-DXWL... U U U 12 12 4 1.807 +subx 8 rr . 1001...100000... .......... U U U 4 4 2 1.808 +subx 16 rr . 1001...101000... .......... U U U 4 4 2 1.809 +subx 32 rr . 1001...110000... .......... U U U 8 6 2 1.810 +subx 8 mm ax7 1001111100001... .......... U U U 18 18 12 1.811 +subx 8 mm ay7 1001...100001111 .......... U U U 18 18 12 1.812 +subx 8 mm axy7 1001111100001111 .......... U U U 18 18 12 1.813 +subx 8 mm . 1001...100001... .......... U U U 18 18 12 1.814 +subx 16 mm . 1001...101001... .......... U U U 18 18 12 1.815 +subx 32 mm . 1001...110001... .......... U U U 30 30 12 1.816 +swap 32 . . 0100100001000... .......... U U U 4 4 4 1.817 +tas 8 . d 0100101011000... .......... U U U 4 4 4 1.818 +tas 8 . . 0100101011...... A+-DXWL... U U U 14 14 12 1.819 +trap 0 . . 010011100100.... .......... U U U 4 4 4 1.820 +trapt 0 . . 0101000011111100 .......... . . U . . 4 1.821 +trapt 16 . . 0101000011111010 .......... . . U . . 6 1.822 +trapt 32 . . 0101000011111011 .......... . . U . . 8 1.823 +trapf 0 . . 0101000111111100 .......... . . U . . 4 1.824 +trapf 16 . . 0101000111111010 .......... . . U . . 6 1.825 +trapf 32 . . 0101000111111011 .......... . . U . . 8 1.826 +trapcc 0 . . 0101....11111100 .......... . . U . . 4 1.827 +trapcc 16 . . 0101....11111010 .......... . . U . . 6 1.828 +trapcc 32 . . 0101....11111011 .......... . . U . . 8 1.829 +trapv 0 . . 0100111001110110 .......... U U U 4 4 4 1.830 +tst 8 . d 0100101000000... .......... U U U 4 4 2 1.831 +tst 8 . . 0100101000...... A+-DXWL... U U U 4 4 2 1.832 +tst 8 . pcdi 0100101000111010 .......... . . U . . 7 1.833 +tst 8 . pcix 0100101000111011 .......... . . U . . 9 1.834 +tst 8 . i 0100101000111100 .......... . . U . . 6 1.835 +tst 16 . d 0100101001000... .......... U U U 4 4 2 1.836 +tst 16 . a 0100101001001... .......... . . U . . 2 1.837 +tst 16 . . 0100101001...... A+-DXWL... U U U 4 4 2 1.838 +tst 16 . pcdi 0100101001111010 .......... . . U . . 7 1.839 +tst 16 . pcix 0100101001111011 .......... . . U . . 9 1.840 +tst 16 . i 0100101001111100 .......... . . U . . 6 1.841 +tst 32 . d 0100101010000... .......... U U U 4 4 2 1.842 +tst 32 . a 0100101010001... .......... . . U . . 2 1.843 +tst 32 . . 0100101010...... A+-DXWL... U U U 4 4 2 1.844 +tst 32 . pcdi 0100101010111010 .......... . . U . . 7 1.845 +tst 32 . pcix 0100101010111011 .......... . . U . . 9 1.846 +tst 32 . i 0100101010111100 .......... . . U . . 6 1.847 +unlk 32 . a7 0100111001011111 .......... U U U 12 12 6 1.848 +unlk 32 . . 0100111001011... .......... U U U 12 12 6 1.849 +unpk 16 rr . 1000...110000... .......... . . U . . 8 1.850 +unpk 16 mm ax7 1000111110001... .......... . . U . . 13 1.851 +unpk 16 mm ay7 1000...110001111 .......... . . U . . 13 1.852 +unpk 16 mm axy7 1000111110001111 .......... . . U . . 13 1.853 +unpk 16 mm . 1000...110001... .......... . . U . . 13 1.854 + 1.855 + 1.856 + 1.857 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.858 +M68KMAKE_OPCODE_HANDLER_BODY 1.859 + 1.860 +M68KMAKE_OP(1010, 0, ., .) 1.861 +{ 1.862 + m68ki_exception_1010(); 1.863 +} 1.864 + 1.865 + 1.866 +M68KMAKE_OP(1111, 0, ., .) 1.867 +{ 1.868 + m68ki_exception_1111(); 1.869 +} 1.870 + 1.871 + 1.872 +M68KMAKE_OP(abcd, 8, rr, .) 1.873 +{ 1.874 + uint* r_dst = &DX; 1.875 + uint src = DY; 1.876 + uint dst = *r_dst; 1.877 + uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1(); 1.878 + 1.879 + if(res > 9) 1.880 + res += 6; 1.881 + res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst); 1.882 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.883 + if(FLAG_C) 1.884 + res -= 0xa0; 1.885 + 1.886 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.887 + 1.888 + res = MASK_OUT_ABOVE_8(res); 1.889 + FLAG_Z |= res; 1.890 + 1.891 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.892 +} 1.893 + 1.894 + 1.895 +M68KMAKE_OP(abcd, 8, mm, ax7) 1.896 +{ 1.897 + uint src = OPER_AY_PD_8(); 1.898 + uint ea = EA_A7_PD_8(); 1.899 + uint dst = m68ki_read_8(ea); 1.900 + uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1(); 1.901 + 1.902 + if(res > 9) 1.903 + res += 6; 1.904 + res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst); 1.905 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.906 + if(FLAG_C) 1.907 + res -= 0xa0; 1.908 + 1.909 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.910 + 1.911 + res = MASK_OUT_ABOVE_8(res); 1.912 + FLAG_Z |= res; 1.913 + 1.914 + m68ki_write_8(ea, res); 1.915 +} 1.916 + 1.917 + 1.918 +M68KMAKE_OP(abcd, 8, mm, ay7) 1.919 +{ 1.920 + uint src = OPER_A7_PD_8(); 1.921 + uint ea = EA_AX_PD_8(); 1.922 + uint dst = m68ki_read_8(ea); 1.923 + uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1(); 1.924 + 1.925 + if(res > 9) 1.926 + res += 6; 1.927 + res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst); 1.928 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.929 + if(FLAG_C) 1.930 + res -= 0xa0; 1.931 + 1.932 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.933 + 1.934 + res = MASK_OUT_ABOVE_8(res); 1.935 + FLAG_Z |= res; 1.936 + 1.937 + m68ki_write_8(ea, res); 1.938 +} 1.939 + 1.940 + 1.941 +M68KMAKE_OP(abcd, 8, mm, axy7) 1.942 +{ 1.943 + uint src = OPER_A7_PD_8(); 1.944 + uint ea = EA_A7_PD_8(); 1.945 + uint dst = m68ki_read_8(ea); 1.946 + uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1(); 1.947 + 1.948 + if(res > 9) 1.949 + res += 6; 1.950 + res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst); 1.951 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.952 + if(FLAG_C) 1.953 + res -= 0xa0; 1.954 + 1.955 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.956 + 1.957 + res = MASK_OUT_ABOVE_8(res); 1.958 + FLAG_Z |= res; 1.959 + 1.960 + m68ki_write_8(ea, res); 1.961 +} 1.962 + 1.963 + 1.964 +M68KMAKE_OP(abcd, 8, mm, .) 1.965 +{ 1.966 + uint src = OPER_AY_PD_8(); 1.967 + uint ea = EA_AX_PD_8(); 1.968 + uint dst = m68ki_read_8(ea); 1.969 + uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1(); 1.970 + 1.971 + if(res > 9) 1.972 + res += 6; 1.973 + res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst); 1.974 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.975 + if(FLAG_C) 1.976 + res -= 0xa0; 1.977 + 1.978 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.979 + 1.980 + res = MASK_OUT_ABOVE_8(res); 1.981 + FLAG_Z |= res; 1.982 + 1.983 + m68ki_write_8(ea, res); 1.984 +} 1.985 + 1.986 + 1.987 +M68KMAKE_OP(add, 8, er, d) 1.988 +{ 1.989 + uint* r_dst = &DX; 1.990 + uint src = MASK_OUT_ABOVE_8(DY); 1.991 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.992 + uint res = src + dst; 1.993 + 1.994 + FLAG_N = NFLAG_8(res); 1.995 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.996 + FLAG_X = FLAG_C = CFLAG_8(res); 1.997 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.998 + 1.999 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.1000 +} 1.1001 + 1.1002 + 1.1003 +M68KMAKE_OP(add, 8, er, .) 1.1004 +{ 1.1005 + uint* r_dst = &DX; 1.1006 + uint src = M68KMAKE_GET_OPER_AY_8; 1.1007 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.1008 + uint res = src + dst; 1.1009 + 1.1010 + FLAG_N = NFLAG_8(res); 1.1011 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1012 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1013 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.1014 + 1.1015 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.1016 +} 1.1017 + 1.1018 + 1.1019 +M68KMAKE_OP(add, 16, er, d) 1.1020 +{ 1.1021 + uint* r_dst = &DX; 1.1022 + uint src = MASK_OUT_ABOVE_16(DY); 1.1023 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.1024 + uint res = src + dst; 1.1025 + 1.1026 + FLAG_N = NFLAG_16(res); 1.1027 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1028 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1029 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1030 + 1.1031 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.1032 +} 1.1033 + 1.1034 + 1.1035 +M68KMAKE_OP(add, 16, er, a) 1.1036 +{ 1.1037 + uint* r_dst = &DX; 1.1038 + uint src = MASK_OUT_ABOVE_16(AY); 1.1039 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.1040 + uint res = src + dst; 1.1041 + 1.1042 + FLAG_N = NFLAG_16(res); 1.1043 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1044 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1045 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1046 + 1.1047 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.1048 +} 1.1049 + 1.1050 + 1.1051 +M68KMAKE_OP(add, 16, er, .) 1.1052 +{ 1.1053 + uint* r_dst = &DX; 1.1054 + uint src = M68KMAKE_GET_OPER_AY_16; 1.1055 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.1056 + uint res = src + dst; 1.1057 + 1.1058 + FLAG_N = NFLAG_16(res); 1.1059 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1060 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1061 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1062 + 1.1063 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.1064 +} 1.1065 + 1.1066 + 1.1067 +M68KMAKE_OP(add, 32, er, d) 1.1068 +{ 1.1069 + uint* r_dst = &DX; 1.1070 + uint src = DY; 1.1071 + uint dst = *r_dst; 1.1072 + uint res = src + dst; 1.1073 + 1.1074 + FLAG_N = NFLAG_32(res); 1.1075 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1076 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1077 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1078 + 1.1079 + *r_dst = FLAG_Z; 1.1080 +} 1.1081 + 1.1082 + 1.1083 +M68KMAKE_OP(add, 32, er, a) 1.1084 +{ 1.1085 + uint* r_dst = &DX; 1.1086 + uint src = AY; 1.1087 + uint dst = *r_dst; 1.1088 + uint res = src + dst; 1.1089 + 1.1090 + FLAG_N = NFLAG_32(res); 1.1091 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1092 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1093 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1094 + 1.1095 + *r_dst = FLAG_Z; 1.1096 +} 1.1097 + 1.1098 + 1.1099 +M68KMAKE_OP(add, 32, er, .) 1.1100 +{ 1.1101 + uint* r_dst = &DX; 1.1102 + uint src = M68KMAKE_GET_OPER_AY_32; 1.1103 + uint dst = *r_dst; 1.1104 + uint res = src + dst; 1.1105 + 1.1106 + FLAG_N = NFLAG_32(res); 1.1107 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1108 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1109 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1110 + 1.1111 + *r_dst = FLAG_Z; 1.1112 +} 1.1113 + 1.1114 + 1.1115 +M68KMAKE_OP(add, 8, re, .) 1.1116 +{ 1.1117 + uint ea = M68KMAKE_GET_EA_AY_8; 1.1118 + uint src = MASK_OUT_ABOVE_8(DX); 1.1119 + uint dst = m68ki_read_8(ea); 1.1120 + uint res = src + dst; 1.1121 + 1.1122 + FLAG_N = NFLAG_8(res); 1.1123 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1124 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1125 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.1126 + 1.1127 + m68ki_write_8(ea, FLAG_Z); 1.1128 +} 1.1129 + 1.1130 + 1.1131 +M68KMAKE_OP(add, 16, re, .) 1.1132 +{ 1.1133 + uint ea = M68KMAKE_GET_EA_AY_16; 1.1134 + uint src = MASK_OUT_ABOVE_16(DX); 1.1135 + uint dst = m68ki_read_16(ea); 1.1136 + uint res = src + dst; 1.1137 + 1.1138 + FLAG_N = NFLAG_16(res); 1.1139 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1140 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1141 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1142 + 1.1143 + m68ki_write_16(ea, FLAG_Z); 1.1144 +} 1.1145 + 1.1146 + 1.1147 +M68KMAKE_OP(add, 32, re, .) 1.1148 +{ 1.1149 + uint ea = M68KMAKE_GET_EA_AY_32; 1.1150 + uint src = DX; 1.1151 + uint dst = m68ki_read_32(ea); 1.1152 + uint res = src + dst; 1.1153 + 1.1154 + FLAG_N = NFLAG_32(res); 1.1155 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1156 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1157 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1158 + 1.1159 + m68ki_write_32(ea, FLAG_Z); 1.1160 +} 1.1161 + 1.1162 + 1.1163 +M68KMAKE_OP(adda, 16, ., d) 1.1164 +{ 1.1165 + uint* r_dst = &AX; 1.1166 + 1.1167 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(DY)); 1.1168 +} 1.1169 + 1.1170 + 1.1171 +M68KMAKE_OP(adda, 16, ., a) 1.1172 +{ 1.1173 + uint* r_dst = &AX; 1.1174 + 1.1175 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(AY)); 1.1176 +} 1.1177 + 1.1178 + 1.1179 +M68KMAKE_OP(adda, 16, ., .) 1.1180 +{ 1.1181 + uint* r_dst = &AX; 1.1182 + 1.1183 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(M68KMAKE_GET_OPER_AY_16)); 1.1184 +} 1.1185 + 1.1186 + 1.1187 +M68KMAKE_OP(adda, 32, ., d) 1.1188 +{ 1.1189 + uint* r_dst = &AX; 1.1190 + 1.1191 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + DY); 1.1192 +} 1.1193 + 1.1194 + 1.1195 +M68KMAKE_OP(adda, 32, ., a) 1.1196 +{ 1.1197 + uint* r_dst = &AX; 1.1198 + 1.1199 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + AY); 1.1200 +} 1.1201 + 1.1202 + 1.1203 +M68KMAKE_OP(adda, 32, ., .) 1.1204 +{ 1.1205 + uint* r_dst = &AX; 1.1206 + 1.1207 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + M68KMAKE_GET_OPER_AY_32); 1.1208 +} 1.1209 + 1.1210 + 1.1211 +M68KMAKE_OP(addi, 8, ., d) 1.1212 +{ 1.1213 + uint* r_dst = &DY; 1.1214 + uint src = OPER_I_8(); 1.1215 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.1216 + uint res = src + dst; 1.1217 + 1.1218 + FLAG_N = NFLAG_8(res); 1.1219 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1220 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1221 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.1222 + 1.1223 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.1224 +} 1.1225 + 1.1226 + 1.1227 +M68KMAKE_OP(addi, 8, ., .) 1.1228 +{ 1.1229 + uint src = OPER_I_8(); 1.1230 + uint ea = M68KMAKE_GET_EA_AY_8; 1.1231 + uint dst = m68ki_read_8(ea); 1.1232 + uint res = src + dst; 1.1233 + 1.1234 + FLAG_N = NFLAG_8(res); 1.1235 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1236 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1237 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.1238 + 1.1239 + m68ki_write_8(ea, FLAG_Z); 1.1240 +} 1.1241 + 1.1242 + 1.1243 +M68KMAKE_OP(addi, 16, ., d) 1.1244 +{ 1.1245 + uint* r_dst = &DY; 1.1246 + uint src = OPER_I_16(); 1.1247 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.1248 + uint res = src + dst; 1.1249 + 1.1250 + FLAG_N = NFLAG_16(res); 1.1251 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1252 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1253 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1254 + 1.1255 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.1256 +} 1.1257 + 1.1258 + 1.1259 +M68KMAKE_OP(addi, 16, ., .) 1.1260 +{ 1.1261 + uint src = OPER_I_16(); 1.1262 + uint ea = M68KMAKE_GET_EA_AY_16; 1.1263 + uint dst = m68ki_read_16(ea); 1.1264 + uint res = src + dst; 1.1265 + 1.1266 + FLAG_N = NFLAG_16(res); 1.1267 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1268 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1269 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1270 + 1.1271 + m68ki_write_16(ea, FLAG_Z); 1.1272 +} 1.1273 + 1.1274 + 1.1275 +M68KMAKE_OP(addi, 32, ., d) 1.1276 +{ 1.1277 + uint* r_dst = &DY; 1.1278 + uint src = OPER_I_32(); 1.1279 + uint dst = *r_dst; 1.1280 + uint res = src + dst; 1.1281 + 1.1282 + FLAG_N = NFLAG_32(res); 1.1283 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1284 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1285 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1286 + 1.1287 + *r_dst = FLAG_Z; 1.1288 +} 1.1289 + 1.1290 + 1.1291 +M68KMAKE_OP(addi, 32, ., .) 1.1292 +{ 1.1293 + uint src = OPER_I_32(); 1.1294 + uint ea = M68KMAKE_GET_EA_AY_32; 1.1295 + uint dst = m68ki_read_32(ea); 1.1296 + uint res = src + dst; 1.1297 + 1.1298 + FLAG_N = NFLAG_32(res); 1.1299 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1300 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1301 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1302 + 1.1303 + m68ki_write_32(ea, FLAG_Z); 1.1304 +} 1.1305 + 1.1306 + 1.1307 +M68KMAKE_OP(addq, 8, ., d) 1.1308 +{ 1.1309 + uint* r_dst = &DY; 1.1310 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.1311 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.1312 + uint res = src + dst; 1.1313 + 1.1314 + FLAG_N = NFLAG_8(res); 1.1315 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1316 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1317 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.1318 + 1.1319 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.1320 +} 1.1321 + 1.1322 + 1.1323 +M68KMAKE_OP(addq, 8, ., .) 1.1324 +{ 1.1325 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.1326 + uint ea = M68KMAKE_GET_EA_AY_8; 1.1327 + uint dst = m68ki_read_8(ea); 1.1328 + uint res = src + dst; 1.1329 + 1.1330 + FLAG_N = NFLAG_8(res); 1.1331 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1332 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1333 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.1334 + 1.1335 + m68ki_write_8(ea, FLAG_Z); 1.1336 +} 1.1337 + 1.1338 + 1.1339 +M68KMAKE_OP(addq, 16, ., d) 1.1340 +{ 1.1341 + uint* r_dst = &DY; 1.1342 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.1343 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.1344 + uint res = src + dst; 1.1345 + 1.1346 + FLAG_N = NFLAG_16(res); 1.1347 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1348 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1349 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1350 + 1.1351 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.1352 +} 1.1353 + 1.1354 + 1.1355 +M68KMAKE_OP(addq, 16, ., a) 1.1356 +{ 1.1357 + uint* r_dst = &AY; 1.1358 + 1.1359 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1); 1.1360 +} 1.1361 + 1.1362 + 1.1363 +M68KMAKE_OP(addq, 16, ., .) 1.1364 +{ 1.1365 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.1366 + uint ea = M68KMAKE_GET_EA_AY_16; 1.1367 + uint dst = m68ki_read_16(ea); 1.1368 + uint res = src + dst; 1.1369 + 1.1370 + FLAG_N = NFLAG_16(res); 1.1371 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1372 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1373 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1374 + 1.1375 + m68ki_write_16(ea, FLAG_Z); 1.1376 +} 1.1377 + 1.1378 + 1.1379 +M68KMAKE_OP(addq, 32, ., d) 1.1380 +{ 1.1381 + uint* r_dst = &DY; 1.1382 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.1383 + uint dst = *r_dst; 1.1384 + uint res = src + dst; 1.1385 + 1.1386 + FLAG_N = NFLAG_32(res); 1.1387 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1388 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1389 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1390 + 1.1391 + *r_dst = FLAG_Z; 1.1392 +} 1.1393 + 1.1394 + 1.1395 +M68KMAKE_OP(addq, 32, ., a) 1.1396 +{ 1.1397 + uint* r_dst = &AY; 1.1398 + 1.1399 + *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1); 1.1400 +} 1.1401 + 1.1402 + 1.1403 +M68KMAKE_OP(addq, 32, ., .) 1.1404 +{ 1.1405 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.1406 + uint ea = M68KMAKE_GET_EA_AY_32; 1.1407 + uint dst = m68ki_read_32(ea); 1.1408 + uint res = src + dst; 1.1409 + 1.1410 + 1.1411 + FLAG_N = NFLAG_32(res); 1.1412 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1413 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1414 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.1415 + 1.1416 + m68ki_write_32(ea, FLAG_Z); 1.1417 +} 1.1418 + 1.1419 + 1.1420 +M68KMAKE_OP(addx, 8, rr, .) 1.1421 +{ 1.1422 + uint* r_dst = &DX; 1.1423 + uint src = MASK_OUT_ABOVE_8(DY); 1.1424 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.1425 + uint res = src + dst + XFLAG_AS_1(); 1.1426 + 1.1427 + FLAG_N = NFLAG_8(res); 1.1428 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1429 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1430 + 1.1431 + res = MASK_OUT_ABOVE_8(res); 1.1432 + FLAG_Z |= res; 1.1433 + 1.1434 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.1435 +} 1.1436 + 1.1437 + 1.1438 +M68KMAKE_OP(addx, 16, rr, .) 1.1439 +{ 1.1440 + uint* r_dst = &DX; 1.1441 + uint src = MASK_OUT_ABOVE_16(DY); 1.1442 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.1443 + uint res = src + dst + XFLAG_AS_1(); 1.1444 + 1.1445 + FLAG_N = NFLAG_16(res); 1.1446 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1447 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1448 + 1.1449 + res = MASK_OUT_ABOVE_16(res); 1.1450 + FLAG_Z |= res; 1.1451 + 1.1452 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.1453 +} 1.1454 + 1.1455 + 1.1456 +M68KMAKE_OP(addx, 32, rr, .) 1.1457 +{ 1.1458 + uint* r_dst = &DX; 1.1459 + uint src = DY; 1.1460 + uint dst = *r_dst; 1.1461 + uint res = src + dst + XFLAG_AS_1(); 1.1462 + 1.1463 + FLAG_N = NFLAG_32(res); 1.1464 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1465 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1466 + 1.1467 + res = MASK_OUT_ABOVE_32(res); 1.1468 + FLAG_Z |= res; 1.1469 + 1.1470 + *r_dst = res; 1.1471 +} 1.1472 + 1.1473 + 1.1474 +M68KMAKE_OP(addx, 8, mm, ax7) 1.1475 +{ 1.1476 + uint src = OPER_AY_PD_8(); 1.1477 + uint ea = EA_A7_PD_8(); 1.1478 + uint dst = m68ki_read_8(ea); 1.1479 + uint res = src + dst + XFLAG_AS_1(); 1.1480 + 1.1481 + FLAG_N = NFLAG_8(res); 1.1482 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1483 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1484 + 1.1485 + res = MASK_OUT_ABOVE_8(res); 1.1486 + FLAG_Z |= res; 1.1487 + 1.1488 + m68ki_write_8(ea, res); 1.1489 +} 1.1490 + 1.1491 + 1.1492 +M68KMAKE_OP(addx, 8, mm, ay7) 1.1493 +{ 1.1494 + uint src = OPER_A7_PD_8(); 1.1495 + uint ea = EA_AX_PD_8(); 1.1496 + uint dst = m68ki_read_8(ea); 1.1497 + uint res = src + dst + XFLAG_AS_1(); 1.1498 + 1.1499 + FLAG_N = NFLAG_8(res); 1.1500 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1501 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1502 + 1.1503 + res = MASK_OUT_ABOVE_8(res); 1.1504 + FLAG_Z |= res; 1.1505 + 1.1506 + m68ki_write_8(ea, res); 1.1507 +} 1.1508 + 1.1509 + 1.1510 +M68KMAKE_OP(addx, 8, mm, axy7) 1.1511 +{ 1.1512 + uint src = OPER_A7_PD_8(); 1.1513 + uint ea = EA_A7_PD_8(); 1.1514 + uint dst = m68ki_read_8(ea); 1.1515 + uint res = src + dst + XFLAG_AS_1(); 1.1516 + 1.1517 + FLAG_N = NFLAG_8(res); 1.1518 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1519 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1520 + 1.1521 + res = MASK_OUT_ABOVE_8(res); 1.1522 + FLAG_Z |= res; 1.1523 + 1.1524 + m68ki_write_8(ea, res); 1.1525 +} 1.1526 + 1.1527 + 1.1528 +M68KMAKE_OP(addx, 8, mm, .) 1.1529 +{ 1.1530 + uint src = OPER_AY_PD_8(); 1.1531 + uint ea = EA_AX_PD_8(); 1.1532 + uint dst = m68ki_read_8(ea); 1.1533 + uint res = src + dst + XFLAG_AS_1(); 1.1534 + 1.1535 + FLAG_N = NFLAG_8(res); 1.1536 + FLAG_V = VFLAG_ADD_8(src, dst, res); 1.1537 + FLAG_X = FLAG_C = CFLAG_8(res); 1.1538 + 1.1539 + res = MASK_OUT_ABOVE_8(res); 1.1540 + FLAG_Z |= res; 1.1541 + 1.1542 + m68ki_write_8(ea, res); 1.1543 +} 1.1544 + 1.1545 + 1.1546 +M68KMAKE_OP(addx, 16, mm, .) 1.1547 +{ 1.1548 + uint src = OPER_AY_PD_16(); 1.1549 + uint ea = EA_AX_PD_16(); 1.1550 + uint dst = m68ki_read_16(ea); 1.1551 + uint res = src + dst + XFLAG_AS_1(); 1.1552 + 1.1553 + FLAG_N = NFLAG_16(res); 1.1554 + FLAG_V = VFLAG_ADD_16(src, dst, res); 1.1555 + FLAG_X = FLAG_C = CFLAG_16(res); 1.1556 + 1.1557 + res = MASK_OUT_ABOVE_16(res); 1.1558 + FLAG_Z |= res; 1.1559 + 1.1560 + m68ki_write_16(ea, res); 1.1561 +} 1.1562 + 1.1563 + 1.1564 +M68KMAKE_OP(addx, 32, mm, .) 1.1565 +{ 1.1566 + uint src = OPER_AY_PD_32(); 1.1567 + uint ea = EA_AX_PD_32(); 1.1568 + uint dst = m68ki_read_32(ea); 1.1569 + uint res = src + dst + XFLAG_AS_1(); 1.1570 + 1.1571 + FLAG_N = NFLAG_32(res); 1.1572 + FLAG_V = VFLAG_ADD_32(src, dst, res); 1.1573 + FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res); 1.1574 + 1.1575 + res = MASK_OUT_ABOVE_32(res); 1.1576 + FLAG_Z |= res; 1.1577 + 1.1578 + m68ki_write_32(ea, res); 1.1579 +} 1.1580 + 1.1581 + 1.1582 +M68KMAKE_OP(and, 8, er, d) 1.1583 +{ 1.1584 + FLAG_Z = MASK_OUT_ABOVE_8(DX &= (DY | 0xffffff00)); 1.1585 + 1.1586 + FLAG_N = NFLAG_8(FLAG_Z); 1.1587 + FLAG_C = CFLAG_CLEAR; 1.1588 + FLAG_V = VFLAG_CLEAR; 1.1589 +} 1.1590 + 1.1591 + 1.1592 +M68KMAKE_OP(and, 8, er, .) 1.1593 +{ 1.1594 + FLAG_Z = MASK_OUT_ABOVE_8(DX &= (M68KMAKE_GET_OPER_AY_8 | 0xffffff00)); 1.1595 + 1.1596 + FLAG_N = NFLAG_8(FLAG_Z); 1.1597 + FLAG_C = CFLAG_CLEAR; 1.1598 + FLAG_V = VFLAG_CLEAR; 1.1599 +} 1.1600 + 1.1601 + 1.1602 +M68KMAKE_OP(and, 16, er, d) 1.1603 +{ 1.1604 + FLAG_Z = MASK_OUT_ABOVE_16(DX &= (DY | 0xffff0000)); 1.1605 + 1.1606 + FLAG_N = NFLAG_16(FLAG_Z); 1.1607 + FLAG_C = CFLAG_CLEAR; 1.1608 + FLAG_V = VFLAG_CLEAR; 1.1609 +} 1.1610 + 1.1611 + 1.1612 +M68KMAKE_OP(and, 16, er, .) 1.1613 +{ 1.1614 + FLAG_Z = MASK_OUT_ABOVE_16(DX &= (M68KMAKE_GET_OPER_AY_16 | 0xffff0000)); 1.1615 + 1.1616 + FLAG_N = NFLAG_16(FLAG_Z); 1.1617 + FLAG_C = CFLAG_CLEAR; 1.1618 + FLAG_V = VFLAG_CLEAR; 1.1619 +} 1.1620 + 1.1621 + 1.1622 +M68KMAKE_OP(and, 32, er, d) 1.1623 +{ 1.1624 + FLAG_Z = DX &= DY; 1.1625 + 1.1626 + FLAG_N = NFLAG_32(FLAG_Z); 1.1627 + FLAG_C = CFLAG_CLEAR; 1.1628 + FLAG_V = VFLAG_CLEAR; 1.1629 +} 1.1630 + 1.1631 + 1.1632 +M68KMAKE_OP(and, 32, er, .) 1.1633 +{ 1.1634 + FLAG_Z = DX &= M68KMAKE_GET_OPER_AY_32; 1.1635 + 1.1636 + FLAG_N = NFLAG_32(FLAG_Z); 1.1637 + FLAG_C = CFLAG_CLEAR; 1.1638 + FLAG_V = VFLAG_CLEAR; 1.1639 +} 1.1640 + 1.1641 + 1.1642 +M68KMAKE_OP(and, 8, re, .) 1.1643 +{ 1.1644 + uint ea = M68KMAKE_GET_EA_AY_8; 1.1645 + uint res = DX & m68ki_read_8(ea); 1.1646 + 1.1647 + FLAG_N = NFLAG_8(res); 1.1648 + FLAG_C = CFLAG_CLEAR; 1.1649 + FLAG_V = VFLAG_CLEAR; 1.1650 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.1651 + 1.1652 + m68ki_write_8(ea, FLAG_Z); 1.1653 +} 1.1654 + 1.1655 + 1.1656 +M68KMAKE_OP(and, 16, re, .) 1.1657 +{ 1.1658 + uint ea = M68KMAKE_GET_EA_AY_16; 1.1659 + uint res = DX & m68ki_read_16(ea); 1.1660 + 1.1661 + FLAG_N = NFLAG_16(res); 1.1662 + FLAG_C = CFLAG_CLEAR; 1.1663 + FLAG_V = VFLAG_CLEAR; 1.1664 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.1665 + 1.1666 + m68ki_write_16(ea, FLAG_Z); 1.1667 +} 1.1668 + 1.1669 + 1.1670 +M68KMAKE_OP(and, 32, re, .) 1.1671 +{ 1.1672 + uint ea = M68KMAKE_GET_EA_AY_32; 1.1673 + uint res = DX & m68ki_read_32(ea); 1.1674 + 1.1675 + FLAG_N = NFLAG_32(res); 1.1676 + FLAG_Z = res; 1.1677 + FLAG_C = CFLAG_CLEAR; 1.1678 + FLAG_V = VFLAG_CLEAR; 1.1679 + 1.1680 + m68ki_write_32(ea, res); 1.1681 +} 1.1682 + 1.1683 + 1.1684 +M68KMAKE_OP(andi, 8, ., d) 1.1685 +{ 1.1686 + FLAG_Z = MASK_OUT_ABOVE_8(DY &= (OPER_I_8() | 0xffffff00)); 1.1687 + 1.1688 + FLAG_N = NFLAG_8(FLAG_Z); 1.1689 + FLAG_C = CFLAG_CLEAR; 1.1690 + FLAG_V = VFLAG_CLEAR; 1.1691 +} 1.1692 + 1.1693 + 1.1694 +M68KMAKE_OP(andi, 8, ., .) 1.1695 +{ 1.1696 + uint src = OPER_I_8(); 1.1697 + uint ea = M68KMAKE_GET_EA_AY_8; 1.1698 + uint res = src & m68ki_read_8(ea); 1.1699 + 1.1700 + FLAG_N = NFLAG_8(res); 1.1701 + FLAG_Z = res; 1.1702 + FLAG_C = CFLAG_CLEAR; 1.1703 + FLAG_V = VFLAG_CLEAR; 1.1704 + 1.1705 + m68ki_write_8(ea, res); 1.1706 +} 1.1707 + 1.1708 + 1.1709 +M68KMAKE_OP(andi, 16, ., d) 1.1710 +{ 1.1711 + FLAG_Z = MASK_OUT_ABOVE_16(DY &= (OPER_I_16() | 0xffff0000)); 1.1712 + 1.1713 + FLAG_N = NFLAG_16(FLAG_Z); 1.1714 + FLAG_C = CFLAG_CLEAR; 1.1715 + FLAG_V = VFLAG_CLEAR; 1.1716 +} 1.1717 + 1.1718 + 1.1719 +M68KMAKE_OP(andi, 16, ., .) 1.1720 +{ 1.1721 + uint src = OPER_I_16(); 1.1722 + uint ea = M68KMAKE_GET_EA_AY_16; 1.1723 + uint res = src & m68ki_read_16(ea); 1.1724 + 1.1725 + FLAG_N = NFLAG_16(res); 1.1726 + FLAG_Z = res; 1.1727 + FLAG_C = CFLAG_CLEAR; 1.1728 + FLAG_V = VFLAG_CLEAR; 1.1729 + 1.1730 + m68ki_write_16(ea, res); 1.1731 +} 1.1732 + 1.1733 + 1.1734 +M68KMAKE_OP(andi, 32, ., d) 1.1735 +{ 1.1736 + FLAG_Z = DY &= (OPER_I_32()); 1.1737 + 1.1738 + FLAG_N = NFLAG_32(FLAG_Z); 1.1739 + FLAG_C = CFLAG_CLEAR; 1.1740 + FLAG_V = VFLAG_CLEAR; 1.1741 +} 1.1742 + 1.1743 + 1.1744 +M68KMAKE_OP(andi, 32, ., .) 1.1745 +{ 1.1746 + uint src = OPER_I_32(); 1.1747 + uint ea = M68KMAKE_GET_EA_AY_32; 1.1748 + uint res = src & m68ki_read_32(ea); 1.1749 + 1.1750 + FLAG_N = NFLAG_32(res); 1.1751 + FLAG_Z = res; 1.1752 + FLAG_C = CFLAG_CLEAR; 1.1753 + FLAG_V = VFLAG_CLEAR; 1.1754 + 1.1755 + m68ki_write_32(ea, res); 1.1756 +} 1.1757 + 1.1758 + 1.1759 +M68KMAKE_OP(andi, 16, toc, .) 1.1760 +{ 1.1761 + m68ki_set_ccr(m68ki_get_ccr() & OPER_I_16()); 1.1762 +} 1.1763 + 1.1764 + 1.1765 +M68KMAKE_OP(andi, 16, tos, .) 1.1766 +{ 1.1767 + if(FLAG_S) 1.1768 + { 1.1769 + uint src = OPER_I_16(); 1.1770 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.1771 + m68ki_set_sr(m68ki_get_sr() & src); 1.1772 + return; 1.1773 + } 1.1774 + m68ki_exception_privilege_violation(); 1.1775 +} 1.1776 + 1.1777 + 1.1778 +M68KMAKE_OP(asr, 8, s, .) 1.1779 +{ 1.1780 + uint* r_dst = &DY; 1.1781 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.1782 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.1783 + uint res = src >> shift; 1.1784 + 1.1785 + if(GET_MSB_8(src)) 1.1786 + res |= m68ki_shift_8_table[shift]; 1.1787 + 1.1788 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.1789 + 1.1790 + FLAG_N = NFLAG_8(res); 1.1791 + FLAG_Z = res; 1.1792 + FLAG_V = VFLAG_CLEAR; 1.1793 + FLAG_X = FLAG_C = src << (9-shift); 1.1794 +} 1.1795 + 1.1796 + 1.1797 +M68KMAKE_OP(asr, 16, s, .) 1.1798 +{ 1.1799 + uint* r_dst = &DY; 1.1800 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.1801 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.1802 + uint res = src >> shift; 1.1803 + 1.1804 + if(GET_MSB_16(src)) 1.1805 + res |= m68ki_shift_16_table[shift]; 1.1806 + 1.1807 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.1808 + 1.1809 + FLAG_N = NFLAG_16(res); 1.1810 + FLAG_Z = res; 1.1811 + FLAG_V = VFLAG_CLEAR; 1.1812 + FLAG_X = FLAG_C = src << (9-shift); 1.1813 +} 1.1814 + 1.1815 + 1.1816 +M68KMAKE_OP(asr, 32, s, .) 1.1817 +{ 1.1818 + uint* r_dst = &DY; 1.1819 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.1820 + uint src = *r_dst; 1.1821 + uint res = src >> shift; 1.1822 + 1.1823 + if(GET_MSB_32(src)) 1.1824 + res |= m68ki_shift_32_table[shift]; 1.1825 + 1.1826 + *r_dst = res; 1.1827 + 1.1828 + FLAG_N = NFLAG_32(res); 1.1829 + FLAG_Z = res; 1.1830 + FLAG_V = VFLAG_CLEAR; 1.1831 + FLAG_X = FLAG_C = src << (9-shift); 1.1832 +} 1.1833 + 1.1834 + 1.1835 +M68KMAKE_OP(asr, 8, r, .) 1.1836 +{ 1.1837 + uint* r_dst = &DY; 1.1838 + uint shift = DX & 0x3f; 1.1839 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.1840 + uint res = src >> shift; 1.1841 + 1.1842 + if(shift != 0) 1.1843 + { 1.1844 + USE_CYCLES(shift<<CYC_SHIFT); 1.1845 + 1.1846 + if(shift < 8) 1.1847 + { 1.1848 + if(GET_MSB_8(src)) 1.1849 + res |= m68ki_shift_8_table[shift]; 1.1850 + 1.1851 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.1852 + 1.1853 + FLAG_X = FLAG_C = src << (9-shift); 1.1854 + FLAG_N = NFLAG_8(res); 1.1855 + FLAG_Z = res; 1.1856 + FLAG_V = VFLAG_CLEAR; 1.1857 + return; 1.1858 + } 1.1859 + 1.1860 + if(GET_MSB_8(src)) 1.1861 + { 1.1862 + *r_dst |= 0xff; 1.1863 + FLAG_C = CFLAG_SET; 1.1864 + FLAG_X = XFLAG_SET; 1.1865 + FLAG_N = NFLAG_SET; 1.1866 + FLAG_Z = ZFLAG_CLEAR; 1.1867 + FLAG_V = VFLAG_CLEAR; 1.1868 + return; 1.1869 + } 1.1870 + 1.1871 + *r_dst &= 0xffffff00; 1.1872 + FLAG_C = CFLAG_CLEAR; 1.1873 + FLAG_X = XFLAG_CLEAR; 1.1874 + FLAG_N = NFLAG_CLEAR; 1.1875 + FLAG_Z = ZFLAG_SET; 1.1876 + FLAG_V = VFLAG_CLEAR; 1.1877 + return; 1.1878 + } 1.1879 + 1.1880 + FLAG_C = CFLAG_CLEAR; 1.1881 + FLAG_N = NFLAG_8(src); 1.1882 + FLAG_Z = src; 1.1883 + FLAG_V = VFLAG_CLEAR; 1.1884 +} 1.1885 + 1.1886 + 1.1887 +M68KMAKE_OP(asr, 16, r, .) 1.1888 +{ 1.1889 + uint* r_dst = &DY; 1.1890 + uint shift = DX & 0x3f; 1.1891 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.1892 + uint res = src >> shift; 1.1893 + 1.1894 + if(shift != 0) 1.1895 + { 1.1896 + USE_CYCLES(shift<<CYC_SHIFT); 1.1897 + 1.1898 + if(shift < 16) 1.1899 + { 1.1900 + if(GET_MSB_16(src)) 1.1901 + res |= m68ki_shift_16_table[shift]; 1.1902 + 1.1903 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.1904 + 1.1905 + FLAG_C = FLAG_X = (src >> (shift - 1))<<8; 1.1906 + FLAG_N = NFLAG_16(res); 1.1907 + FLAG_Z = res; 1.1908 + FLAG_V = VFLAG_CLEAR; 1.1909 + return; 1.1910 + } 1.1911 + 1.1912 + if(GET_MSB_16(src)) 1.1913 + { 1.1914 + *r_dst |= 0xffff; 1.1915 + FLAG_C = CFLAG_SET; 1.1916 + FLAG_X = XFLAG_SET; 1.1917 + FLAG_N = NFLAG_SET; 1.1918 + FLAG_Z = ZFLAG_CLEAR; 1.1919 + FLAG_V = VFLAG_CLEAR; 1.1920 + return; 1.1921 + } 1.1922 + 1.1923 + *r_dst &= 0xffff0000; 1.1924 + FLAG_C = CFLAG_CLEAR; 1.1925 + FLAG_X = XFLAG_CLEAR; 1.1926 + FLAG_N = NFLAG_CLEAR; 1.1927 + FLAG_Z = ZFLAG_SET; 1.1928 + FLAG_V = VFLAG_CLEAR; 1.1929 + return; 1.1930 + } 1.1931 + 1.1932 + FLAG_C = CFLAG_CLEAR; 1.1933 + FLAG_N = NFLAG_16(src); 1.1934 + FLAG_Z = src; 1.1935 + FLAG_V = VFLAG_CLEAR; 1.1936 +} 1.1937 + 1.1938 + 1.1939 +M68KMAKE_OP(asr, 32, r, .) 1.1940 +{ 1.1941 + uint* r_dst = &DY; 1.1942 + uint shift = DX & 0x3f; 1.1943 + uint src = *r_dst; 1.1944 + uint res = src >> shift; 1.1945 + 1.1946 + if(shift != 0) 1.1947 + { 1.1948 + USE_CYCLES(shift<<CYC_SHIFT); 1.1949 + 1.1950 + if(shift < 32) 1.1951 + { 1.1952 + if(GET_MSB_32(src)) 1.1953 + res |= m68ki_shift_32_table[shift]; 1.1954 + 1.1955 + *r_dst = res; 1.1956 + 1.1957 + FLAG_C = FLAG_X = (src >> (shift - 1))<<8; 1.1958 + FLAG_N = NFLAG_32(res); 1.1959 + FLAG_Z = res; 1.1960 + FLAG_V = VFLAG_CLEAR; 1.1961 + return; 1.1962 + } 1.1963 + 1.1964 + if(GET_MSB_32(src)) 1.1965 + { 1.1966 + *r_dst = 0xffffffff; 1.1967 + FLAG_C = CFLAG_SET; 1.1968 + FLAG_X = XFLAG_SET; 1.1969 + FLAG_N = NFLAG_SET; 1.1970 + FLAG_Z = ZFLAG_CLEAR; 1.1971 + FLAG_V = VFLAG_CLEAR; 1.1972 + return; 1.1973 + } 1.1974 + 1.1975 + *r_dst = 0; 1.1976 + FLAG_C = CFLAG_CLEAR; 1.1977 + FLAG_X = XFLAG_CLEAR; 1.1978 + FLAG_N = NFLAG_CLEAR; 1.1979 + FLAG_Z = ZFLAG_SET; 1.1980 + FLAG_V = VFLAG_CLEAR; 1.1981 + return; 1.1982 + } 1.1983 + 1.1984 + FLAG_C = CFLAG_CLEAR; 1.1985 + FLAG_N = NFLAG_32(src); 1.1986 + FLAG_Z = src; 1.1987 + FLAG_V = VFLAG_CLEAR; 1.1988 +} 1.1989 + 1.1990 + 1.1991 +M68KMAKE_OP(asr, 16, ., .) 1.1992 +{ 1.1993 + uint ea = M68KMAKE_GET_EA_AY_16; 1.1994 + uint src = m68ki_read_16(ea); 1.1995 + uint res = src >> 1; 1.1996 + 1.1997 + if(GET_MSB_16(src)) 1.1998 + res |= 0x8000; 1.1999 + 1.2000 + m68ki_write_16(ea, res); 1.2001 + 1.2002 + FLAG_N = NFLAG_16(res); 1.2003 + FLAG_Z = res; 1.2004 + FLAG_V = VFLAG_CLEAR; 1.2005 + FLAG_C = FLAG_X = src << 8; 1.2006 +} 1.2007 + 1.2008 + 1.2009 +M68KMAKE_OP(asl, 8, s, .) 1.2010 +{ 1.2011 + uint* r_dst = &DY; 1.2012 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.2013 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.2014 + uint res = MASK_OUT_ABOVE_8(src << shift); 1.2015 + 1.2016 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.2017 + 1.2018 + FLAG_X = FLAG_C = src << shift; 1.2019 + FLAG_N = NFLAG_8(res); 1.2020 + FLAG_Z = res; 1.2021 + src &= m68ki_shift_8_table[shift + 1]; 1.2022 + FLAG_V = (!(src == 0 || (src == m68ki_shift_8_table[shift + 1] && shift < 8)))<<7; 1.2023 +} 1.2024 + 1.2025 + 1.2026 +M68KMAKE_OP(asl, 16, s, .) 1.2027 +{ 1.2028 + uint* r_dst = &DY; 1.2029 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.2030 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.2031 + uint res = MASK_OUT_ABOVE_16(src << shift); 1.2032 + 1.2033 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.2034 + 1.2035 + FLAG_N = NFLAG_16(res); 1.2036 + FLAG_Z = res; 1.2037 + FLAG_X = FLAG_C = src >> (8-shift); 1.2038 + src &= m68ki_shift_16_table[shift + 1]; 1.2039 + FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7; 1.2040 +} 1.2041 + 1.2042 + 1.2043 +M68KMAKE_OP(asl, 32, s, .) 1.2044 +{ 1.2045 + uint* r_dst = &DY; 1.2046 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.2047 + uint src = *r_dst; 1.2048 + uint res = MASK_OUT_ABOVE_32(src << shift); 1.2049 + 1.2050 + *r_dst = res; 1.2051 + 1.2052 + FLAG_N = NFLAG_32(res); 1.2053 + FLAG_Z = res; 1.2054 + FLAG_X = FLAG_C = src >> (24-shift); 1.2055 + src &= m68ki_shift_32_table[shift + 1]; 1.2056 + FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7; 1.2057 +} 1.2058 + 1.2059 + 1.2060 +M68KMAKE_OP(asl, 8, r, .) 1.2061 +{ 1.2062 + uint* r_dst = &DY; 1.2063 + uint shift = DX & 0x3f; 1.2064 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.2065 + uint res = MASK_OUT_ABOVE_8(src << shift); 1.2066 + 1.2067 + if(shift != 0) 1.2068 + { 1.2069 + USE_CYCLES(shift<<CYC_SHIFT); 1.2070 + 1.2071 + if(shift < 8) 1.2072 + { 1.2073 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.2074 + FLAG_X = FLAG_C = src << shift; 1.2075 + FLAG_N = NFLAG_8(res); 1.2076 + FLAG_Z = res; 1.2077 + src &= m68ki_shift_8_table[shift + 1]; 1.2078 + FLAG_V = (!(src == 0 || src == m68ki_shift_8_table[shift + 1]))<<7; 1.2079 + return; 1.2080 + } 1.2081 + 1.2082 + *r_dst &= 0xffffff00; 1.2083 + FLAG_X = FLAG_C = ((shift == 8 ? src & 1 : 0))<<8; 1.2084 + FLAG_N = NFLAG_CLEAR; 1.2085 + FLAG_Z = ZFLAG_SET; 1.2086 + FLAG_V = (!(src == 0))<<7; 1.2087 + return; 1.2088 + } 1.2089 + 1.2090 + FLAG_C = CFLAG_CLEAR; 1.2091 + FLAG_N = NFLAG_8(src); 1.2092 + FLAG_Z = src; 1.2093 + FLAG_V = VFLAG_CLEAR; 1.2094 +} 1.2095 + 1.2096 + 1.2097 +M68KMAKE_OP(asl, 16, r, .) 1.2098 +{ 1.2099 + uint* r_dst = &DY; 1.2100 + uint shift = DX & 0x3f; 1.2101 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.2102 + uint res = MASK_OUT_ABOVE_16(src << shift); 1.2103 + 1.2104 + if(shift != 0) 1.2105 + { 1.2106 + USE_CYCLES(shift<<CYC_SHIFT); 1.2107 + 1.2108 + if(shift < 16) 1.2109 + { 1.2110 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.2111 + FLAG_X = FLAG_C = (src << shift) >> 8; 1.2112 + FLAG_N = NFLAG_16(res); 1.2113 + FLAG_Z = res; 1.2114 + src &= m68ki_shift_16_table[shift + 1]; 1.2115 + FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7; 1.2116 + return; 1.2117 + } 1.2118 + 1.2119 + *r_dst &= 0xffff0000; 1.2120 + FLAG_X = FLAG_C = ((shift == 16 ? src & 1 : 0))<<8; 1.2121 + FLAG_N = NFLAG_CLEAR; 1.2122 + FLAG_Z = ZFLAG_SET; 1.2123 + FLAG_V = (!(src == 0))<<7; 1.2124 + return; 1.2125 + } 1.2126 + 1.2127 + FLAG_C = CFLAG_CLEAR; 1.2128 + FLAG_N = NFLAG_16(src); 1.2129 + FLAG_Z = src; 1.2130 + FLAG_V = VFLAG_CLEAR; 1.2131 +} 1.2132 + 1.2133 + 1.2134 +M68KMAKE_OP(asl, 32, r, .) 1.2135 +{ 1.2136 + uint* r_dst = &DY; 1.2137 + uint shift = DX & 0x3f; 1.2138 + uint src = *r_dst; 1.2139 + uint res = MASK_OUT_ABOVE_32(src << shift); 1.2140 + 1.2141 + if(shift != 0) 1.2142 + { 1.2143 + USE_CYCLES(shift<<CYC_SHIFT); 1.2144 + 1.2145 + if(shift < 32) 1.2146 + { 1.2147 + *r_dst = res; 1.2148 + FLAG_X = FLAG_C = (src >> (32 - shift)) << 8; 1.2149 + FLAG_N = NFLAG_32(res); 1.2150 + FLAG_Z = res; 1.2151 + src &= m68ki_shift_32_table[shift + 1]; 1.2152 + FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7; 1.2153 + return; 1.2154 + } 1.2155 + 1.2156 + *r_dst = 0; 1.2157 + FLAG_X = FLAG_C = ((shift == 32 ? src & 1 : 0))<<8; 1.2158 + FLAG_N = NFLAG_CLEAR; 1.2159 + FLAG_Z = ZFLAG_SET; 1.2160 + FLAG_V = (!(src == 0))<<7; 1.2161 + return; 1.2162 + } 1.2163 + 1.2164 + FLAG_C = CFLAG_CLEAR; 1.2165 + FLAG_N = NFLAG_32(src); 1.2166 + FLAG_Z = src; 1.2167 + FLAG_V = VFLAG_CLEAR; 1.2168 +} 1.2169 + 1.2170 + 1.2171 +M68KMAKE_OP(asl, 16, ., .) 1.2172 +{ 1.2173 + uint ea = M68KMAKE_GET_EA_AY_16; 1.2174 + uint src = m68ki_read_16(ea); 1.2175 + uint res = MASK_OUT_ABOVE_16(src << 1); 1.2176 + 1.2177 + m68ki_write_16(ea, res); 1.2178 + 1.2179 + FLAG_N = NFLAG_16(res); 1.2180 + FLAG_Z = res; 1.2181 + FLAG_X = FLAG_C = src >> 7; 1.2182 + src &= 0xc000; 1.2183 + FLAG_V = (!(src == 0 || src == 0xc000))<<7; 1.2184 +} 1.2185 + 1.2186 + 1.2187 +M68KMAKE_OP(bcc, 8, ., .) 1.2188 +{ 1.2189 + if(M68KMAKE_CC) 1.2190 + { 1.2191 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.2192 + m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR)); 1.2193 + return; 1.2194 + } 1.2195 + USE_CYCLES(CYC_BCC_NOTAKE_B); 1.2196 +} 1.2197 + 1.2198 + 1.2199 +M68KMAKE_OP(bcc, 16, ., .) 1.2200 +{ 1.2201 + if(M68KMAKE_CC) 1.2202 + { 1.2203 + uint offset = OPER_I_16(); 1.2204 + REG_PC -= 2; 1.2205 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.2206 + m68ki_branch_16(offset); 1.2207 + return; 1.2208 + } 1.2209 + REG_PC += 2; 1.2210 + USE_CYCLES(CYC_BCC_NOTAKE_W); 1.2211 +} 1.2212 + 1.2213 + 1.2214 +M68KMAKE_OP(bcc, 32, ., .) 1.2215 +{ 1.2216 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2217 + { 1.2218 + if(M68KMAKE_CC) 1.2219 + { 1.2220 + uint offset = OPER_I_32(); 1.2221 + REG_PC -= 4; 1.2222 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.2223 + m68ki_branch_32(offset); 1.2224 + return; 1.2225 + } 1.2226 + REG_PC += 4; 1.2227 + return; 1.2228 + } 1.2229 + m68ki_exception_illegal(); 1.2230 +} 1.2231 + 1.2232 + 1.2233 +M68KMAKE_OP(bchg, 32, r, d) 1.2234 +{ 1.2235 + uint* r_dst = &DY; 1.2236 + uint mask = 1 << (DX & 0x1f); 1.2237 + 1.2238 + FLAG_Z = *r_dst & mask; 1.2239 + *r_dst ^= mask; 1.2240 +} 1.2241 + 1.2242 + 1.2243 +M68KMAKE_OP(bchg, 8, r, .) 1.2244 +{ 1.2245 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2246 + uint src = m68ki_read_8(ea); 1.2247 + uint mask = 1 << (DX & 7); 1.2248 + 1.2249 + FLAG_Z = src & mask; 1.2250 + m68ki_write_8(ea, src ^ mask); 1.2251 +} 1.2252 + 1.2253 + 1.2254 +M68KMAKE_OP(bchg, 32, s, d) 1.2255 +{ 1.2256 + uint* r_dst = &DY; 1.2257 + uint mask = 1 << (OPER_I_8() & 0x1f); 1.2258 + 1.2259 + FLAG_Z = *r_dst & mask; 1.2260 + *r_dst ^= mask; 1.2261 +} 1.2262 + 1.2263 + 1.2264 +M68KMAKE_OP(bchg, 8, s, .) 1.2265 +{ 1.2266 + uint mask = 1 << (OPER_I_8() & 7); 1.2267 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2268 + uint src = m68ki_read_8(ea); 1.2269 + 1.2270 + FLAG_Z = src & mask; 1.2271 + m68ki_write_8(ea, src ^ mask); 1.2272 +} 1.2273 + 1.2274 + 1.2275 +M68KMAKE_OP(bclr, 32, r, d) 1.2276 +{ 1.2277 + uint* r_dst = &DY; 1.2278 + uint mask = 1 << (DX & 0x1f); 1.2279 + 1.2280 + FLAG_Z = *r_dst & mask; 1.2281 + *r_dst &= ~mask; 1.2282 +} 1.2283 + 1.2284 + 1.2285 +M68KMAKE_OP(bclr, 8, r, .) 1.2286 +{ 1.2287 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2288 + uint src = m68ki_read_8(ea); 1.2289 + uint mask = 1 << (DX & 7); 1.2290 + 1.2291 + FLAG_Z = src & mask; 1.2292 + m68ki_write_8(ea, src & ~mask); 1.2293 +} 1.2294 + 1.2295 + 1.2296 +M68KMAKE_OP(bclr, 32, s, d) 1.2297 +{ 1.2298 + uint* r_dst = &DY; 1.2299 + uint mask = 1 << (OPER_I_8() & 0x1f); 1.2300 + 1.2301 + FLAG_Z = *r_dst & mask; 1.2302 + *r_dst &= ~mask; 1.2303 +} 1.2304 + 1.2305 + 1.2306 +M68KMAKE_OP(bclr, 8, s, .) 1.2307 +{ 1.2308 + uint mask = 1 << (OPER_I_8() & 7); 1.2309 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2310 + uint src = m68ki_read_8(ea); 1.2311 + 1.2312 + FLAG_Z = src & mask; 1.2313 + m68ki_write_8(ea, src & ~mask); 1.2314 +} 1.2315 + 1.2316 + 1.2317 +M68KMAKE_OP(bfchg, 32, ., d) 1.2318 +{ 1.2319 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2320 + { 1.2321 + uint word2 = OPER_I_16(); 1.2322 + uint offset = (word2>>6)&31; 1.2323 + uint width = word2; 1.2324 + uint* data = &DY; 1.2325 + uint64 mask; 1.2326 + 1.2327 + 1.2328 + if(BIT_B(word2)) 1.2329 + offset = REG_D[offset&7]; 1.2330 + if(BIT_5(word2)) 1.2331 + width = REG_D[width&7]; 1.2332 + 1.2333 + offset &= 31; 1.2334 + width = ((width-1) & 31) + 1; 1.2335 + 1.2336 + mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2337 + mask = ROR_32(mask, offset); 1.2338 + 1.2339 + FLAG_N = NFLAG_32(*data<<offset); 1.2340 + FLAG_Z = *data & mask; 1.2341 + FLAG_V = VFLAG_CLEAR; 1.2342 + FLAG_C = CFLAG_CLEAR; 1.2343 + 1.2344 + *data ^= mask; 1.2345 + 1.2346 + return; 1.2347 + } 1.2348 + m68ki_exception_illegal(); 1.2349 +} 1.2350 + 1.2351 + 1.2352 +M68KMAKE_OP(bfchg, 32, ., .) 1.2353 +{ 1.2354 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2355 + { 1.2356 + uint word2 = OPER_I_16(); 1.2357 + sint offset = (word2>>6)&31; 1.2358 + uint width = word2; 1.2359 + uint mask_base; 1.2360 + uint data_long; 1.2361 + uint mask_long; 1.2362 + uint data_byte = 0; 1.2363 + uint mask_byte = 0; 1.2364 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2365 + 1.2366 + 1.2367 + if(BIT_B(word2)) 1.2368 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2369 + if(BIT_5(word2)) 1.2370 + width = REG_D[width&7]; 1.2371 + 1.2372 + /* Offset is signed so we have to use ugly math =( */ 1.2373 + ea += offset / 8; 1.2374 + offset %= 8; 1.2375 + if(offset < 0) 1.2376 + { 1.2377 + offset += 8; 1.2378 + ea--; 1.2379 + } 1.2380 + width = ((width-1) & 31) + 1; 1.2381 + 1.2382 + mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2383 + mask_long = mask_base >> offset; 1.2384 + 1.2385 + data_long = m68ki_read_32(ea); 1.2386 + FLAG_N = NFLAG_32(data_long << offset); 1.2387 + FLAG_Z = data_long & mask_long; 1.2388 + FLAG_V = VFLAG_CLEAR; 1.2389 + FLAG_C = CFLAG_CLEAR; 1.2390 + 1.2391 + m68ki_write_32(ea, data_long ^ mask_long); 1.2392 + 1.2393 + if((width + offset) > 32) 1.2394 + { 1.2395 + mask_byte = MASK_OUT_ABOVE_8(mask_base); 1.2396 + data_byte = m68ki_read_8(ea+4); 1.2397 + FLAG_Z |= (data_byte & mask_byte); 1.2398 + m68ki_write_8(ea+4, data_byte ^ mask_byte); 1.2399 + } 1.2400 + return; 1.2401 + } 1.2402 + m68ki_exception_illegal(); 1.2403 +} 1.2404 + 1.2405 + 1.2406 +M68KMAKE_OP(bfclr, 32, ., d) 1.2407 +{ 1.2408 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2409 + { 1.2410 + uint word2 = OPER_I_16(); 1.2411 + uint offset = (word2>>6)&31; 1.2412 + uint width = word2; 1.2413 + uint* data = &DY; 1.2414 + uint64 mask; 1.2415 + 1.2416 + 1.2417 + if(BIT_B(word2)) 1.2418 + offset = REG_D[offset&7]; 1.2419 + if(BIT_5(word2)) 1.2420 + width = REG_D[width&7]; 1.2421 + 1.2422 + 1.2423 + offset &= 31; 1.2424 + width = ((width-1) & 31) + 1; 1.2425 + 1.2426 + 1.2427 + mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2428 + mask = ROR_32(mask, offset); 1.2429 + 1.2430 + FLAG_N = NFLAG_32(*data<<offset); 1.2431 + FLAG_Z = *data & mask; 1.2432 + FLAG_V = VFLAG_CLEAR; 1.2433 + FLAG_C = CFLAG_CLEAR; 1.2434 + 1.2435 + *data &= ~mask; 1.2436 + 1.2437 + return; 1.2438 + } 1.2439 + m68ki_exception_illegal(); 1.2440 +} 1.2441 + 1.2442 + 1.2443 +M68KMAKE_OP(bfclr, 32, ., .) 1.2444 +{ 1.2445 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2446 + { 1.2447 + uint word2 = OPER_I_16(); 1.2448 + sint offset = (word2>>6)&31; 1.2449 + uint width = word2; 1.2450 + uint mask_base; 1.2451 + uint data_long; 1.2452 + uint mask_long; 1.2453 + uint data_byte = 0; 1.2454 + uint mask_byte = 0; 1.2455 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2456 + 1.2457 + 1.2458 + if(BIT_B(word2)) 1.2459 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2460 + if(BIT_5(word2)) 1.2461 + width = REG_D[width&7]; 1.2462 + 1.2463 + /* Offset is signed so we have to use ugly math =( */ 1.2464 + ea += offset / 8; 1.2465 + offset %= 8; 1.2466 + if(offset < 0) 1.2467 + { 1.2468 + offset += 8; 1.2469 + ea--; 1.2470 + } 1.2471 + width = ((width-1) & 31) + 1; 1.2472 + 1.2473 + mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2474 + mask_long = mask_base >> offset; 1.2475 + 1.2476 + data_long = m68ki_read_32(ea); 1.2477 + FLAG_N = NFLAG_32(data_long << offset); 1.2478 + FLAG_Z = data_long & mask_long; 1.2479 + FLAG_V = VFLAG_CLEAR; 1.2480 + FLAG_C = CFLAG_CLEAR; 1.2481 + 1.2482 + m68ki_write_32(ea, data_long & ~mask_long); 1.2483 + 1.2484 + if((width + offset) > 32) 1.2485 + { 1.2486 + mask_byte = MASK_OUT_ABOVE_8(mask_base); 1.2487 + data_byte = m68ki_read_8(ea+4); 1.2488 + FLAG_Z |= (data_byte & mask_byte); 1.2489 + m68ki_write_8(ea+4, data_byte & ~mask_byte); 1.2490 + } 1.2491 + return; 1.2492 + } 1.2493 + m68ki_exception_illegal(); 1.2494 +} 1.2495 + 1.2496 + 1.2497 +M68KMAKE_OP(bfexts, 32, ., d) 1.2498 +{ 1.2499 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2500 + { 1.2501 + uint word2 = OPER_I_16(); 1.2502 + uint offset = (word2>>6)&31; 1.2503 + uint width = word2; 1.2504 + uint64 data = DY; 1.2505 + 1.2506 + 1.2507 + if(BIT_B(word2)) 1.2508 + offset = REG_D[offset&7]; 1.2509 + if(BIT_5(word2)) 1.2510 + width = REG_D[width&7]; 1.2511 + 1.2512 + offset &= 31; 1.2513 + width = ((width-1) & 31) + 1; 1.2514 + 1.2515 + data = ROL_32(data, offset); 1.2516 + FLAG_N = NFLAG_32(data); 1.2517 + data = MAKE_INT_32(data) >> (32 - width); 1.2518 + 1.2519 + FLAG_Z = data; 1.2520 + FLAG_V = VFLAG_CLEAR; 1.2521 + FLAG_C = CFLAG_CLEAR; 1.2522 + 1.2523 + REG_D[(word2>>12)&7] = data; 1.2524 + 1.2525 + return; 1.2526 + } 1.2527 + m68ki_exception_illegal(); 1.2528 +} 1.2529 + 1.2530 + 1.2531 +M68KMAKE_OP(bfexts, 32, ., .) 1.2532 +{ 1.2533 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2534 + { 1.2535 + uint word2 = OPER_I_16(); 1.2536 + sint offset = (word2>>6)&31; 1.2537 + uint width = word2; 1.2538 + uint data; 1.2539 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2540 + 1.2541 + 1.2542 + if(BIT_B(word2)) 1.2543 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2544 + if(BIT_5(word2)) 1.2545 + width = REG_D[width&7]; 1.2546 + 1.2547 + /* Offset is signed so we have to use ugly math =( */ 1.2548 + ea += offset / 8; 1.2549 + offset %= 8; 1.2550 + if(offset < 0) 1.2551 + { 1.2552 + offset += 8; 1.2553 + ea--; 1.2554 + } 1.2555 + width = ((width-1) & 31) + 1; 1.2556 + 1.2557 + data = m68ki_read_32(ea); 1.2558 + 1.2559 + data = MASK_OUT_ABOVE_32(data<<offset); 1.2560 + 1.2561 + if((offset+width) > 32) 1.2562 + data |= (m68ki_read_8(ea+4) << offset) >> 8; 1.2563 + 1.2564 + FLAG_N = NFLAG_32(data); 1.2565 + data = MAKE_INT_32(data) >> (32 - width); 1.2566 + 1.2567 + FLAG_Z = data; 1.2568 + FLAG_V = VFLAG_CLEAR; 1.2569 + FLAG_C = CFLAG_CLEAR; 1.2570 + 1.2571 + REG_D[(word2 >> 12) & 7] = data; 1.2572 + 1.2573 + return; 1.2574 + } 1.2575 + m68ki_exception_illegal(); 1.2576 +} 1.2577 + 1.2578 + 1.2579 +M68KMAKE_OP(bfextu, 32, ., d) 1.2580 +{ 1.2581 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2582 + { 1.2583 + uint word2 = OPER_I_16(); 1.2584 + uint offset = (word2>>6)&31; 1.2585 + uint width = word2; 1.2586 + uint64 data = DY; 1.2587 + 1.2588 + 1.2589 + if(BIT_B(word2)) 1.2590 + offset = REG_D[offset&7]; 1.2591 + if(BIT_5(word2)) 1.2592 + width = REG_D[width&7]; 1.2593 + 1.2594 + offset &= 31; 1.2595 + width = ((width-1) & 31) + 1; 1.2596 + 1.2597 + data = ROL_32(data, offset); 1.2598 + FLAG_N = NFLAG_32(data); 1.2599 + data >>= 32 - width; 1.2600 + 1.2601 + FLAG_Z = data; 1.2602 + FLAG_V = VFLAG_CLEAR; 1.2603 + FLAG_C = CFLAG_CLEAR; 1.2604 + 1.2605 + REG_D[(word2>>12)&7] = data; 1.2606 + 1.2607 + return; 1.2608 + } 1.2609 + m68ki_exception_illegal(); 1.2610 +} 1.2611 + 1.2612 + 1.2613 +M68KMAKE_OP(bfextu, 32, ., .) 1.2614 +{ 1.2615 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2616 + { 1.2617 + uint word2 = OPER_I_16(); 1.2618 + sint offset = (word2>>6)&31; 1.2619 + uint width = word2; 1.2620 + uint data; 1.2621 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2622 + 1.2623 + 1.2624 + if(BIT_B(word2)) 1.2625 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2626 + if(BIT_5(word2)) 1.2627 + width = REG_D[width&7]; 1.2628 + 1.2629 + /* Offset is signed so we have to use ugly math =( */ 1.2630 + ea += offset / 8; 1.2631 + offset %= 8; 1.2632 + if(offset < 0) 1.2633 + { 1.2634 + offset += 8; 1.2635 + ea--; 1.2636 + } 1.2637 + width = ((width-1) & 31) + 1; 1.2638 + 1.2639 + data = m68ki_read_32(ea); 1.2640 + data = MASK_OUT_ABOVE_32(data<<offset); 1.2641 + 1.2642 + if((offset+width) > 32) 1.2643 + data |= (m68ki_read_8(ea+4) << offset) >> 8; 1.2644 + 1.2645 + FLAG_N = NFLAG_32(data); 1.2646 + data >>= (32 - width); 1.2647 + 1.2648 + FLAG_Z = data; 1.2649 + FLAG_V = VFLAG_CLEAR; 1.2650 + FLAG_C = CFLAG_CLEAR; 1.2651 + 1.2652 + REG_D[(word2 >> 12) & 7] = data; 1.2653 + 1.2654 + return; 1.2655 + } 1.2656 + m68ki_exception_illegal(); 1.2657 +} 1.2658 + 1.2659 + 1.2660 +M68KMAKE_OP(bfffo, 32, ., d) 1.2661 +{ 1.2662 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2663 + { 1.2664 + uint word2 = OPER_I_16(); 1.2665 + uint offset = (word2>>6)&31; 1.2666 + uint width = word2; 1.2667 + uint64 data = DY; 1.2668 + uint bit; 1.2669 + 1.2670 + 1.2671 + if(BIT_B(word2)) 1.2672 + offset = REG_D[offset&7]; 1.2673 + if(BIT_5(word2)) 1.2674 + width = REG_D[width&7]; 1.2675 + 1.2676 + offset &= 31; 1.2677 + width = ((width-1) & 31) + 1; 1.2678 + 1.2679 + data = ROL_32(data, offset); 1.2680 + FLAG_N = NFLAG_32(data); 1.2681 + data >>= 32 - width; 1.2682 + 1.2683 + FLAG_Z = data; 1.2684 + FLAG_V = VFLAG_CLEAR; 1.2685 + FLAG_C = CFLAG_CLEAR; 1.2686 + 1.2687 + for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1) 1.2688 + offset++; 1.2689 + 1.2690 + REG_D[(word2>>12)&7] = offset; 1.2691 + 1.2692 + return; 1.2693 + } 1.2694 + m68ki_exception_illegal(); 1.2695 +} 1.2696 + 1.2697 + 1.2698 +M68KMAKE_OP(bfffo, 32, ., .) 1.2699 +{ 1.2700 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2701 + { 1.2702 + uint word2 = OPER_I_16(); 1.2703 + sint offset = (word2>>6)&31; 1.2704 + sint local_offset; 1.2705 + uint width = word2; 1.2706 + uint data; 1.2707 + uint bit; 1.2708 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2709 + 1.2710 + 1.2711 + if(BIT_B(word2)) 1.2712 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2713 + if(BIT_5(word2)) 1.2714 + width = REG_D[width&7]; 1.2715 + 1.2716 + /* Offset is signed so we have to use ugly math =( */ 1.2717 + ea += offset / 8; 1.2718 + local_offset = offset % 8; 1.2719 + if(local_offset < 0) 1.2720 + { 1.2721 + local_offset += 8; 1.2722 + ea--; 1.2723 + } 1.2724 + width = ((width-1) & 31) + 1; 1.2725 + 1.2726 + data = m68ki_read_32(ea); 1.2727 + data = MASK_OUT_ABOVE_32(data<<local_offset); 1.2728 + 1.2729 + if((local_offset+width) > 32) 1.2730 + data |= (m68ki_read_8(ea+4) << local_offset) >> 8; 1.2731 + 1.2732 + FLAG_N = NFLAG_32(data); 1.2733 + data >>= (32 - width); 1.2734 + 1.2735 + FLAG_Z = data; 1.2736 + FLAG_V = VFLAG_CLEAR; 1.2737 + FLAG_C = CFLAG_CLEAR; 1.2738 + 1.2739 + for(bit = 1<<(width-1);bit && !(data & bit);bit>>= 1) 1.2740 + offset++; 1.2741 + 1.2742 + REG_D[(word2>>12)&7] = offset; 1.2743 + 1.2744 + return; 1.2745 + } 1.2746 + m68ki_exception_illegal(); 1.2747 +} 1.2748 + 1.2749 + 1.2750 +M68KMAKE_OP(bfins, 32, ., d) 1.2751 +{ 1.2752 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2753 + { 1.2754 + uint word2 = OPER_I_16(); 1.2755 + uint offset = (word2>>6)&31; 1.2756 + uint width = word2; 1.2757 + uint* data = &DY; 1.2758 + uint64 mask; 1.2759 + uint64 insert = REG_D[(word2>>12)&7]; 1.2760 + 1.2761 + 1.2762 + if(BIT_B(word2)) 1.2763 + offset = REG_D[offset&7]; 1.2764 + if(BIT_5(word2)) 1.2765 + width = REG_D[width&7]; 1.2766 + 1.2767 + 1.2768 + offset &= 31; 1.2769 + width = ((width-1) & 31) + 1; 1.2770 + 1.2771 + 1.2772 + mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2773 + mask = ROR_32(mask, offset); 1.2774 + 1.2775 + insert = MASK_OUT_ABOVE_32(insert << (32 - width)); 1.2776 + FLAG_N = NFLAG_32(insert); 1.2777 + FLAG_Z = insert; 1.2778 + insert = ROR_32(insert, offset); 1.2779 + 1.2780 + FLAG_V = VFLAG_CLEAR; 1.2781 + FLAG_C = CFLAG_CLEAR; 1.2782 + 1.2783 + *data &= ~mask; 1.2784 + *data |= insert; 1.2785 + 1.2786 + return; 1.2787 + } 1.2788 + m68ki_exception_illegal(); 1.2789 +} 1.2790 + 1.2791 + 1.2792 +M68KMAKE_OP(bfins, 32, ., .) 1.2793 +{ 1.2794 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2795 + { 1.2796 + uint word2 = OPER_I_16(); 1.2797 + sint offset = (word2>>6)&31; 1.2798 + uint width = word2; 1.2799 + uint insert_base = REG_D[(word2>>12)&7]; 1.2800 + uint insert_long; 1.2801 + uint insert_byte; 1.2802 + uint mask_base; 1.2803 + uint data_long; 1.2804 + uint mask_long; 1.2805 + uint data_byte = 0; 1.2806 + uint mask_byte = 0; 1.2807 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2808 + 1.2809 + 1.2810 + if(BIT_B(word2)) 1.2811 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2812 + if(BIT_5(word2)) 1.2813 + width = REG_D[width&7]; 1.2814 + 1.2815 + /* Offset is signed so we have to use ugly math =( */ 1.2816 + ea += offset / 8; 1.2817 + offset %= 8; 1.2818 + if(offset < 0) 1.2819 + { 1.2820 + offset += 8; 1.2821 + ea--; 1.2822 + } 1.2823 + width = ((width-1) & 31) + 1; 1.2824 + 1.2825 + mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2826 + mask_long = mask_base >> offset; 1.2827 + 1.2828 + insert_base = MASK_OUT_ABOVE_32(insert_base << (32 - width)); 1.2829 + FLAG_N = NFLAG_32(insert_base); 1.2830 + FLAG_Z = insert_base; 1.2831 + insert_long = insert_base >> offset; 1.2832 + 1.2833 + data_long = m68ki_read_32(ea); 1.2834 + FLAG_V = VFLAG_CLEAR; 1.2835 + FLAG_C = CFLAG_CLEAR; 1.2836 + 1.2837 + m68ki_write_32(ea, (data_long & ~mask_long) | insert_long); 1.2838 + 1.2839 + if((width + offset) > 32) 1.2840 + { 1.2841 + mask_byte = MASK_OUT_ABOVE_8(mask_base); 1.2842 + insert_byte = MASK_OUT_ABOVE_8(insert_base); 1.2843 + data_byte = m68ki_read_8(ea+4); 1.2844 + FLAG_Z |= (data_byte & mask_byte); 1.2845 + m68ki_write_8(ea+4, (data_byte & ~mask_byte) | insert_byte); 1.2846 + } 1.2847 + return; 1.2848 + } 1.2849 + m68ki_exception_illegal(); 1.2850 +} 1.2851 + 1.2852 + 1.2853 +M68KMAKE_OP(bfset, 32, ., d) 1.2854 +{ 1.2855 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2856 + { 1.2857 + uint word2 = OPER_I_16(); 1.2858 + uint offset = (word2>>6)&31; 1.2859 + uint width = word2; 1.2860 + uint* data = &DY; 1.2861 + uint64 mask; 1.2862 + 1.2863 + 1.2864 + if(BIT_B(word2)) 1.2865 + offset = REG_D[offset&7]; 1.2866 + if(BIT_5(word2)) 1.2867 + width = REG_D[width&7]; 1.2868 + 1.2869 + 1.2870 + offset &= 31; 1.2871 + width = ((width-1) & 31) + 1; 1.2872 + 1.2873 + 1.2874 + mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2875 + mask = ROR_32(mask, offset); 1.2876 + 1.2877 + FLAG_N = NFLAG_32(*data<<offset); 1.2878 + FLAG_Z = *data & mask; 1.2879 + FLAG_V = VFLAG_CLEAR; 1.2880 + FLAG_C = CFLAG_CLEAR; 1.2881 + 1.2882 + *data |= mask; 1.2883 + 1.2884 + return; 1.2885 + } 1.2886 + m68ki_exception_illegal(); 1.2887 +} 1.2888 + 1.2889 + 1.2890 +M68KMAKE_OP(bfset, 32, ., .) 1.2891 +{ 1.2892 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2893 + { 1.2894 + uint word2 = OPER_I_16(); 1.2895 + sint offset = (word2>>6)&31; 1.2896 + uint width = word2; 1.2897 + uint mask_base; 1.2898 + uint data_long; 1.2899 + uint mask_long; 1.2900 + uint data_byte = 0; 1.2901 + uint mask_byte = 0; 1.2902 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2903 + 1.2904 + 1.2905 + if(BIT_B(word2)) 1.2906 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2907 + if(BIT_5(word2)) 1.2908 + width = REG_D[width&7]; 1.2909 + 1.2910 + /* Offset is signed so we have to use ugly math =( */ 1.2911 + ea += offset / 8; 1.2912 + offset %= 8; 1.2913 + if(offset < 0) 1.2914 + { 1.2915 + offset += 8; 1.2916 + ea--; 1.2917 + } 1.2918 + width = ((width-1) & 31) + 1; 1.2919 + 1.2920 + 1.2921 + mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2922 + mask_long = mask_base >> offset; 1.2923 + 1.2924 + data_long = m68ki_read_32(ea); 1.2925 + FLAG_N = NFLAG_32(data_long << offset); 1.2926 + FLAG_Z = data_long & mask_long; 1.2927 + FLAG_V = VFLAG_CLEAR; 1.2928 + FLAG_C = CFLAG_CLEAR; 1.2929 + 1.2930 + m68ki_write_32(ea, data_long | mask_long); 1.2931 + 1.2932 + if((width + offset) > 32) 1.2933 + { 1.2934 + mask_byte = MASK_OUT_ABOVE_8(mask_base); 1.2935 + data_byte = m68ki_read_8(ea+4); 1.2936 + FLAG_Z |= (data_byte & mask_byte); 1.2937 + m68ki_write_8(ea+4, data_byte | mask_byte); 1.2938 + } 1.2939 + return; 1.2940 + } 1.2941 + m68ki_exception_illegal(); 1.2942 +} 1.2943 + 1.2944 + 1.2945 +M68KMAKE_OP(bftst, 32, ., d) 1.2946 +{ 1.2947 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2948 + { 1.2949 + uint word2 = OPER_I_16(); 1.2950 + uint offset = (word2>>6)&31; 1.2951 + uint width = word2; 1.2952 + uint* data = &DY; 1.2953 + uint64 mask; 1.2954 + 1.2955 + 1.2956 + if(BIT_B(word2)) 1.2957 + offset = REG_D[offset&7]; 1.2958 + if(BIT_5(word2)) 1.2959 + width = REG_D[width&7]; 1.2960 + 1.2961 + 1.2962 + offset &= 31; 1.2963 + width = ((width-1) & 31) + 1; 1.2964 + 1.2965 + 1.2966 + mask = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.2967 + mask = ROR_32(mask, offset); 1.2968 + 1.2969 + FLAG_N = NFLAG_32(*data<<offset); 1.2970 + FLAG_Z = *data & mask; 1.2971 + FLAG_V = VFLAG_CLEAR; 1.2972 + FLAG_C = CFLAG_CLEAR; 1.2973 + 1.2974 + return; 1.2975 + } 1.2976 + m68ki_exception_illegal(); 1.2977 +} 1.2978 + 1.2979 + 1.2980 +M68KMAKE_OP(bftst, 32, ., .) 1.2981 +{ 1.2982 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.2983 + { 1.2984 + uint word2 = OPER_I_16(); 1.2985 + sint offset = (word2>>6)&31; 1.2986 + uint width = word2; 1.2987 + uint mask_base; 1.2988 + uint data_long; 1.2989 + uint mask_long; 1.2990 + uint data_byte = 0; 1.2991 + uint mask_byte = 0; 1.2992 + uint ea = M68KMAKE_GET_EA_AY_8; 1.2993 + 1.2994 + if(BIT_B(word2)) 1.2995 + offset = MAKE_INT_32(REG_D[offset&7]); 1.2996 + if(BIT_5(word2)) 1.2997 + width = REG_D[width&7]; 1.2998 + 1.2999 + /* Offset is signed so we have to use ugly math =( */ 1.3000 + ea += offset / 8; 1.3001 + offset %= 8; 1.3002 + if(offset < 0) 1.3003 + { 1.3004 + offset += 8; 1.3005 + ea--; 1.3006 + } 1.3007 + width = ((width-1) & 31) + 1; 1.3008 + 1.3009 + 1.3010 + mask_base = MASK_OUT_ABOVE_32(0xffffffff << (32 - width)); 1.3011 + mask_long = mask_base >> offset; 1.3012 + 1.3013 + data_long = m68ki_read_32(ea); 1.3014 + FLAG_N = ((data_long & (0x80000000 >> offset))<<offset)>>24; 1.3015 + FLAG_Z = data_long & mask_long; 1.3016 + FLAG_V = VFLAG_CLEAR; 1.3017 + FLAG_C = CFLAG_CLEAR; 1.3018 + 1.3019 + if((width + offset) > 32) 1.3020 + { 1.3021 + mask_byte = MASK_OUT_ABOVE_8(mask_base); 1.3022 + data_byte = m68ki_read_8(ea+4); 1.3023 + FLAG_Z |= (data_byte & mask_byte); 1.3024 + } 1.3025 + return; 1.3026 + } 1.3027 + m68ki_exception_illegal(); 1.3028 +} 1.3029 + 1.3030 + 1.3031 +M68KMAKE_OP(bkpt, 0, ., .) 1.3032 +{ 1.3033 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.3034 + { 1.3035 + m68ki_bkpt_ack(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE) ? REG_IR & 7 : 0); /* auto-disable (see m68kcpu.h) */ 1.3036 + } 1.3037 + m68ki_exception_illegal(); 1.3038 +} 1.3039 + 1.3040 + 1.3041 +M68KMAKE_OP(bra, 8, ., .) 1.3042 +{ 1.3043 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3044 + m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR)); 1.3045 + if(REG_PC == REG_PPC) 1.3046 + USE_ALL_CYCLES(); 1.3047 +} 1.3048 + 1.3049 + 1.3050 +M68KMAKE_OP(bra, 16, ., .) 1.3051 +{ 1.3052 + uint offset = OPER_I_16(); 1.3053 + REG_PC -= 2; 1.3054 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3055 + m68ki_branch_16(offset); 1.3056 + if(REG_PC == REG_PPC) 1.3057 + USE_ALL_CYCLES(); 1.3058 +} 1.3059 + 1.3060 + 1.3061 +M68KMAKE_OP(bra, 32, ., .) 1.3062 +{ 1.3063 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3064 + { 1.3065 + uint offset = OPER_I_32(); 1.3066 + REG_PC -= 4; 1.3067 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3068 + m68ki_branch_32(offset); 1.3069 + if(REG_PC == REG_PPC) 1.3070 + USE_ALL_CYCLES(); 1.3071 + return; 1.3072 + } 1.3073 + m68ki_exception_illegal(); 1.3074 +} 1.3075 + 1.3076 + 1.3077 +M68KMAKE_OP(bset, 32, r, d) 1.3078 +{ 1.3079 + uint* r_dst = &DY; 1.3080 + uint mask = 1 << (DX & 0x1f); 1.3081 + 1.3082 + FLAG_Z = *r_dst & mask; 1.3083 + *r_dst |= mask; 1.3084 +} 1.3085 + 1.3086 + 1.3087 +M68KMAKE_OP(bset, 8, r, .) 1.3088 +{ 1.3089 + uint ea = M68KMAKE_GET_EA_AY_8; 1.3090 + uint src = m68ki_read_8(ea); 1.3091 + uint mask = 1 << (DX & 7); 1.3092 + 1.3093 + FLAG_Z = src & mask; 1.3094 + m68ki_write_8(ea, src | mask); 1.3095 +} 1.3096 + 1.3097 + 1.3098 +M68KMAKE_OP(bset, 32, s, d) 1.3099 +{ 1.3100 + uint* r_dst = &DY; 1.3101 + uint mask = 1 << (OPER_I_8() & 0x1f); 1.3102 + 1.3103 + FLAG_Z = *r_dst & mask; 1.3104 + *r_dst |= mask; 1.3105 +} 1.3106 + 1.3107 + 1.3108 +M68KMAKE_OP(bset, 8, s, .) 1.3109 +{ 1.3110 + uint mask = 1 << (OPER_I_8() & 7); 1.3111 + uint ea = M68KMAKE_GET_EA_AY_8; 1.3112 + uint src = m68ki_read_8(ea); 1.3113 + 1.3114 + FLAG_Z = src & mask; 1.3115 + m68ki_write_8(ea, src | mask); 1.3116 +} 1.3117 + 1.3118 + 1.3119 +M68KMAKE_OP(bsr, 8, ., .) 1.3120 +{ 1.3121 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3122 + m68ki_push_32(REG_PC); 1.3123 + m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR)); 1.3124 +} 1.3125 + 1.3126 + 1.3127 +M68KMAKE_OP(bsr, 16, ., .) 1.3128 +{ 1.3129 + uint offset = OPER_I_16(); 1.3130 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3131 + m68ki_push_32(REG_PC); 1.3132 + REG_PC -= 2; 1.3133 + m68ki_branch_16(offset); 1.3134 +} 1.3135 + 1.3136 + 1.3137 +M68KMAKE_OP(bsr, 32, ., .) 1.3138 +{ 1.3139 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3140 + { 1.3141 + uint offset = OPER_I_32(); 1.3142 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3143 + m68ki_push_32(REG_PC); 1.3144 + REG_PC -= 4; 1.3145 + m68ki_branch_32(offset); 1.3146 + return; 1.3147 + } 1.3148 + m68ki_exception_illegal(); 1.3149 +} 1.3150 + 1.3151 + 1.3152 +M68KMAKE_OP(btst, 32, r, d) 1.3153 +{ 1.3154 + FLAG_Z = DY & (1 << (DX & 0x1f)); 1.3155 +} 1.3156 + 1.3157 + 1.3158 +M68KMAKE_OP(btst, 8, r, .) 1.3159 +{ 1.3160 + FLAG_Z = M68KMAKE_GET_OPER_AY_8 & (1 << (DX & 7)); 1.3161 +} 1.3162 + 1.3163 + 1.3164 +M68KMAKE_OP(btst, 32, s, d) 1.3165 +{ 1.3166 + FLAG_Z = DY & (1 << (OPER_I_8() & 0x1f)); 1.3167 +} 1.3168 + 1.3169 + 1.3170 +M68KMAKE_OP(btst, 8, s, .) 1.3171 +{ 1.3172 + uint bit = OPER_I_8() & 7; 1.3173 + 1.3174 + FLAG_Z = M68KMAKE_GET_OPER_AY_8 & (1 << bit); 1.3175 +} 1.3176 + 1.3177 + 1.3178 +M68KMAKE_OP(callm, 32, ., .) 1.3179 +{ 1.3180 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.3181 + { 1.3182 + uint ea = M68KMAKE_GET_EA_AY_32; 1.3183 + 1.3184 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3185 + REG_PC += 2; 1.3186 +(void)ea; /* just to avoid an 'unused variable' warning */ 1.3187 + M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n", 1.3188 + m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR, 1.3189 + m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2)))); 1.3190 + return; 1.3191 + } 1.3192 + m68ki_exception_illegal(); 1.3193 +} 1.3194 + 1.3195 + 1.3196 +M68KMAKE_OP(cas, 8, ., .) 1.3197 +{ 1.3198 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3199 + { 1.3200 + uint word2 = OPER_I_16(); 1.3201 + uint ea = M68KMAKE_GET_EA_AY_8; 1.3202 + uint dest = m68ki_read_8(ea); 1.3203 + uint* compare = ®_D[word2 & 7]; 1.3204 + uint res = dest - MASK_OUT_ABOVE_8(*compare); 1.3205 + 1.3206 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3207 + FLAG_N = NFLAG_8(res); 1.3208 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3209 + FLAG_V = VFLAG_SUB_8(*compare, dest, res); 1.3210 + FLAG_C = CFLAG_8(res); 1.3211 + 1.3212 + if(COND_NE()) 1.3213 + *compare = MASK_OUT_BELOW_8(*compare) | dest; 1.3214 + else 1.3215 + { 1.3216 + USE_CYCLES(3); 1.3217 + m68ki_write_8(ea, MASK_OUT_ABOVE_8(REG_D[(word2 >> 6) & 7])); 1.3218 + } 1.3219 + return; 1.3220 + } 1.3221 + m68ki_exception_illegal(); 1.3222 +} 1.3223 + 1.3224 + 1.3225 +M68KMAKE_OP(cas, 16, ., .) 1.3226 +{ 1.3227 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3228 + { 1.3229 + uint word2 = OPER_I_16(); 1.3230 + uint ea = M68KMAKE_GET_EA_AY_16; 1.3231 + uint dest = m68ki_read_16(ea); 1.3232 + uint* compare = ®_D[word2 & 7]; 1.3233 + uint res = dest - MASK_OUT_ABOVE_16(*compare); 1.3234 + 1.3235 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3236 + FLAG_N = NFLAG_16(res); 1.3237 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3238 + FLAG_V = VFLAG_SUB_16(*compare, dest, res); 1.3239 + FLAG_C = CFLAG_16(res); 1.3240 + 1.3241 + if(COND_NE()) 1.3242 + *compare = MASK_OUT_BELOW_16(*compare) | dest; 1.3243 + else 1.3244 + { 1.3245 + USE_CYCLES(3); 1.3246 + m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_D[(word2 >> 6) & 7])); 1.3247 + } 1.3248 + return; 1.3249 + } 1.3250 + m68ki_exception_illegal(); 1.3251 +} 1.3252 + 1.3253 + 1.3254 +M68KMAKE_OP(cas, 32, ., .) 1.3255 +{ 1.3256 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3257 + { 1.3258 + uint word2 = OPER_I_16(); 1.3259 + uint ea = M68KMAKE_GET_EA_AY_32; 1.3260 + uint dest = m68ki_read_32(ea); 1.3261 + uint* compare = ®_D[word2 & 7]; 1.3262 + uint res = dest - *compare; 1.3263 + 1.3264 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3265 + FLAG_N = NFLAG_32(res); 1.3266 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3267 + FLAG_V = VFLAG_SUB_32(*compare, dest, res); 1.3268 + FLAG_C = CFLAG_SUB_32(*compare, dest, res); 1.3269 + 1.3270 + if(COND_NE()) 1.3271 + *compare = dest; 1.3272 + else 1.3273 + { 1.3274 + USE_CYCLES(3); 1.3275 + m68ki_write_32(ea, REG_D[(word2 >> 6) & 7]); 1.3276 + } 1.3277 + return; 1.3278 + } 1.3279 + m68ki_exception_illegal(); 1.3280 +} 1.3281 + 1.3282 + 1.3283 +M68KMAKE_OP(cas2, 16, ., .) 1.3284 +{ 1.3285 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3286 + { 1.3287 + uint word2 = OPER_I_32(); 1.3288 + uint* compare1 = ®_D[(word2 >> 16) & 7]; 1.3289 + uint ea1 = REG_DA[(word2 >> 28) & 15]; 1.3290 + uint dest1 = m68ki_read_16(ea1); 1.3291 + uint res1 = dest1 - MASK_OUT_ABOVE_16(*compare1); 1.3292 + uint* compare2 = ®_D[word2 & 7]; 1.3293 + uint ea2 = REG_DA[(word2 >> 12) & 15]; 1.3294 + uint dest2 = m68ki_read_16(ea2); 1.3295 + uint res2; 1.3296 + 1.3297 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3298 + FLAG_N = NFLAG_16(res1); 1.3299 + FLAG_Z = MASK_OUT_ABOVE_16(res1); 1.3300 + FLAG_V = VFLAG_SUB_16(*compare1, dest1, res1); 1.3301 + FLAG_C = CFLAG_16(res1); 1.3302 + 1.3303 + if(COND_EQ()) 1.3304 + { 1.3305 + res2 = dest2 - MASK_OUT_ABOVE_16(*compare2); 1.3306 + 1.3307 + FLAG_N = NFLAG_16(res2); 1.3308 + FLAG_Z = MASK_OUT_ABOVE_16(res2); 1.3309 + FLAG_V = VFLAG_SUB_16(*compare2, dest2, res2); 1.3310 + FLAG_C = CFLAG_16(res2); 1.3311 + 1.3312 + if(COND_EQ()) 1.3313 + { 1.3314 + USE_CYCLES(3); 1.3315 + m68ki_write_16(ea1, REG_D[(word2 >> 22) & 7]); 1.3316 + m68ki_write_16(ea2, REG_D[(word2 >> 6) & 7]); 1.3317 + return; 1.3318 + } 1.3319 + } 1.3320 + *compare1 = BIT_1F(word2) ? MAKE_INT_16(dest1) : MASK_OUT_BELOW_16(*compare1) | dest1; 1.3321 + *compare2 = BIT_F(word2) ? MAKE_INT_16(dest2) : MASK_OUT_BELOW_16(*compare2) | dest2; 1.3322 + return; 1.3323 + } 1.3324 + m68ki_exception_illegal(); 1.3325 +} 1.3326 + 1.3327 + 1.3328 +M68KMAKE_OP(cas2, 32, ., .) 1.3329 +{ 1.3330 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3331 + { 1.3332 + uint word2 = OPER_I_32(); 1.3333 + uint* compare1 = ®_D[(word2 >> 16) & 7]; 1.3334 + uint ea1 = REG_DA[(word2 >> 28) & 15]; 1.3335 + uint dest1 = m68ki_read_32(ea1); 1.3336 + uint res1 = dest1 - *compare1; 1.3337 + uint* compare2 = ®_D[word2 & 7]; 1.3338 + uint ea2 = REG_DA[(word2 >> 12) & 15]; 1.3339 + uint dest2 = m68ki_read_32(ea2); 1.3340 + uint res2; 1.3341 + 1.3342 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.3343 + FLAG_N = NFLAG_32(res1); 1.3344 + FLAG_Z = MASK_OUT_ABOVE_32(res1); 1.3345 + FLAG_V = VFLAG_SUB_32(*compare1, dest1, res1); 1.3346 + FLAG_C = CFLAG_SUB_32(*compare1, dest1, res1); 1.3347 + 1.3348 + if(COND_EQ()) 1.3349 + { 1.3350 + res2 = dest2 - *compare2; 1.3351 + 1.3352 + FLAG_N = NFLAG_32(res2); 1.3353 + FLAG_Z = MASK_OUT_ABOVE_32(res2); 1.3354 + FLAG_V = VFLAG_SUB_32(*compare2, dest2, res2); 1.3355 + FLAG_C = CFLAG_SUB_32(*compare2, dest2, res2); 1.3356 + 1.3357 + if(COND_EQ()) 1.3358 + { 1.3359 + USE_CYCLES(3); 1.3360 + m68ki_write_32(ea1, REG_D[(word2 >> 22) & 7]); 1.3361 + m68ki_write_32(ea2, REG_D[(word2 >> 6) & 7]); 1.3362 + return; 1.3363 + } 1.3364 + } 1.3365 + *compare1 = dest1; 1.3366 + *compare2 = dest2; 1.3367 + return; 1.3368 + } 1.3369 + m68ki_exception_illegal(); 1.3370 +} 1.3371 + 1.3372 + 1.3373 +M68KMAKE_OP(chk, 16, ., d) 1.3374 +{ 1.3375 + sint src = MAKE_INT_16(DX); 1.3376 + sint bound = MAKE_INT_16(DY); 1.3377 + 1.3378 + if(src >= 0 && src <= bound) 1.3379 + { 1.3380 + return; 1.3381 + } 1.3382 + FLAG_N = (src < 0)<<7; 1.3383 + m68ki_exception_trap(EXCEPTION_CHK); 1.3384 +} 1.3385 + 1.3386 + 1.3387 +M68KMAKE_OP(chk, 16, ., .) 1.3388 +{ 1.3389 + sint src = MAKE_INT_16(DX); 1.3390 + sint bound = MAKE_INT_16(M68KMAKE_GET_OPER_AY_16); 1.3391 + 1.3392 + if(src >= 0 && src <= bound) 1.3393 + { 1.3394 + return; 1.3395 + } 1.3396 + FLAG_N = (src < 0)<<7; 1.3397 + m68ki_exception_trap(EXCEPTION_CHK); 1.3398 +} 1.3399 + 1.3400 + 1.3401 +M68KMAKE_OP(chk, 32, ., d) 1.3402 +{ 1.3403 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3404 + { 1.3405 + sint src = MAKE_INT_32(DX); 1.3406 + sint bound = MAKE_INT_32(DY); 1.3407 + 1.3408 + if(src >= 0 && src <= bound) 1.3409 + { 1.3410 + return; 1.3411 + } 1.3412 + FLAG_N = (src < 0)<<7; 1.3413 + m68ki_exception_trap(EXCEPTION_CHK); 1.3414 + return; 1.3415 + } 1.3416 + m68ki_exception_illegal(); 1.3417 +} 1.3418 + 1.3419 + 1.3420 +M68KMAKE_OP(chk, 32, ., .) 1.3421 +{ 1.3422 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3423 + { 1.3424 + sint src = MAKE_INT_32(DX); 1.3425 + sint bound = MAKE_INT_32(M68KMAKE_GET_OPER_AY_32); 1.3426 + 1.3427 + if(src >= 0 && src <= bound) 1.3428 + { 1.3429 + return; 1.3430 + } 1.3431 + FLAG_N = (src < 0)<<7; 1.3432 + m68ki_exception_trap(EXCEPTION_CHK); 1.3433 + return; 1.3434 + } 1.3435 + m68ki_exception_illegal(); 1.3436 +} 1.3437 + 1.3438 + 1.3439 +M68KMAKE_OP(chk2cmp2, 8, ., .) 1.3440 +{ 1.3441 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3442 + { 1.3443 + uint word2 = OPER_I_16(); 1.3444 + uint compare = REG_DA[(word2 >> 12) & 15]; 1.3445 + uint ea = M68KMAKE_GET_EA_AY_8; 1.3446 + uint lower_bound = m68ki_read_8(ea); 1.3447 + uint upper_bound = m68ki_read_8(ea + 1); 1.3448 + 1.3449 + if(!BIT_F(word2)) 1.3450 + compare = MAKE_INT_8(compare); 1.3451 + 1.3452 + FLAG_C = compare - lower_bound; 1.3453 + FLAG_Z = MASK_OUT_ABOVE_8(FLAG_C); 1.3454 + if(COND_CS()) 1.3455 + { 1.3456 + if(BIT_B(word2)) 1.3457 + m68ki_exception_trap(EXCEPTION_CHK); 1.3458 + return; 1.3459 + } 1.3460 + 1.3461 + FLAG_C = upper_bound - compare; 1.3462 + FLAG_Z = MASK_OUT_ABOVE_8(FLAG_C); 1.3463 + if(COND_CS() && BIT_B(word2)) 1.3464 + m68ki_exception_trap(EXCEPTION_CHK); 1.3465 + 1.3466 + return; 1.3467 + } 1.3468 + m68ki_exception_illegal(); 1.3469 +} 1.3470 + 1.3471 + 1.3472 +M68KMAKE_OP(chk2cmp2, 16, ., .) 1.3473 +{ 1.3474 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3475 + { 1.3476 + uint word2 = OPER_I_16(); 1.3477 + uint compare = REG_DA[(word2 >> 12) & 15]; 1.3478 + uint ea = M68KMAKE_GET_EA_AY_16; 1.3479 + uint lower_bound = m68ki_read_16(ea); 1.3480 + uint upper_bound = m68ki_read_16(ea + 1); 1.3481 + 1.3482 + if(!BIT_F(word2)) 1.3483 + compare = MAKE_INT_16(compare); 1.3484 + 1.3485 + FLAG_C = compare - lower_bound; 1.3486 + FLAG_Z = MASK_OUT_ABOVE_16(FLAG_C); 1.3487 + FLAG_C = CFLAG_16(FLAG_C); 1.3488 + if(COND_CS()) 1.3489 + { 1.3490 + if(BIT_B(word2)) 1.3491 + m68ki_exception_trap(EXCEPTION_CHK); 1.3492 + return; 1.3493 + } 1.3494 + 1.3495 + FLAG_C = upper_bound - compare; 1.3496 + FLAG_Z = MASK_OUT_ABOVE_16(FLAG_C); 1.3497 + FLAG_C = CFLAG_16(FLAG_C); 1.3498 + if(COND_CS() && BIT_B(word2)) 1.3499 + m68ki_exception_trap(EXCEPTION_CHK); 1.3500 + 1.3501 + return; 1.3502 + } 1.3503 + m68ki_exception_illegal(); 1.3504 +} 1.3505 + 1.3506 + 1.3507 +M68KMAKE_OP(chk2cmp2, 32, ., .) 1.3508 +{ 1.3509 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3510 + { 1.3511 + uint word2 = OPER_I_16(); 1.3512 + uint compare = REG_DA[(word2 >> 12) & 15]; 1.3513 + uint ea = M68KMAKE_GET_EA_AY_32; 1.3514 + uint lower_bound = m68ki_read_32(ea); 1.3515 + uint upper_bound = m68ki_read_32(ea + 1); 1.3516 + 1.3517 + FLAG_C = compare - lower_bound; 1.3518 + FLAG_Z = MASK_OUT_ABOVE_32(FLAG_C); 1.3519 + FLAG_C = CFLAG_SUB_32(lower_bound, compare, FLAG_C); 1.3520 + if(COND_CS()) 1.3521 + { 1.3522 + if(BIT_B(word2)) 1.3523 + m68ki_exception_trap(EXCEPTION_CHK); 1.3524 + return; 1.3525 + } 1.3526 + 1.3527 + FLAG_C = upper_bound - compare; 1.3528 + FLAG_Z = MASK_OUT_ABOVE_32(FLAG_C); 1.3529 + FLAG_C = CFLAG_SUB_32(compare, upper_bound, FLAG_C); 1.3530 + if(COND_CS() && BIT_B(word2)) 1.3531 + m68ki_exception_trap(EXCEPTION_CHK); 1.3532 + 1.3533 + return; 1.3534 + } 1.3535 + m68ki_exception_illegal(); 1.3536 +} 1.3537 + 1.3538 + 1.3539 +M68KMAKE_OP(clr, 8, ., d) 1.3540 +{ 1.3541 + DY &= 0xffffff00; 1.3542 + 1.3543 + FLAG_N = NFLAG_CLEAR; 1.3544 + FLAG_V = VFLAG_CLEAR; 1.3545 + FLAG_C = CFLAG_CLEAR; 1.3546 + FLAG_Z = ZFLAG_SET; 1.3547 +} 1.3548 + 1.3549 + 1.3550 +M68KMAKE_OP(clr, 8, ., .) 1.3551 +{ 1.3552 + m68ki_write_8(M68KMAKE_GET_EA_AY_8, 0); 1.3553 + 1.3554 + FLAG_N = NFLAG_CLEAR; 1.3555 + FLAG_V = VFLAG_CLEAR; 1.3556 + FLAG_C = CFLAG_CLEAR; 1.3557 + FLAG_Z = ZFLAG_SET; 1.3558 +} 1.3559 + 1.3560 + 1.3561 +M68KMAKE_OP(clr, 16, ., d) 1.3562 +{ 1.3563 + DY &= 0xffff0000; 1.3564 + 1.3565 + FLAG_N = NFLAG_CLEAR; 1.3566 + FLAG_V = VFLAG_CLEAR; 1.3567 + FLAG_C = CFLAG_CLEAR; 1.3568 + FLAG_Z = ZFLAG_SET; 1.3569 +} 1.3570 + 1.3571 + 1.3572 +M68KMAKE_OP(clr, 16, ., .) 1.3573 +{ 1.3574 + m68ki_write_16(M68KMAKE_GET_EA_AY_16, 0); 1.3575 + 1.3576 + FLAG_N = NFLAG_CLEAR; 1.3577 + FLAG_V = VFLAG_CLEAR; 1.3578 + FLAG_C = CFLAG_CLEAR; 1.3579 + FLAG_Z = ZFLAG_SET; 1.3580 +} 1.3581 + 1.3582 + 1.3583 +M68KMAKE_OP(clr, 32, ., d) 1.3584 +{ 1.3585 + DY = 0; 1.3586 + 1.3587 + FLAG_N = NFLAG_CLEAR; 1.3588 + FLAG_V = VFLAG_CLEAR; 1.3589 + FLAG_C = CFLAG_CLEAR; 1.3590 + FLAG_Z = ZFLAG_SET; 1.3591 +} 1.3592 + 1.3593 + 1.3594 +M68KMAKE_OP(clr, 32, ., .) 1.3595 +{ 1.3596 + m68ki_write_32(M68KMAKE_GET_EA_AY_32, 0); 1.3597 + 1.3598 + FLAG_N = NFLAG_CLEAR; 1.3599 + FLAG_V = VFLAG_CLEAR; 1.3600 + FLAG_C = CFLAG_CLEAR; 1.3601 + FLAG_Z = ZFLAG_SET; 1.3602 +} 1.3603 + 1.3604 + 1.3605 +M68KMAKE_OP(cmp, 8, ., d) 1.3606 +{ 1.3607 + uint src = MASK_OUT_ABOVE_8(DY); 1.3608 + uint dst = MASK_OUT_ABOVE_8(DX); 1.3609 + uint res = dst - src; 1.3610 + 1.3611 + FLAG_N = NFLAG_8(res); 1.3612 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3613 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3614 + FLAG_C = CFLAG_8(res); 1.3615 +} 1.3616 + 1.3617 + 1.3618 +M68KMAKE_OP(cmp, 8, ., .) 1.3619 +{ 1.3620 + uint src = M68KMAKE_GET_OPER_AY_8; 1.3621 + uint dst = MASK_OUT_ABOVE_8(DX); 1.3622 + uint res = dst - src; 1.3623 + 1.3624 + FLAG_N = NFLAG_8(res); 1.3625 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3626 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3627 + FLAG_C = CFLAG_8(res); 1.3628 +} 1.3629 + 1.3630 + 1.3631 +M68KMAKE_OP(cmp, 16, ., d) 1.3632 +{ 1.3633 + uint src = MASK_OUT_ABOVE_16(DY); 1.3634 + uint dst = MASK_OUT_ABOVE_16(DX); 1.3635 + uint res = dst - src; 1.3636 + 1.3637 + FLAG_N = NFLAG_16(res); 1.3638 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3639 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.3640 + FLAG_C = CFLAG_16(res); 1.3641 +} 1.3642 + 1.3643 + 1.3644 +M68KMAKE_OP(cmp, 16, ., a) 1.3645 +{ 1.3646 + uint src = MASK_OUT_ABOVE_16(AY); 1.3647 + uint dst = MASK_OUT_ABOVE_16(DX); 1.3648 + uint res = dst - src; 1.3649 + 1.3650 + FLAG_N = NFLAG_16(res); 1.3651 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3652 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.3653 + FLAG_C = CFLAG_16(res); 1.3654 +} 1.3655 + 1.3656 + 1.3657 +M68KMAKE_OP(cmp, 16, ., .) 1.3658 +{ 1.3659 + uint src = M68KMAKE_GET_OPER_AY_16; 1.3660 + uint dst = MASK_OUT_ABOVE_16(DX); 1.3661 + uint res = dst - src; 1.3662 + 1.3663 + FLAG_N = NFLAG_16(res); 1.3664 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3665 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.3666 + FLAG_C = CFLAG_16(res); 1.3667 +} 1.3668 + 1.3669 + 1.3670 +M68KMAKE_OP(cmp, 32, ., d) 1.3671 +{ 1.3672 + uint src = DY; 1.3673 + uint dst = DX; 1.3674 + uint res = dst - src; 1.3675 + 1.3676 + FLAG_N = NFLAG_32(res); 1.3677 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3678 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3679 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3680 +} 1.3681 + 1.3682 + 1.3683 +M68KMAKE_OP(cmp, 32, ., a) 1.3684 +{ 1.3685 + uint src = AY; 1.3686 + uint dst = DX; 1.3687 + uint res = dst - src; 1.3688 + 1.3689 + FLAG_N = NFLAG_32(res); 1.3690 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3691 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3692 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3693 +} 1.3694 + 1.3695 + 1.3696 +M68KMAKE_OP(cmp, 32, ., .) 1.3697 +{ 1.3698 + uint src = M68KMAKE_GET_OPER_AY_32; 1.3699 + uint dst = DX; 1.3700 + uint res = dst - src; 1.3701 + 1.3702 + FLAG_N = NFLAG_32(res); 1.3703 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3704 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3705 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3706 +} 1.3707 + 1.3708 + 1.3709 +M68KMAKE_OP(cmpa, 16, ., d) 1.3710 +{ 1.3711 + uint src = MAKE_INT_16(DY); 1.3712 + uint dst = AX; 1.3713 + uint res = dst - src; 1.3714 + 1.3715 + FLAG_N = NFLAG_32(res); 1.3716 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3717 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3718 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3719 +} 1.3720 + 1.3721 + 1.3722 +M68KMAKE_OP(cmpa, 16, ., a) 1.3723 +{ 1.3724 + uint src = MAKE_INT_16(AY); 1.3725 + uint dst = AX; 1.3726 + uint res = dst - src; 1.3727 + 1.3728 + FLAG_N = NFLAG_32(res); 1.3729 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3730 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3731 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3732 +} 1.3733 + 1.3734 + 1.3735 +M68KMAKE_OP(cmpa, 16, ., .) 1.3736 +{ 1.3737 + uint src = MAKE_INT_16(M68KMAKE_GET_OPER_AY_16); 1.3738 + uint dst = AX; 1.3739 + uint res = dst - src; 1.3740 + 1.3741 + FLAG_N = NFLAG_32(res); 1.3742 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3743 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3744 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3745 +} 1.3746 + 1.3747 + 1.3748 +M68KMAKE_OP(cmpa, 32, ., d) 1.3749 +{ 1.3750 + uint src = DY; 1.3751 + uint dst = AX; 1.3752 + uint res = dst - src; 1.3753 + 1.3754 + FLAG_N = NFLAG_32(res); 1.3755 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3756 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3757 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3758 +} 1.3759 + 1.3760 + 1.3761 +M68KMAKE_OP(cmpa, 32, ., a) 1.3762 +{ 1.3763 + uint src = AY; 1.3764 + uint dst = AX; 1.3765 + uint res = dst - src; 1.3766 + 1.3767 + FLAG_N = NFLAG_32(res); 1.3768 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3769 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3770 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3771 +} 1.3772 + 1.3773 + 1.3774 +M68KMAKE_OP(cmpa, 32, ., .) 1.3775 +{ 1.3776 + uint src = M68KMAKE_GET_OPER_AY_32; 1.3777 + uint dst = AX; 1.3778 + uint res = dst - src; 1.3779 + 1.3780 + FLAG_N = NFLAG_32(res); 1.3781 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3782 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3783 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3784 +} 1.3785 + 1.3786 + 1.3787 +M68KMAKE_OP(cmpi, 8, ., d) 1.3788 +{ 1.3789 + uint src = OPER_I_8(); 1.3790 + uint dst = MASK_OUT_ABOVE_8(DY); 1.3791 + uint res = dst - src; 1.3792 + 1.3793 + FLAG_N = NFLAG_8(res); 1.3794 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3795 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3796 + FLAG_C = CFLAG_8(res); 1.3797 +} 1.3798 + 1.3799 + 1.3800 +M68KMAKE_OP(cmpi, 8, ., .) 1.3801 +{ 1.3802 + uint src = OPER_I_8(); 1.3803 + uint dst = M68KMAKE_GET_OPER_AY_8; 1.3804 + uint res = dst - src; 1.3805 + 1.3806 + FLAG_N = NFLAG_8(res); 1.3807 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3808 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3809 + FLAG_C = CFLAG_8(res); 1.3810 +} 1.3811 + 1.3812 + 1.3813 +M68KMAKE_OP(cmpi, 8, ., pcdi) 1.3814 +{ 1.3815 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3816 + { 1.3817 + uint src = OPER_I_8(); 1.3818 + uint dst = OPER_PCDI_8(); 1.3819 + uint res = dst - src; 1.3820 + 1.3821 + FLAG_N = NFLAG_8(res); 1.3822 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3823 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3824 + FLAG_C = CFLAG_8(res); 1.3825 + return; 1.3826 + } 1.3827 + m68ki_exception_illegal(); 1.3828 +} 1.3829 + 1.3830 + 1.3831 +M68KMAKE_OP(cmpi, 8, ., pcix) 1.3832 +{ 1.3833 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3834 + { 1.3835 + uint src = OPER_I_8(); 1.3836 + uint dst = OPER_PCIX_8(); 1.3837 + uint res = dst - src; 1.3838 + 1.3839 + FLAG_N = NFLAG_8(res); 1.3840 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3841 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3842 + FLAG_C = CFLAG_8(res); 1.3843 + return; 1.3844 + } 1.3845 + m68ki_exception_illegal(); 1.3846 +} 1.3847 + 1.3848 + 1.3849 +M68KMAKE_OP(cmpi, 16, ., d) 1.3850 +{ 1.3851 + uint src = OPER_I_16(); 1.3852 + uint dst = MASK_OUT_ABOVE_16(DY); 1.3853 + uint res = dst - src; 1.3854 + 1.3855 + FLAG_N = NFLAG_16(res); 1.3856 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3857 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.3858 + FLAG_C = CFLAG_16(res); 1.3859 +} 1.3860 + 1.3861 + 1.3862 +M68KMAKE_OP(cmpi, 16, ., .) 1.3863 +{ 1.3864 + uint src = OPER_I_16(); 1.3865 + uint dst = M68KMAKE_GET_OPER_AY_16; 1.3866 + uint res = dst - src; 1.3867 + 1.3868 + FLAG_N = NFLAG_16(res); 1.3869 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3870 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.3871 + FLAG_C = CFLAG_16(res); 1.3872 +} 1.3873 + 1.3874 + 1.3875 +M68KMAKE_OP(cmpi, 16, ., pcdi) 1.3876 +{ 1.3877 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3878 + { 1.3879 + uint src = OPER_I_16(); 1.3880 + uint dst = OPER_PCDI_16(); 1.3881 + uint res = dst - src; 1.3882 + 1.3883 + FLAG_N = NFLAG_16(res); 1.3884 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3885 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.3886 + FLAG_C = CFLAG_16(res); 1.3887 + return; 1.3888 + } 1.3889 + m68ki_exception_illegal(); 1.3890 +} 1.3891 + 1.3892 + 1.3893 +M68KMAKE_OP(cmpi, 16, ., pcix) 1.3894 +{ 1.3895 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3896 + { 1.3897 + uint src = OPER_I_16(); 1.3898 + uint dst = OPER_PCIX_16(); 1.3899 + uint res = dst - src; 1.3900 + 1.3901 + FLAG_N = NFLAG_16(res); 1.3902 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.3903 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.3904 + FLAG_C = CFLAG_16(res); 1.3905 + return; 1.3906 + } 1.3907 + m68ki_exception_illegal(); 1.3908 +} 1.3909 + 1.3910 + 1.3911 +M68KMAKE_OP(cmpi, 32, ., d) 1.3912 +{ 1.3913 + uint src = OPER_I_32(); 1.3914 + uint dst = DY; 1.3915 + uint res = dst - src; 1.3916 + 1.3917 + FLAG_N = NFLAG_32(res); 1.3918 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3919 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3920 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3921 +} 1.3922 + 1.3923 + 1.3924 +M68KMAKE_OP(cmpi, 32, ., .) 1.3925 +{ 1.3926 + uint src = OPER_I_32(); 1.3927 + uint dst = M68KMAKE_GET_OPER_AY_32; 1.3928 + uint res = dst - src; 1.3929 + 1.3930 + FLAG_N = NFLAG_32(res); 1.3931 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3932 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3933 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3934 +} 1.3935 + 1.3936 + 1.3937 +M68KMAKE_OP(cmpi, 32, ., pcdi) 1.3938 +{ 1.3939 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3940 + { 1.3941 + uint src = OPER_I_32(); 1.3942 + uint dst = OPER_PCDI_32(); 1.3943 + uint res = dst - src; 1.3944 + 1.3945 + FLAG_N = NFLAG_32(res); 1.3946 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3947 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3948 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3949 + return; 1.3950 + } 1.3951 + m68ki_exception_illegal(); 1.3952 +} 1.3953 + 1.3954 + 1.3955 +M68KMAKE_OP(cmpi, 32, ., pcix) 1.3956 +{ 1.3957 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.3958 + { 1.3959 + uint src = OPER_I_32(); 1.3960 + uint dst = OPER_PCIX_32(); 1.3961 + uint res = dst - src; 1.3962 + 1.3963 + FLAG_N = NFLAG_32(res); 1.3964 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.3965 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.3966 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.3967 + return; 1.3968 + } 1.3969 + m68ki_exception_illegal(); 1.3970 +} 1.3971 + 1.3972 + 1.3973 +M68KMAKE_OP(cmpm, 8, ., ax7) 1.3974 +{ 1.3975 + uint src = OPER_AY_PI_8(); 1.3976 + uint dst = OPER_A7_PI_8(); 1.3977 + uint res = dst - src; 1.3978 + 1.3979 + FLAG_N = NFLAG_8(res); 1.3980 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3981 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3982 + FLAG_C = CFLAG_8(res); 1.3983 +} 1.3984 + 1.3985 + 1.3986 +M68KMAKE_OP(cmpm, 8, ., ay7) 1.3987 +{ 1.3988 + uint src = OPER_A7_PI_8(); 1.3989 + uint dst = OPER_AX_PI_8(); 1.3990 + uint res = dst - src; 1.3991 + 1.3992 + FLAG_N = NFLAG_8(res); 1.3993 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.3994 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.3995 + FLAG_C = CFLAG_8(res); 1.3996 +} 1.3997 + 1.3998 + 1.3999 +M68KMAKE_OP(cmpm, 8, ., axy7) 1.4000 +{ 1.4001 + uint src = OPER_A7_PI_8(); 1.4002 + uint dst = OPER_A7_PI_8(); 1.4003 + uint res = dst - src; 1.4004 + 1.4005 + FLAG_N = NFLAG_8(res); 1.4006 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.4007 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.4008 + FLAG_C = CFLAG_8(res); 1.4009 +} 1.4010 + 1.4011 + 1.4012 +M68KMAKE_OP(cmpm, 8, ., .) 1.4013 +{ 1.4014 + uint src = OPER_AY_PI_8(); 1.4015 + uint dst = OPER_AX_PI_8(); 1.4016 + uint res = dst - src; 1.4017 + 1.4018 + FLAG_N = NFLAG_8(res); 1.4019 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.4020 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.4021 + FLAG_C = CFLAG_8(res); 1.4022 +} 1.4023 + 1.4024 + 1.4025 +M68KMAKE_OP(cmpm, 16, ., .) 1.4026 +{ 1.4027 + uint src = OPER_AY_PI_16(); 1.4028 + uint dst = OPER_AX_PI_16(); 1.4029 + uint res = dst - src; 1.4030 + 1.4031 + FLAG_N = NFLAG_16(res); 1.4032 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.4033 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.4034 + FLAG_C = CFLAG_16(res); 1.4035 +} 1.4036 + 1.4037 + 1.4038 +M68KMAKE_OP(cmpm, 32, ., .) 1.4039 +{ 1.4040 + uint src = OPER_AY_PI_32(); 1.4041 + uint dst = OPER_AX_PI_32(); 1.4042 + uint res = dst - src; 1.4043 + 1.4044 + FLAG_N = NFLAG_32(res); 1.4045 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.4046 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.4047 + FLAG_C = CFLAG_SUB_32(src, dst, res); 1.4048 +} 1.4049 + 1.4050 + 1.4051 +M68KMAKE_OP(cpbcc, 32, ., .) 1.4052 +{ 1.4053 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4054 + { 1.4055 + M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n", 1.4056 + m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR, 1.4057 + m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2)))); 1.4058 + return; 1.4059 + } 1.4060 + m68ki_exception_1111(); 1.4061 +} 1.4062 + 1.4063 + 1.4064 +M68KMAKE_OP(cpdbcc, 32, ., .) 1.4065 +{ 1.4066 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4067 + { 1.4068 + M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n", 1.4069 + m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR, 1.4070 + m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2)))); 1.4071 + return; 1.4072 + } 1.4073 + m68ki_exception_1111(); 1.4074 +} 1.4075 + 1.4076 + 1.4077 +M68KMAKE_OP(cpgen, 32, ., .) 1.4078 +{ 1.4079 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4080 + { 1.4081 + M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n", 1.4082 + m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR, 1.4083 + m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2)))); 1.4084 + return; 1.4085 + } 1.4086 + m68ki_exception_1111(); 1.4087 +} 1.4088 + 1.4089 + 1.4090 +M68KMAKE_OP(cpscc, 32, ., .) 1.4091 +{ 1.4092 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4093 + { 1.4094 + M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n", 1.4095 + m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR, 1.4096 + m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2)))); 1.4097 + return; 1.4098 + } 1.4099 + m68ki_exception_1111(); 1.4100 +} 1.4101 + 1.4102 + 1.4103 +M68KMAKE_OP(cptrapcc, 32, ., .) 1.4104 +{ 1.4105 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4106 + { 1.4107 + M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n", 1.4108 + m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR, 1.4109 + m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2)))); 1.4110 + return; 1.4111 + } 1.4112 + m68ki_exception_1111(); 1.4113 +} 1.4114 + 1.4115 + 1.4116 +M68KMAKE_OP(dbt, 16, ., .) 1.4117 +{ 1.4118 + REG_PC += 2; 1.4119 +} 1.4120 + 1.4121 + 1.4122 +M68KMAKE_OP(dbf, 16, ., .) 1.4123 +{ 1.4124 + uint* r_dst = &DY; 1.4125 + uint res = MASK_OUT_ABOVE_16(*r_dst - 1); 1.4126 + 1.4127 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.4128 + if(res != 0xffff) 1.4129 + { 1.4130 + uint offset = OPER_I_16(); 1.4131 + REG_PC -= 2; 1.4132 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.4133 + m68ki_branch_16(offset); 1.4134 + return; 1.4135 + } 1.4136 + REG_PC += 2; 1.4137 +} 1.4138 + 1.4139 + 1.4140 +M68KMAKE_OP(dbcc, 16, ., .) 1.4141 +{ 1.4142 + if(M68KMAKE_NOT_CC) 1.4143 + { 1.4144 + uint* r_dst = &DY; 1.4145 + uint res = MASK_OUT_ABOVE_16(*r_dst - 1); 1.4146 + 1.4147 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.4148 + if(res != 0xffff) 1.4149 + { 1.4150 + uint offset = OPER_I_16(); 1.4151 + REG_PC -= 2; 1.4152 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.4153 + m68ki_branch_16(offset); 1.4154 + USE_CYCLES(CYC_DBCC_F_NOEXP); 1.4155 + return; 1.4156 + } 1.4157 + REG_PC += 2; 1.4158 + USE_CYCLES(CYC_DBCC_F_EXP); 1.4159 + return; 1.4160 + } 1.4161 + REG_PC += 2; 1.4162 +} 1.4163 + 1.4164 + 1.4165 +M68KMAKE_OP(divs, 16, ., d) 1.4166 +{ 1.4167 + uint* r_dst = &DX; 1.4168 + sint src = MAKE_INT_16(DY); 1.4169 + sint quotient; 1.4170 + sint remainder; 1.4171 + 1.4172 + if(src != 0) 1.4173 + { 1.4174 + if((uint32)*r_dst == 0x80000000 && src == -1) 1.4175 + { 1.4176 + FLAG_Z = 0; 1.4177 + FLAG_N = NFLAG_CLEAR; 1.4178 + FLAG_V = VFLAG_CLEAR; 1.4179 + FLAG_C = CFLAG_CLEAR; 1.4180 + *r_dst = 0; 1.4181 + return; 1.4182 + } 1.4183 + 1.4184 + quotient = MAKE_INT_32(*r_dst) / src; 1.4185 + remainder = MAKE_INT_32(*r_dst) % src; 1.4186 + 1.4187 + if(quotient == MAKE_INT_16(quotient)) 1.4188 + { 1.4189 + FLAG_Z = quotient; 1.4190 + FLAG_N = NFLAG_16(quotient); 1.4191 + FLAG_V = VFLAG_CLEAR; 1.4192 + FLAG_C = CFLAG_CLEAR; 1.4193 + *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16)); 1.4194 + return; 1.4195 + } 1.4196 + FLAG_V = VFLAG_SET; 1.4197 + return; 1.4198 + } 1.4199 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4200 +} 1.4201 + 1.4202 + 1.4203 +M68KMAKE_OP(divs, 16, ., .) 1.4204 +{ 1.4205 + uint* r_dst = &DX; 1.4206 + sint src = MAKE_INT_16(M68KMAKE_GET_OPER_AY_16); 1.4207 + sint quotient; 1.4208 + sint remainder; 1.4209 + 1.4210 + if(src != 0) 1.4211 + { 1.4212 + if((uint32)*r_dst == 0x80000000 && src == -1) 1.4213 + { 1.4214 + FLAG_Z = 0; 1.4215 + FLAG_N = NFLAG_CLEAR; 1.4216 + FLAG_V = VFLAG_CLEAR; 1.4217 + FLAG_C = CFLAG_CLEAR; 1.4218 + *r_dst = 0; 1.4219 + return; 1.4220 + } 1.4221 + 1.4222 + quotient = MAKE_INT_32(*r_dst) / src; 1.4223 + remainder = MAKE_INT_32(*r_dst) % src; 1.4224 + 1.4225 + if(quotient == MAKE_INT_16(quotient)) 1.4226 + { 1.4227 + FLAG_Z = quotient; 1.4228 + FLAG_N = NFLAG_16(quotient); 1.4229 + FLAG_V = VFLAG_CLEAR; 1.4230 + FLAG_C = CFLAG_CLEAR; 1.4231 + *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16)); 1.4232 + return; 1.4233 + } 1.4234 + FLAG_V = VFLAG_SET; 1.4235 + return; 1.4236 + } 1.4237 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4238 +} 1.4239 + 1.4240 + 1.4241 +M68KMAKE_OP(divu, 16, ., d) 1.4242 +{ 1.4243 + uint* r_dst = &DX; 1.4244 + uint src = MASK_OUT_ABOVE_16(DY); 1.4245 + 1.4246 + if(src != 0) 1.4247 + { 1.4248 + uint quotient = *r_dst / src; 1.4249 + uint remainder = *r_dst % src; 1.4250 + 1.4251 + if(quotient < 0x10000) 1.4252 + { 1.4253 + FLAG_Z = quotient; 1.4254 + FLAG_N = NFLAG_16(quotient); 1.4255 + FLAG_V = VFLAG_CLEAR; 1.4256 + FLAG_C = CFLAG_CLEAR; 1.4257 + *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16)); 1.4258 + return; 1.4259 + } 1.4260 + FLAG_V = VFLAG_SET; 1.4261 + return; 1.4262 + } 1.4263 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4264 +} 1.4265 + 1.4266 + 1.4267 +M68KMAKE_OP(divu, 16, ., .) 1.4268 +{ 1.4269 + uint* r_dst = &DX; 1.4270 + uint src = M68KMAKE_GET_OPER_AY_16; 1.4271 + 1.4272 + if(src != 0) 1.4273 + { 1.4274 + uint quotient = *r_dst / src; 1.4275 + uint remainder = *r_dst % src; 1.4276 + 1.4277 + if(quotient < 0x10000) 1.4278 + { 1.4279 + FLAG_Z = quotient; 1.4280 + FLAG_N = NFLAG_16(quotient); 1.4281 + FLAG_V = VFLAG_CLEAR; 1.4282 + FLAG_C = CFLAG_CLEAR; 1.4283 + *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16)); 1.4284 + return; 1.4285 + } 1.4286 + FLAG_V = VFLAG_SET; 1.4287 + return; 1.4288 + } 1.4289 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4290 +} 1.4291 + 1.4292 + 1.4293 +M68KMAKE_OP(divl, 32, ., d) 1.4294 +{ 1.4295 +#if M68K_USE_64_BIT 1.4296 + 1.4297 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4298 + { 1.4299 + uint word2 = OPER_I_16(); 1.4300 + uint64 divisor = DY; 1.4301 + uint64 dividend = 0; 1.4302 + uint64 quotient = 0; 1.4303 + uint64 remainder = 0; 1.4304 + 1.4305 + if(divisor != 0) 1.4306 + { 1.4307 + if(BIT_A(word2)) /* 64 bit */ 1.4308 + { 1.4309 + dividend = REG_D[word2 & 7]; 1.4310 + dividend <<= 32; 1.4311 + dividend |= REG_D[(word2 >> 12) & 7]; 1.4312 + 1.4313 + if(BIT_B(word2)) /* signed */ 1.4314 + { 1.4315 + quotient = (uint64)((sint64)dividend / (sint64)((sint32)divisor)); 1.4316 + remainder = (uint64)((sint64)dividend % (sint64)((sint32)divisor)); 1.4317 + if((sint64)quotient != (sint64)((sint32)quotient)) 1.4318 + { 1.4319 + FLAG_V = VFLAG_SET; 1.4320 + return; 1.4321 + } 1.4322 + } 1.4323 + else /* unsigned */ 1.4324 + { 1.4325 + quotient = dividend / divisor; 1.4326 + if(quotient > 0xffffffff) 1.4327 + { 1.4328 + FLAG_V = VFLAG_SET; 1.4329 + return; 1.4330 + } 1.4331 + remainder = dividend % divisor; 1.4332 + } 1.4333 + } 1.4334 + else /* 32 bit */ 1.4335 + { 1.4336 + dividend = REG_D[(word2 >> 12) & 7]; 1.4337 + if(BIT_B(word2)) /* signed */ 1.4338 + { 1.4339 + quotient = (uint64)((sint64)((sint32)dividend) / (sint64)((sint32)divisor)); 1.4340 + remainder = (uint64)((sint64)((sint32)dividend) % (sint64)((sint32)divisor)); 1.4341 + } 1.4342 + else /* unsigned */ 1.4343 + { 1.4344 + quotient = dividend / divisor; 1.4345 + remainder = dividend % divisor; 1.4346 + } 1.4347 + } 1.4348 + 1.4349 + REG_D[word2 & 7] = remainder; 1.4350 + REG_D[(word2 >> 12) & 7] = quotient; 1.4351 + 1.4352 + FLAG_N = NFLAG_32(quotient); 1.4353 + FLAG_Z = quotient; 1.4354 + FLAG_V = VFLAG_CLEAR; 1.4355 + FLAG_C = CFLAG_CLEAR; 1.4356 + return; 1.4357 + } 1.4358 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4359 + return; 1.4360 + } 1.4361 + m68ki_exception_illegal(); 1.4362 + 1.4363 +#else 1.4364 + 1.4365 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4366 + { 1.4367 + uint word2 = OPER_I_16(); 1.4368 + uint divisor = DY; 1.4369 + uint dividend_hi = REG_D[word2 & 7]; 1.4370 + uint dividend_lo = REG_D[(word2 >> 12) & 7]; 1.4371 + uint quotient = 0; 1.4372 + uint remainder = 0; 1.4373 + uint dividend_neg = 0; 1.4374 + uint divisor_neg = 0; 1.4375 + sint i; 1.4376 + uint overflow; 1.4377 + 1.4378 + if(divisor != 0) 1.4379 + { 1.4380 + /* quad / long : long quotient, long remainder */ 1.4381 + if(BIT_A(word2)) 1.4382 + { 1.4383 + if(BIT_B(word2)) /* signed */ 1.4384 + { 1.4385 + /* special case in signed divide */ 1.4386 + if(dividend_hi == 0 && dividend_lo == 0x80000000 && divisor == 0xffffffff) 1.4387 + { 1.4388 + REG_D[word2 & 7] = 0; 1.4389 + REG_D[(word2 >> 12) & 7] = 0x80000000; 1.4390 + 1.4391 + FLAG_N = NFLAG_SET; 1.4392 + FLAG_Z = ZFLAG_CLEAR; 1.4393 + FLAG_V = VFLAG_CLEAR; 1.4394 + FLAG_C = CFLAG_CLEAR; 1.4395 + return; 1.4396 + } 1.4397 + if(GET_MSB_32(dividend_hi)) 1.4398 + { 1.4399 + dividend_neg = 1; 1.4400 + dividend_hi = (uint)MASK_OUT_ABOVE_32((-(sint)dividend_hi) - (dividend_lo != 0)); 1.4401 + dividend_lo = (uint)MASK_OUT_ABOVE_32(-(sint)dividend_lo); 1.4402 + } 1.4403 + if(GET_MSB_32(divisor)) 1.4404 + { 1.4405 + divisor_neg = 1; 1.4406 + divisor = (uint)MASK_OUT_ABOVE_32(-(sint)divisor); 1.4407 + 1.4408 + } 1.4409 + } 1.4410 + 1.4411 + /* if the upper long is greater than the divisor, we're overflowing. */ 1.4412 + if(dividend_hi >= divisor) 1.4413 + { 1.4414 + FLAG_V = VFLAG_SET; 1.4415 + return; 1.4416 + } 1.4417 + 1.4418 + for(i = 31; i >= 0; i--) 1.4419 + { 1.4420 + quotient <<= 1; 1.4421 + remainder = (remainder << 1) + ((dividend_hi >> i) & 1); 1.4422 + if(remainder >= divisor) 1.4423 + { 1.4424 + remainder -= divisor; 1.4425 + quotient++; 1.4426 + } 1.4427 + } 1.4428 + for(i = 31; i >= 0; i--) 1.4429 + { 1.4430 + quotient <<= 1; 1.4431 + overflow = GET_MSB_32(remainder); 1.4432 + remainder = (remainder << 1) + ((dividend_lo >> i) & 1); 1.4433 + if(remainder >= divisor || overflow) 1.4434 + { 1.4435 + remainder -= divisor; 1.4436 + quotient++; 1.4437 + } 1.4438 + } 1.4439 + 1.4440 + if(BIT_B(word2)) /* signed */ 1.4441 + { 1.4442 + if(quotient > 0x7fffffff) 1.4443 + { 1.4444 + FLAG_V = VFLAG_SET; 1.4445 + return; 1.4446 + } 1.4447 + if(dividend_neg) 1.4448 + { 1.4449 + remainder = (uint)MASK_OUT_ABOVE_32(-(sint)remainder); 1.4450 + quotient = (uint)MASK_OUT_ABOVE_32(-(sint)quotient); 1.4451 + } 1.4452 + if(divisor_neg) 1.4453 + quotient = (uint)MASK_OUT_ABOVE_32(-(sint)quotient); 1.4454 + } 1.4455 + 1.4456 + REG_D[word2 & 7] = remainder; 1.4457 + REG_D[(word2 >> 12) & 7] = quotient; 1.4458 + 1.4459 + FLAG_N = NFLAG_32(quotient); 1.4460 + FLAG_Z = quotient; 1.4461 + FLAG_V = VFLAG_CLEAR; 1.4462 + FLAG_C = CFLAG_CLEAR; 1.4463 + return; 1.4464 + } 1.4465 + 1.4466 + /* long / long: long quotient, maybe long remainder */ 1.4467 + if(BIT_B(word2)) /* signed */ 1.4468 + { 1.4469 + /* Special case in divide */ 1.4470 + if(dividend_lo == 0x80000000 && divisor == 0xffffffff) 1.4471 + { 1.4472 + FLAG_N = NFLAG_SET; 1.4473 + FLAG_Z = ZFLAG_CLEAR; 1.4474 + FLAG_V = VFLAG_CLEAR; 1.4475 + FLAG_C = CFLAG_CLEAR; 1.4476 + REG_D[(word2 >> 12) & 7] = 0x80000000; 1.4477 + REG_D[word2 & 7] = 0; 1.4478 + return; 1.4479 + } 1.4480 + REG_D[word2 & 7] = MAKE_INT_32(dividend_lo) % MAKE_INT_32(divisor); 1.4481 + quotient = REG_D[(word2 >> 12) & 7] = MAKE_INT_32(dividend_lo) / MAKE_INT_32(divisor); 1.4482 + } 1.4483 + else 1.4484 + { 1.4485 + REG_D[word2 & 7] = MASK_OUT_ABOVE_32(dividend_lo) % MASK_OUT_ABOVE_32(divisor); 1.4486 + quotient = REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(dividend_lo) / MASK_OUT_ABOVE_32(divisor); 1.4487 + } 1.4488 + 1.4489 + FLAG_N = NFLAG_32(quotient); 1.4490 + FLAG_Z = quotient; 1.4491 + FLAG_V = VFLAG_CLEAR; 1.4492 + FLAG_C = CFLAG_CLEAR; 1.4493 + return; 1.4494 + } 1.4495 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4496 + return; 1.4497 + } 1.4498 + m68ki_exception_illegal(); 1.4499 + 1.4500 +#endif 1.4501 +} 1.4502 + 1.4503 + 1.4504 +M68KMAKE_OP(divl, 32, ., .) 1.4505 +{ 1.4506 +#if M68K_USE_64_BIT 1.4507 + 1.4508 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4509 + { 1.4510 + uint word2 = OPER_I_16(); 1.4511 + uint64 divisor = M68KMAKE_GET_OPER_AY_32; 1.4512 + uint64 dividend = 0; 1.4513 + uint64 quotient = 0; 1.4514 + uint64 remainder = 0; 1.4515 + 1.4516 + if(divisor != 0) 1.4517 + { 1.4518 + if(BIT_A(word2)) /* 64 bit */ 1.4519 + { 1.4520 + dividend = REG_D[word2 & 7]; 1.4521 + dividend <<= 32; 1.4522 + dividend |= REG_D[(word2 >> 12) & 7]; 1.4523 + 1.4524 + if(BIT_B(word2)) /* signed */ 1.4525 + { 1.4526 + quotient = (uint64)((sint64)dividend / (sint64)((sint32)divisor)); 1.4527 + remainder = (uint64)((sint64)dividend % (sint64)((sint32)divisor)); 1.4528 + if((sint64)quotient != (sint64)((sint32)quotient)) 1.4529 + { 1.4530 + FLAG_V = VFLAG_SET; 1.4531 + return; 1.4532 + } 1.4533 + } 1.4534 + else /* unsigned */ 1.4535 + { 1.4536 + quotient = dividend / divisor; 1.4537 + if(quotient > 0xffffffff) 1.4538 + { 1.4539 + FLAG_V = VFLAG_SET; 1.4540 + return; 1.4541 + } 1.4542 + remainder = dividend % divisor; 1.4543 + } 1.4544 + } 1.4545 + else /* 32 bit */ 1.4546 + { 1.4547 + dividend = REG_D[(word2 >> 12) & 7]; 1.4548 + if(BIT_B(word2)) /* signed */ 1.4549 + { 1.4550 + quotient = (uint64)((sint64)((sint32)dividend) / (sint64)((sint32)divisor)); 1.4551 + remainder = (uint64)((sint64)((sint32)dividend) % (sint64)((sint32)divisor)); 1.4552 + } 1.4553 + else /* unsigned */ 1.4554 + { 1.4555 + quotient = dividend / divisor; 1.4556 + remainder = dividend % divisor; 1.4557 + } 1.4558 + } 1.4559 + 1.4560 + REG_D[word2 & 7] = remainder; 1.4561 + REG_D[(word2 >> 12) & 7] = quotient; 1.4562 + 1.4563 + FLAG_N = NFLAG_32(quotient); 1.4564 + FLAG_Z = quotient; 1.4565 + FLAG_V = VFLAG_CLEAR; 1.4566 + FLAG_C = CFLAG_CLEAR; 1.4567 + return; 1.4568 + } 1.4569 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4570 + return; 1.4571 + } 1.4572 + m68ki_exception_illegal(); 1.4573 + 1.4574 +#else 1.4575 + 1.4576 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4577 + { 1.4578 + uint word2 = OPER_I_16(); 1.4579 + uint divisor = M68KMAKE_GET_OPER_AY_32; 1.4580 + uint dividend_hi = REG_D[word2 & 7]; 1.4581 + uint dividend_lo = REG_D[(word2 >> 12) & 7]; 1.4582 + uint quotient = 0; 1.4583 + uint remainder = 0; 1.4584 + uint dividend_neg = 0; 1.4585 + uint divisor_neg = 0; 1.4586 + sint i; 1.4587 + uint overflow; 1.4588 + 1.4589 + if(divisor != 0) 1.4590 + { 1.4591 + /* quad / long : long quotient, long remainder */ 1.4592 + if(BIT_A(word2)) 1.4593 + { 1.4594 + if(BIT_B(word2)) /* signed */ 1.4595 + { 1.4596 + /* special case in signed divide */ 1.4597 + if(dividend_hi == 0 && dividend_lo == 0x80000000 && divisor == 0xffffffff) 1.4598 + { 1.4599 + REG_D[word2 & 7] = 0; 1.4600 + REG_D[(word2 >> 12) & 7] = 0x80000000; 1.4601 + 1.4602 + FLAG_N = NFLAG_SET; 1.4603 + FLAG_Z = ZFLAG_CLEAR; 1.4604 + FLAG_V = VFLAG_CLEAR; 1.4605 + FLAG_C = CFLAG_CLEAR; 1.4606 + return; 1.4607 + } 1.4608 + if(GET_MSB_32(dividend_hi)) 1.4609 + { 1.4610 + dividend_neg = 1; 1.4611 + dividend_hi = (uint)MASK_OUT_ABOVE_32((-(sint)dividend_hi) - (dividend_lo != 0)); 1.4612 + dividend_lo = (uint)MASK_OUT_ABOVE_32(-(sint)dividend_lo); 1.4613 + } 1.4614 + if(GET_MSB_32(divisor)) 1.4615 + { 1.4616 + divisor_neg = 1; 1.4617 + divisor = (uint)MASK_OUT_ABOVE_32(-(sint)divisor); 1.4618 + 1.4619 + } 1.4620 + } 1.4621 + 1.4622 + /* if the upper long is greater than the divisor, we're overflowing. */ 1.4623 + if(dividend_hi >= divisor) 1.4624 + { 1.4625 + FLAG_V = VFLAG_SET; 1.4626 + return; 1.4627 + } 1.4628 + 1.4629 + for(i = 31; i >= 0; i--) 1.4630 + { 1.4631 + quotient <<= 1; 1.4632 + remainder = (remainder << 1) + ((dividend_hi >> i) & 1); 1.4633 + if(remainder >= divisor) 1.4634 + { 1.4635 + remainder -= divisor; 1.4636 + quotient++; 1.4637 + } 1.4638 + } 1.4639 + for(i = 31; i >= 0; i--) 1.4640 + { 1.4641 + quotient <<= 1; 1.4642 + overflow = GET_MSB_32(remainder); 1.4643 + remainder = (remainder << 1) + ((dividend_lo >> i) & 1); 1.4644 + if(remainder >= divisor || overflow) 1.4645 + { 1.4646 + remainder -= divisor; 1.4647 + quotient++; 1.4648 + } 1.4649 + } 1.4650 + 1.4651 + if(BIT_B(word2)) /* signed */ 1.4652 + { 1.4653 + if(quotient > 0x7fffffff) 1.4654 + { 1.4655 + FLAG_V = VFLAG_SET; 1.4656 + return; 1.4657 + } 1.4658 + if(dividend_neg) 1.4659 + { 1.4660 + remainder = (uint)MASK_OUT_ABOVE_32(-(sint)remainder); 1.4661 + quotient = (uint)MASK_OUT_ABOVE_32(-(sint)quotient); 1.4662 + } 1.4663 + if(divisor_neg) 1.4664 + quotient = (uint)MASK_OUT_ABOVE_32(-(sint)quotient); 1.4665 + } 1.4666 + 1.4667 + REG_D[word2 & 7] = remainder; 1.4668 + REG_D[(word2 >> 12) & 7] = quotient; 1.4669 + 1.4670 + FLAG_N = NFLAG_32(quotient); 1.4671 + FLAG_Z = quotient; 1.4672 + FLAG_V = VFLAG_CLEAR; 1.4673 + FLAG_C = CFLAG_CLEAR; 1.4674 + return; 1.4675 + } 1.4676 + 1.4677 + /* long / long: long quotient, maybe long remainder */ 1.4678 + if(BIT_B(word2)) /* signed */ 1.4679 + { 1.4680 + /* Special case in divide */ 1.4681 + if(dividend_lo == 0x80000000 && divisor == 0xffffffff) 1.4682 + { 1.4683 + FLAG_N = NFLAG_SET; 1.4684 + FLAG_Z = ZFLAG_CLEAR; 1.4685 + FLAG_V = VFLAG_CLEAR; 1.4686 + FLAG_C = CFLAG_CLEAR; 1.4687 + REG_D[(word2 >> 12) & 7] = 0x80000000; 1.4688 + REG_D[word2 & 7] = 0; 1.4689 + return; 1.4690 + } 1.4691 + REG_D[word2 & 7] = MAKE_INT_32(dividend_lo) % MAKE_INT_32(divisor); 1.4692 + quotient = REG_D[(word2 >> 12) & 7] = MAKE_INT_32(dividend_lo) / MAKE_INT_32(divisor); 1.4693 + } 1.4694 + else 1.4695 + { 1.4696 + REG_D[word2 & 7] = MASK_OUT_ABOVE_32(dividend_lo) % MASK_OUT_ABOVE_32(divisor); 1.4697 + quotient = REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(dividend_lo) / MASK_OUT_ABOVE_32(divisor); 1.4698 + } 1.4699 + 1.4700 + FLAG_N = NFLAG_32(quotient); 1.4701 + FLAG_Z = quotient; 1.4702 + FLAG_V = VFLAG_CLEAR; 1.4703 + FLAG_C = CFLAG_CLEAR; 1.4704 + return; 1.4705 + } 1.4706 + m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE); 1.4707 + return; 1.4708 + } 1.4709 + m68ki_exception_illegal(); 1.4710 + 1.4711 +#endif 1.4712 +} 1.4713 + 1.4714 + 1.4715 +M68KMAKE_OP(eor, 8, ., d) 1.4716 +{ 1.4717 + uint res = MASK_OUT_ABOVE_8(DY ^= MASK_OUT_ABOVE_8(DX)); 1.4718 + 1.4719 + FLAG_N = NFLAG_8(res); 1.4720 + FLAG_Z = res; 1.4721 + FLAG_C = CFLAG_CLEAR; 1.4722 + FLAG_V = VFLAG_CLEAR; 1.4723 +} 1.4724 + 1.4725 + 1.4726 +M68KMAKE_OP(eor, 8, ., .) 1.4727 +{ 1.4728 + uint ea = M68KMAKE_GET_EA_AY_8; 1.4729 + uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea)); 1.4730 + 1.4731 + m68ki_write_8(ea, res); 1.4732 + 1.4733 + FLAG_N = NFLAG_8(res); 1.4734 + FLAG_Z = res; 1.4735 + FLAG_C = CFLAG_CLEAR; 1.4736 + FLAG_V = VFLAG_CLEAR; 1.4737 +} 1.4738 + 1.4739 + 1.4740 +M68KMAKE_OP(eor, 16, ., d) 1.4741 +{ 1.4742 + uint res = MASK_OUT_ABOVE_16(DY ^= MASK_OUT_ABOVE_16(DX)); 1.4743 + 1.4744 + FLAG_N = NFLAG_16(res); 1.4745 + FLAG_Z = res; 1.4746 + FLAG_C = CFLAG_CLEAR; 1.4747 + FLAG_V = VFLAG_CLEAR; 1.4748 +} 1.4749 + 1.4750 + 1.4751 +M68KMAKE_OP(eor, 16, ., .) 1.4752 +{ 1.4753 + uint ea = M68KMAKE_GET_EA_AY_16; 1.4754 + uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea)); 1.4755 + 1.4756 + m68ki_write_16(ea, res); 1.4757 + 1.4758 + FLAG_N = NFLAG_16(res); 1.4759 + FLAG_Z = res; 1.4760 + FLAG_C = CFLAG_CLEAR; 1.4761 + FLAG_V = VFLAG_CLEAR; 1.4762 +} 1.4763 + 1.4764 + 1.4765 +M68KMAKE_OP(eor, 32, ., d) 1.4766 +{ 1.4767 + uint res = DY ^= DX; 1.4768 + 1.4769 + FLAG_N = NFLAG_32(res); 1.4770 + FLAG_Z = res; 1.4771 + FLAG_C = CFLAG_CLEAR; 1.4772 + FLAG_V = VFLAG_CLEAR; 1.4773 +} 1.4774 + 1.4775 + 1.4776 +M68KMAKE_OP(eor, 32, ., .) 1.4777 +{ 1.4778 + uint ea = M68KMAKE_GET_EA_AY_32; 1.4779 + uint res = DX ^ m68ki_read_32(ea); 1.4780 + 1.4781 + m68ki_write_32(ea, res); 1.4782 + 1.4783 + FLAG_N = NFLAG_32(res); 1.4784 + FLAG_Z = res; 1.4785 + FLAG_C = CFLAG_CLEAR; 1.4786 + FLAG_V = VFLAG_CLEAR; 1.4787 +} 1.4788 + 1.4789 + 1.4790 +M68KMAKE_OP(eori, 8, ., d) 1.4791 +{ 1.4792 + uint res = MASK_OUT_ABOVE_8(DY ^= OPER_I_8()); 1.4793 + 1.4794 + FLAG_N = NFLAG_8(res); 1.4795 + FLAG_Z = res; 1.4796 + FLAG_C = CFLAG_CLEAR; 1.4797 + FLAG_V = VFLAG_CLEAR; 1.4798 +} 1.4799 + 1.4800 + 1.4801 +M68KMAKE_OP(eori, 8, ., .) 1.4802 +{ 1.4803 + uint src = OPER_I_8(); 1.4804 + uint ea = M68KMAKE_GET_EA_AY_8; 1.4805 + uint res = src ^ m68ki_read_8(ea); 1.4806 + 1.4807 + m68ki_write_8(ea, res); 1.4808 + 1.4809 + FLAG_N = NFLAG_8(res); 1.4810 + FLAG_Z = res; 1.4811 + FLAG_C = CFLAG_CLEAR; 1.4812 + FLAG_V = VFLAG_CLEAR; 1.4813 +} 1.4814 + 1.4815 + 1.4816 +M68KMAKE_OP(eori, 16, ., d) 1.4817 +{ 1.4818 + uint res = MASK_OUT_ABOVE_16(DY ^= OPER_I_16()); 1.4819 + 1.4820 + FLAG_N = NFLAG_16(res); 1.4821 + FLAG_Z = res; 1.4822 + FLAG_C = CFLAG_CLEAR; 1.4823 + FLAG_V = VFLAG_CLEAR; 1.4824 +} 1.4825 + 1.4826 + 1.4827 +M68KMAKE_OP(eori, 16, ., .) 1.4828 +{ 1.4829 + uint src = OPER_I_16(); 1.4830 + uint ea = M68KMAKE_GET_EA_AY_16; 1.4831 + uint res = src ^ m68ki_read_16(ea); 1.4832 + 1.4833 + m68ki_write_16(ea, res); 1.4834 + 1.4835 + FLAG_N = NFLAG_16(res); 1.4836 + FLAG_Z = res; 1.4837 + FLAG_C = CFLAG_CLEAR; 1.4838 + FLAG_V = VFLAG_CLEAR; 1.4839 +} 1.4840 + 1.4841 + 1.4842 +M68KMAKE_OP(eori, 32, ., d) 1.4843 +{ 1.4844 + uint res = DY ^= OPER_I_32(); 1.4845 + 1.4846 + FLAG_N = NFLAG_32(res); 1.4847 + FLAG_Z = res; 1.4848 + FLAG_C = CFLAG_CLEAR; 1.4849 + FLAG_V = VFLAG_CLEAR; 1.4850 +} 1.4851 + 1.4852 + 1.4853 +M68KMAKE_OP(eori, 32, ., .) 1.4854 +{ 1.4855 + uint src = OPER_I_32(); 1.4856 + uint ea = M68KMAKE_GET_EA_AY_32; 1.4857 + uint res = src ^ m68ki_read_32(ea); 1.4858 + 1.4859 + m68ki_write_32(ea, res); 1.4860 + 1.4861 + FLAG_N = NFLAG_32(res); 1.4862 + FLAG_Z = res; 1.4863 + FLAG_C = CFLAG_CLEAR; 1.4864 + FLAG_V = VFLAG_CLEAR; 1.4865 +} 1.4866 + 1.4867 + 1.4868 +M68KMAKE_OP(eori, 16, toc, .) 1.4869 +{ 1.4870 + m68ki_set_ccr(m68ki_get_ccr() ^ OPER_I_16()); 1.4871 +} 1.4872 + 1.4873 + 1.4874 +M68KMAKE_OP(eori, 16, tos, .) 1.4875 +{ 1.4876 + if(FLAG_S) 1.4877 + { 1.4878 + uint src = OPER_I_16(); 1.4879 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.4880 + m68ki_set_sr(m68ki_get_sr() ^ src); 1.4881 + return; 1.4882 + } 1.4883 + m68ki_exception_privilege_violation(); 1.4884 +} 1.4885 + 1.4886 + 1.4887 +M68KMAKE_OP(exg, 32, dd, .) 1.4888 +{ 1.4889 + uint* reg_a = &DX; 1.4890 + uint* reg_b = &DY; 1.4891 + uint tmp = *reg_a; 1.4892 + *reg_a = *reg_b; 1.4893 + *reg_b = tmp; 1.4894 +} 1.4895 + 1.4896 + 1.4897 +M68KMAKE_OP(exg, 32, aa, .) 1.4898 +{ 1.4899 + uint* reg_a = &AX; 1.4900 + uint* reg_b = &AY; 1.4901 + uint tmp = *reg_a; 1.4902 + *reg_a = *reg_b; 1.4903 + *reg_b = tmp; 1.4904 +} 1.4905 + 1.4906 + 1.4907 +M68KMAKE_OP(exg, 32, da, .) 1.4908 +{ 1.4909 + uint* reg_a = &DX; 1.4910 + uint* reg_b = &AY; 1.4911 + uint tmp = *reg_a; 1.4912 + *reg_a = *reg_b; 1.4913 + *reg_b = tmp; 1.4914 +} 1.4915 + 1.4916 + 1.4917 +M68KMAKE_OP(ext, 16, ., .) 1.4918 +{ 1.4919 + uint* r_dst = &DY; 1.4920 + 1.4921 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | MASK_OUT_ABOVE_8(*r_dst) | (GET_MSB_8(*r_dst) ? 0xff00 : 0); 1.4922 + 1.4923 + FLAG_N = NFLAG_16(*r_dst); 1.4924 + FLAG_Z = MASK_OUT_ABOVE_16(*r_dst); 1.4925 + FLAG_V = VFLAG_CLEAR; 1.4926 + FLAG_C = CFLAG_CLEAR; 1.4927 +} 1.4928 + 1.4929 + 1.4930 +M68KMAKE_OP(ext, 32, ., .) 1.4931 +{ 1.4932 + uint* r_dst = &DY; 1.4933 + 1.4934 + *r_dst = MASK_OUT_ABOVE_16(*r_dst) | (GET_MSB_16(*r_dst) ? 0xffff0000 : 0); 1.4935 + 1.4936 + FLAG_N = NFLAG_32(*r_dst); 1.4937 + FLAG_Z = *r_dst; 1.4938 + FLAG_V = VFLAG_CLEAR; 1.4939 + FLAG_C = CFLAG_CLEAR; 1.4940 +} 1.4941 + 1.4942 + 1.4943 +M68KMAKE_OP(extb, 32, ., .) 1.4944 +{ 1.4945 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.4946 + { 1.4947 + uint* r_dst = &DY; 1.4948 + 1.4949 + *r_dst = MASK_OUT_ABOVE_8(*r_dst) | (GET_MSB_8(*r_dst) ? 0xffffff00 : 0); 1.4950 + 1.4951 + FLAG_N = NFLAG_32(*r_dst); 1.4952 + FLAG_Z = *r_dst; 1.4953 + FLAG_V = VFLAG_CLEAR; 1.4954 + FLAG_C = CFLAG_CLEAR; 1.4955 + return; 1.4956 + } 1.4957 + m68ki_exception_illegal(); 1.4958 +} 1.4959 + 1.4960 + 1.4961 +M68KMAKE_OP(illegal, 0, ., .) 1.4962 +{ 1.4963 + m68ki_exception_illegal(); 1.4964 +} 1.4965 + 1.4966 +M68KMAKE_OP(jmp, 32, ., .) 1.4967 +{ 1.4968 + m68ki_jump(M68KMAKE_GET_EA_AY_32); 1.4969 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.4970 + if(REG_PC == REG_PPC) 1.4971 + USE_ALL_CYCLES(); 1.4972 +} 1.4973 + 1.4974 + 1.4975 +M68KMAKE_OP(jsr, 32, ., .) 1.4976 +{ 1.4977 + uint ea = M68KMAKE_GET_EA_AY_32; 1.4978 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.4979 + m68ki_push_32(REG_PC); 1.4980 + m68ki_jump(ea); 1.4981 +} 1.4982 + 1.4983 + 1.4984 +M68KMAKE_OP(lea, 32, ., .) 1.4985 +{ 1.4986 + AX = M68KMAKE_GET_EA_AY_32; 1.4987 +} 1.4988 + 1.4989 + 1.4990 +M68KMAKE_OP(link, 16, ., a7) 1.4991 +{ 1.4992 + REG_A[7] -= 4; 1.4993 + m68ki_write_32(REG_A[7], REG_A[7]); 1.4994 + REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16())); 1.4995 +} 1.4996 + 1.4997 + 1.4998 +M68KMAKE_OP(link, 16, ., .) 1.4999 +{ 1.5000 + uint* r_dst = &AY; 1.5001 + 1.5002 + m68ki_push_32(*r_dst); 1.5003 + *r_dst = REG_A[7]; 1.5004 + REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16())); 1.5005 +} 1.5006 + 1.5007 + 1.5008 +M68KMAKE_OP(link, 32, ., a7) 1.5009 +{ 1.5010 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.5011 + { 1.5012 + REG_A[7] -= 4; 1.5013 + m68ki_write_32(REG_A[7], REG_A[7]); 1.5014 + REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + OPER_I_32()); 1.5015 + return; 1.5016 + } 1.5017 + m68ki_exception_illegal(); 1.5018 +} 1.5019 + 1.5020 + 1.5021 +M68KMAKE_OP(link, 32, ., .) 1.5022 +{ 1.5023 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.5024 + { 1.5025 + uint* r_dst = &AY; 1.5026 + 1.5027 + m68ki_push_32(*r_dst); 1.5028 + *r_dst = REG_A[7]; 1.5029 + REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + OPER_I_32()); 1.5030 + return; 1.5031 + } 1.5032 + m68ki_exception_illegal(); 1.5033 +} 1.5034 + 1.5035 + 1.5036 +M68KMAKE_OP(lsr, 8, s, .) 1.5037 +{ 1.5038 + uint* r_dst = &DY; 1.5039 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.5040 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.5041 + uint res = src >> shift; 1.5042 + 1.5043 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.5044 + 1.5045 + FLAG_N = NFLAG_CLEAR; 1.5046 + FLAG_Z = res; 1.5047 + FLAG_X = FLAG_C = src << (9-shift); 1.5048 + FLAG_V = VFLAG_CLEAR; 1.5049 +} 1.5050 + 1.5051 + 1.5052 +M68KMAKE_OP(lsr, 16, s, .) 1.5053 +{ 1.5054 + uint* r_dst = &DY; 1.5055 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.5056 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.5057 + uint res = src >> shift; 1.5058 + 1.5059 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.5060 + 1.5061 + FLAG_N = NFLAG_CLEAR; 1.5062 + FLAG_Z = res; 1.5063 + FLAG_X = FLAG_C = src << (9-shift); 1.5064 + FLAG_V = VFLAG_CLEAR; 1.5065 +} 1.5066 + 1.5067 + 1.5068 +M68KMAKE_OP(lsr, 32, s, .) 1.5069 +{ 1.5070 + uint* r_dst = &DY; 1.5071 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.5072 + uint src = *r_dst; 1.5073 + uint res = src >> shift; 1.5074 + 1.5075 + *r_dst = res; 1.5076 + 1.5077 + FLAG_N = NFLAG_CLEAR; 1.5078 + FLAG_Z = res; 1.5079 + FLAG_X = FLAG_C = src << (9-shift); 1.5080 + FLAG_V = VFLAG_CLEAR; 1.5081 +} 1.5082 + 1.5083 + 1.5084 +M68KMAKE_OP(lsr, 8, r, .) 1.5085 +{ 1.5086 + uint* r_dst = &DY; 1.5087 + uint shift = DX & 0x3f; 1.5088 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.5089 + uint res = src >> shift; 1.5090 + 1.5091 + if(shift != 0) 1.5092 + { 1.5093 + USE_CYCLES(shift<<CYC_SHIFT); 1.5094 + 1.5095 + if(shift <= 8) 1.5096 + { 1.5097 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.5098 + FLAG_X = FLAG_C = src << (9-shift); 1.5099 + FLAG_N = NFLAG_CLEAR; 1.5100 + FLAG_Z = res; 1.5101 + FLAG_V = VFLAG_CLEAR; 1.5102 + return; 1.5103 + } 1.5104 + 1.5105 + *r_dst &= 0xffffff00; 1.5106 + FLAG_X = XFLAG_CLEAR; 1.5107 + FLAG_C = CFLAG_CLEAR; 1.5108 + FLAG_N = NFLAG_CLEAR; 1.5109 + FLAG_Z = ZFLAG_SET; 1.5110 + FLAG_V = VFLAG_CLEAR; 1.5111 + return; 1.5112 + } 1.5113 + 1.5114 + FLAG_C = CFLAG_CLEAR; 1.5115 + FLAG_N = NFLAG_8(src); 1.5116 + FLAG_Z = src; 1.5117 + FLAG_V = VFLAG_CLEAR; 1.5118 +} 1.5119 + 1.5120 + 1.5121 +M68KMAKE_OP(lsr, 16, r, .) 1.5122 +{ 1.5123 + uint* r_dst = &DY; 1.5124 + uint shift = DX & 0x3f; 1.5125 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.5126 + uint res = src >> shift; 1.5127 + 1.5128 + if(shift != 0) 1.5129 + { 1.5130 + USE_CYCLES(shift<<CYC_SHIFT); 1.5131 + 1.5132 + if(shift <= 16) 1.5133 + { 1.5134 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.5135 + FLAG_C = FLAG_X = (src >> (shift - 1))<<8; 1.5136 + FLAG_N = NFLAG_CLEAR; 1.5137 + FLAG_Z = res; 1.5138 + FLAG_V = VFLAG_CLEAR; 1.5139 + return; 1.5140 + } 1.5141 + 1.5142 + *r_dst &= 0xffff0000; 1.5143 + FLAG_X = XFLAG_CLEAR; 1.5144 + FLAG_C = CFLAG_CLEAR; 1.5145 + FLAG_N = NFLAG_CLEAR; 1.5146 + FLAG_Z = ZFLAG_SET; 1.5147 + FLAG_V = VFLAG_CLEAR; 1.5148 + return; 1.5149 + } 1.5150 + 1.5151 + FLAG_C = CFLAG_CLEAR; 1.5152 + FLAG_N = NFLAG_16(src); 1.5153 + FLAG_Z = src; 1.5154 + FLAG_V = VFLAG_CLEAR; 1.5155 +} 1.5156 + 1.5157 + 1.5158 +M68KMAKE_OP(lsr, 32, r, .) 1.5159 +{ 1.5160 + uint* r_dst = &DY; 1.5161 + uint shift = DX & 0x3f; 1.5162 + uint src = *r_dst; 1.5163 + uint res = src >> shift; 1.5164 + 1.5165 + if(shift != 0) 1.5166 + { 1.5167 + USE_CYCLES(shift<<CYC_SHIFT); 1.5168 + 1.5169 + if(shift < 32) 1.5170 + { 1.5171 + *r_dst = res; 1.5172 + FLAG_C = FLAG_X = (src >> (shift - 1))<<8; 1.5173 + FLAG_N = NFLAG_CLEAR; 1.5174 + FLAG_Z = res; 1.5175 + FLAG_V = VFLAG_CLEAR; 1.5176 + return; 1.5177 + } 1.5178 + 1.5179 + *r_dst = 0; 1.5180 + FLAG_X = FLAG_C = (shift == 32 ? GET_MSB_32(src)>>23 : 0); 1.5181 + FLAG_N = NFLAG_CLEAR; 1.5182 + FLAG_Z = ZFLAG_SET; 1.5183 + FLAG_V = VFLAG_CLEAR; 1.5184 + return; 1.5185 + } 1.5186 + 1.5187 + FLAG_C = CFLAG_CLEAR; 1.5188 + FLAG_N = NFLAG_32(src); 1.5189 + FLAG_Z = src; 1.5190 + FLAG_V = VFLAG_CLEAR; 1.5191 +} 1.5192 + 1.5193 + 1.5194 +M68KMAKE_OP(lsr, 16, ., .) 1.5195 +{ 1.5196 + uint ea = M68KMAKE_GET_EA_AY_16; 1.5197 + uint src = m68ki_read_16(ea); 1.5198 + uint res = src >> 1; 1.5199 + 1.5200 + m68ki_write_16(ea, res); 1.5201 + 1.5202 + FLAG_N = NFLAG_CLEAR; 1.5203 + FLAG_Z = res; 1.5204 + FLAG_C = FLAG_X = src << 8; 1.5205 + FLAG_V = VFLAG_CLEAR; 1.5206 +} 1.5207 + 1.5208 + 1.5209 +M68KMAKE_OP(lsl, 8, s, .) 1.5210 +{ 1.5211 + uint* r_dst = &DY; 1.5212 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.5213 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.5214 + uint res = MASK_OUT_ABOVE_8(src << shift); 1.5215 + 1.5216 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.5217 + 1.5218 + FLAG_N = NFLAG_8(res); 1.5219 + FLAG_Z = res; 1.5220 + FLAG_X = FLAG_C = src << shift; 1.5221 + FLAG_V = VFLAG_CLEAR; 1.5222 +} 1.5223 + 1.5224 + 1.5225 +M68KMAKE_OP(lsl, 16, s, .) 1.5226 +{ 1.5227 + uint* r_dst = &DY; 1.5228 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.5229 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.5230 + uint res = MASK_OUT_ABOVE_16(src << shift); 1.5231 + 1.5232 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.5233 + 1.5234 + FLAG_N = NFLAG_16(res); 1.5235 + FLAG_Z = res; 1.5236 + FLAG_X = FLAG_C = src >> (8-shift); 1.5237 + FLAG_V = VFLAG_CLEAR; 1.5238 +} 1.5239 + 1.5240 + 1.5241 +M68KMAKE_OP(lsl, 32, s, .) 1.5242 +{ 1.5243 + uint* r_dst = &DY; 1.5244 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.5245 + uint src = *r_dst; 1.5246 + uint res = MASK_OUT_ABOVE_32(src << shift); 1.5247 + 1.5248 + *r_dst = res; 1.5249 + 1.5250 + FLAG_N = NFLAG_32(res); 1.5251 + FLAG_Z = res; 1.5252 + FLAG_X = FLAG_C = src >> (24-shift); 1.5253 + FLAG_V = VFLAG_CLEAR; 1.5254 +} 1.5255 + 1.5256 + 1.5257 +M68KMAKE_OP(lsl, 8, r, .) 1.5258 +{ 1.5259 + uint* r_dst = &DY; 1.5260 + uint shift = DX & 0x3f; 1.5261 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.5262 + uint res = MASK_OUT_ABOVE_8(src << shift); 1.5263 + 1.5264 + if(shift != 0) 1.5265 + { 1.5266 + USE_CYCLES(shift<<CYC_SHIFT); 1.5267 + 1.5268 + if(shift <= 8) 1.5269 + { 1.5270 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.5271 + FLAG_X = FLAG_C = src << shift; 1.5272 + FLAG_N = NFLAG_8(res); 1.5273 + FLAG_Z = res; 1.5274 + FLAG_V = VFLAG_CLEAR; 1.5275 + return; 1.5276 + } 1.5277 + 1.5278 + *r_dst &= 0xffffff00; 1.5279 + FLAG_X = XFLAG_CLEAR; 1.5280 + FLAG_C = CFLAG_CLEAR; 1.5281 + FLAG_N = NFLAG_CLEAR; 1.5282 + FLAG_Z = ZFLAG_SET; 1.5283 + FLAG_V = VFLAG_CLEAR; 1.5284 + return; 1.5285 + } 1.5286 + 1.5287 + FLAG_C = CFLAG_CLEAR; 1.5288 + FLAG_N = NFLAG_8(src); 1.5289 + FLAG_Z = src; 1.5290 + FLAG_V = VFLAG_CLEAR; 1.5291 +} 1.5292 + 1.5293 + 1.5294 +M68KMAKE_OP(lsl, 16, r, .) 1.5295 +{ 1.5296 + uint* r_dst = &DY; 1.5297 + uint shift = DX & 0x3f; 1.5298 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.5299 + uint res = MASK_OUT_ABOVE_16(src << shift); 1.5300 + 1.5301 + if(shift != 0) 1.5302 + { 1.5303 + USE_CYCLES(shift<<CYC_SHIFT); 1.5304 + 1.5305 + if(shift <= 16) 1.5306 + { 1.5307 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.5308 + FLAG_X = FLAG_C = (src << shift) >> 8; 1.5309 + FLAG_N = NFLAG_16(res); 1.5310 + FLAG_Z = res; 1.5311 + FLAG_V = VFLAG_CLEAR; 1.5312 + return; 1.5313 + } 1.5314 + 1.5315 + *r_dst &= 0xffff0000; 1.5316 + FLAG_X = XFLAG_CLEAR; 1.5317 + FLAG_C = CFLAG_CLEAR; 1.5318 + FLAG_N = NFLAG_CLEAR; 1.5319 + FLAG_Z = ZFLAG_SET; 1.5320 + FLAG_V = VFLAG_CLEAR; 1.5321 + return; 1.5322 + } 1.5323 + 1.5324 + FLAG_C = CFLAG_CLEAR; 1.5325 + FLAG_N = NFLAG_16(src); 1.5326 + FLAG_Z = src; 1.5327 + FLAG_V = VFLAG_CLEAR; 1.5328 +} 1.5329 + 1.5330 + 1.5331 +M68KMAKE_OP(lsl, 32, r, .) 1.5332 +{ 1.5333 + uint* r_dst = &DY; 1.5334 + uint shift = DX & 0x3f; 1.5335 + uint src = *r_dst; 1.5336 + uint res = MASK_OUT_ABOVE_32(src << shift); 1.5337 + 1.5338 + if(shift != 0) 1.5339 + { 1.5340 + USE_CYCLES(shift<<CYC_SHIFT); 1.5341 + 1.5342 + if(shift < 32) 1.5343 + { 1.5344 + *r_dst = res; 1.5345 + FLAG_X = FLAG_C = (src >> (32 - shift)) << 8; 1.5346 + FLAG_N = NFLAG_32(res); 1.5347 + FLAG_Z = res; 1.5348 + FLAG_V = VFLAG_CLEAR; 1.5349 + return; 1.5350 + } 1.5351 + 1.5352 + *r_dst = 0; 1.5353 + FLAG_X = FLAG_C = ((shift == 32 ? src & 1 : 0))<<8; 1.5354 + FLAG_N = NFLAG_CLEAR; 1.5355 + FLAG_Z = ZFLAG_SET; 1.5356 + FLAG_V = VFLAG_CLEAR; 1.5357 + return; 1.5358 + } 1.5359 + 1.5360 + FLAG_C = CFLAG_CLEAR; 1.5361 + FLAG_N = NFLAG_32(src); 1.5362 + FLAG_Z = src; 1.5363 + FLAG_V = VFLAG_CLEAR; 1.5364 +} 1.5365 + 1.5366 + 1.5367 +M68KMAKE_OP(lsl, 16, ., .) 1.5368 +{ 1.5369 + uint ea = M68KMAKE_GET_EA_AY_16; 1.5370 + uint src = m68ki_read_16(ea); 1.5371 + uint res = MASK_OUT_ABOVE_16(src << 1); 1.5372 + 1.5373 + m68ki_write_16(ea, res); 1.5374 + 1.5375 + FLAG_N = NFLAG_16(res); 1.5376 + FLAG_Z = res; 1.5377 + FLAG_X = FLAG_C = src >> 7; 1.5378 + FLAG_V = VFLAG_CLEAR; 1.5379 +} 1.5380 + 1.5381 + 1.5382 +M68KMAKE_OP(move, 8, d, d) 1.5383 +{ 1.5384 + uint res = MASK_OUT_ABOVE_8(DY); 1.5385 + uint* r_dst = &DX; 1.5386 + 1.5387 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.5388 + 1.5389 + FLAG_N = NFLAG_8(res); 1.5390 + FLAG_Z = res; 1.5391 + FLAG_V = VFLAG_CLEAR; 1.5392 + FLAG_C = CFLAG_CLEAR; 1.5393 +} 1.5394 + 1.5395 + 1.5396 +M68KMAKE_OP(move, 8, d, .) 1.5397 +{ 1.5398 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5399 + uint* r_dst = &DX; 1.5400 + 1.5401 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.5402 + 1.5403 + FLAG_N = NFLAG_8(res); 1.5404 + FLAG_Z = res; 1.5405 + FLAG_V = VFLAG_CLEAR; 1.5406 + FLAG_C = CFLAG_CLEAR; 1.5407 +} 1.5408 + 1.5409 + 1.5410 +M68KMAKE_OP(move, 8, ai, d) 1.5411 +{ 1.5412 + uint res = MASK_OUT_ABOVE_8(DY); 1.5413 + uint ea = EA_AX_AI_8(); 1.5414 + 1.5415 + m68ki_write_8(ea, res); 1.5416 + 1.5417 + FLAG_N = NFLAG_8(res); 1.5418 + FLAG_Z = res; 1.5419 + FLAG_V = VFLAG_CLEAR; 1.5420 + FLAG_C = CFLAG_CLEAR; 1.5421 +} 1.5422 + 1.5423 + 1.5424 +M68KMAKE_OP(move, 8, ai, .) 1.5425 +{ 1.5426 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5427 + uint ea = EA_AX_AI_8(); 1.5428 + 1.5429 + m68ki_write_8(ea, res); 1.5430 + 1.5431 + FLAG_N = NFLAG_8(res); 1.5432 + FLAG_Z = res; 1.5433 + FLAG_V = VFLAG_CLEAR; 1.5434 + FLAG_C = CFLAG_CLEAR; 1.5435 +} 1.5436 + 1.5437 + 1.5438 +M68KMAKE_OP(move, 8, pi7, d) 1.5439 +{ 1.5440 + uint res = MASK_OUT_ABOVE_8(DY); 1.5441 + uint ea = EA_A7_PI_8(); 1.5442 + 1.5443 + m68ki_write_8(ea, res); 1.5444 + 1.5445 + FLAG_N = NFLAG_8(res); 1.5446 + FLAG_Z = res; 1.5447 + FLAG_V = VFLAG_CLEAR; 1.5448 + FLAG_C = CFLAG_CLEAR; 1.5449 +} 1.5450 + 1.5451 + 1.5452 +M68KMAKE_OP(move, 8, pi, d) 1.5453 +{ 1.5454 + uint res = MASK_OUT_ABOVE_8(DY); 1.5455 + uint ea = EA_AX_PI_8(); 1.5456 + 1.5457 + m68ki_write_8(ea, res); 1.5458 + 1.5459 + FLAG_N = NFLAG_8(res); 1.5460 + FLAG_Z = res; 1.5461 + FLAG_V = VFLAG_CLEAR; 1.5462 + FLAG_C = CFLAG_CLEAR; 1.5463 +} 1.5464 + 1.5465 + 1.5466 +M68KMAKE_OP(move, 8, pi7, .) 1.5467 +{ 1.5468 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5469 + uint ea = EA_A7_PI_8(); 1.5470 + 1.5471 + m68ki_write_8(ea, res); 1.5472 + 1.5473 + FLAG_N = NFLAG_8(res); 1.5474 + FLAG_Z = res; 1.5475 + FLAG_V = VFLAG_CLEAR; 1.5476 + FLAG_C = CFLAG_CLEAR; 1.5477 +} 1.5478 + 1.5479 + 1.5480 +M68KMAKE_OP(move, 8, pi, .) 1.5481 +{ 1.5482 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5483 + uint ea = EA_AX_PI_8(); 1.5484 + 1.5485 + m68ki_write_8(ea, res); 1.5486 + 1.5487 + FLAG_N = NFLAG_8(res); 1.5488 + FLAG_Z = res; 1.5489 + FLAG_V = VFLAG_CLEAR; 1.5490 + FLAG_C = CFLAG_CLEAR; 1.5491 +} 1.5492 + 1.5493 + 1.5494 +M68KMAKE_OP(move, 8, pd7, d) 1.5495 +{ 1.5496 + uint res = MASK_OUT_ABOVE_8(DY); 1.5497 + uint ea = EA_A7_PD_8(); 1.5498 + 1.5499 + m68ki_write_8(ea, res); 1.5500 + 1.5501 + FLAG_N = NFLAG_8(res); 1.5502 + FLAG_Z = res; 1.5503 + FLAG_V = VFLAG_CLEAR; 1.5504 + FLAG_C = CFLAG_CLEAR; 1.5505 +} 1.5506 + 1.5507 + 1.5508 +M68KMAKE_OP(move, 8, pd, d) 1.5509 +{ 1.5510 + uint res = MASK_OUT_ABOVE_8(DY); 1.5511 + uint ea = EA_AX_PD_8(); 1.5512 + 1.5513 + m68ki_write_8(ea, res); 1.5514 + 1.5515 + FLAG_N = NFLAG_8(res); 1.5516 + FLAG_Z = res; 1.5517 + FLAG_V = VFLAG_CLEAR; 1.5518 + FLAG_C = CFLAG_CLEAR; 1.5519 +} 1.5520 + 1.5521 + 1.5522 +M68KMAKE_OP(move, 8, pd7, .) 1.5523 +{ 1.5524 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5525 + uint ea = EA_A7_PD_8(); 1.5526 + 1.5527 + m68ki_write_8(ea, res); 1.5528 + 1.5529 + FLAG_N = NFLAG_8(res); 1.5530 + FLAG_Z = res; 1.5531 + FLAG_V = VFLAG_CLEAR; 1.5532 + FLAG_C = CFLAG_CLEAR; 1.5533 +} 1.5534 + 1.5535 + 1.5536 +M68KMAKE_OP(move, 8, pd, .) 1.5537 +{ 1.5538 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5539 + uint ea = EA_AX_PD_8(); 1.5540 + 1.5541 + m68ki_write_8(ea, res); 1.5542 + 1.5543 + FLAG_N = NFLAG_8(res); 1.5544 + FLAG_Z = res; 1.5545 + FLAG_V = VFLAG_CLEAR; 1.5546 + FLAG_C = CFLAG_CLEAR; 1.5547 +} 1.5548 + 1.5549 + 1.5550 +M68KMAKE_OP(move, 8, di, d) 1.5551 +{ 1.5552 + uint res = MASK_OUT_ABOVE_8(DY); 1.5553 + uint ea = EA_AX_DI_8(); 1.5554 + 1.5555 + m68ki_write_8(ea, res); 1.5556 + 1.5557 + FLAG_N = NFLAG_8(res); 1.5558 + FLAG_Z = res; 1.5559 + FLAG_V = VFLAG_CLEAR; 1.5560 + FLAG_C = CFLAG_CLEAR; 1.5561 +} 1.5562 + 1.5563 + 1.5564 +M68KMAKE_OP(move, 8, di, .) 1.5565 +{ 1.5566 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5567 + uint ea = EA_AX_DI_8(); 1.5568 + 1.5569 + m68ki_write_8(ea, res); 1.5570 + 1.5571 + FLAG_N = NFLAG_8(res); 1.5572 + FLAG_Z = res; 1.5573 + FLAG_V = VFLAG_CLEAR; 1.5574 + FLAG_C = CFLAG_CLEAR; 1.5575 +} 1.5576 + 1.5577 + 1.5578 +M68KMAKE_OP(move, 8, ix, d) 1.5579 +{ 1.5580 + uint res = MASK_OUT_ABOVE_8(DY); 1.5581 + uint ea = EA_AX_IX_8(); 1.5582 + 1.5583 + m68ki_write_8(ea, res); 1.5584 + 1.5585 + FLAG_N = NFLAG_8(res); 1.5586 + FLAG_Z = res; 1.5587 + FLAG_V = VFLAG_CLEAR; 1.5588 + FLAG_C = CFLAG_CLEAR; 1.5589 +} 1.5590 + 1.5591 + 1.5592 +M68KMAKE_OP(move, 8, ix, .) 1.5593 +{ 1.5594 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5595 + uint ea = EA_AX_IX_8(); 1.5596 + 1.5597 + m68ki_write_8(ea, res); 1.5598 + 1.5599 + FLAG_N = NFLAG_8(res); 1.5600 + FLAG_Z = res; 1.5601 + FLAG_V = VFLAG_CLEAR; 1.5602 + FLAG_C = CFLAG_CLEAR; 1.5603 +} 1.5604 + 1.5605 + 1.5606 +M68KMAKE_OP(move, 8, aw, d) 1.5607 +{ 1.5608 + uint res = MASK_OUT_ABOVE_8(DY); 1.5609 + uint ea = EA_AW_8(); 1.5610 + 1.5611 + m68ki_write_8(ea, res); 1.5612 + 1.5613 + FLAG_N = NFLAG_8(res); 1.5614 + FLAG_Z = res; 1.5615 + FLAG_V = VFLAG_CLEAR; 1.5616 + FLAG_C = CFLAG_CLEAR; 1.5617 +} 1.5618 + 1.5619 + 1.5620 +M68KMAKE_OP(move, 8, aw, .) 1.5621 +{ 1.5622 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5623 + uint ea = EA_AW_8(); 1.5624 + 1.5625 + m68ki_write_8(ea, res); 1.5626 + 1.5627 + FLAG_N = NFLAG_8(res); 1.5628 + FLAG_Z = res; 1.5629 + FLAG_V = VFLAG_CLEAR; 1.5630 + FLAG_C = CFLAG_CLEAR; 1.5631 +} 1.5632 + 1.5633 + 1.5634 +M68KMAKE_OP(move, 8, al, d) 1.5635 +{ 1.5636 + uint res = MASK_OUT_ABOVE_8(DY); 1.5637 + uint ea = EA_AL_8(); 1.5638 + 1.5639 + m68ki_write_8(ea, res); 1.5640 + 1.5641 + FLAG_N = NFLAG_8(res); 1.5642 + FLAG_Z = res; 1.5643 + FLAG_V = VFLAG_CLEAR; 1.5644 + FLAG_C = CFLAG_CLEAR; 1.5645 +} 1.5646 + 1.5647 + 1.5648 +M68KMAKE_OP(move, 8, al, .) 1.5649 +{ 1.5650 + uint res = M68KMAKE_GET_OPER_AY_8; 1.5651 + uint ea = EA_AL_8(); 1.5652 + 1.5653 + m68ki_write_8(ea, res); 1.5654 + 1.5655 + FLAG_N = NFLAG_8(res); 1.5656 + FLAG_Z = res; 1.5657 + FLAG_V = VFLAG_CLEAR; 1.5658 + FLAG_C = CFLAG_CLEAR; 1.5659 +} 1.5660 + 1.5661 + 1.5662 +M68KMAKE_OP(move, 16, d, d) 1.5663 +{ 1.5664 + uint res = MASK_OUT_ABOVE_16(DY); 1.5665 + uint* r_dst = &DX; 1.5666 + 1.5667 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.5668 + 1.5669 + FLAG_N = NFLAG_16(res); 1.5670 + FLAG_Z = res; 1.5671 + FLAG_V = VFLAG_CLEAR; 1.5672 + FLAG_C = CFLAG_CLEAR; 1.5673 +} 1.5674 + 1.5675 + 1.5676 +M68KMAKE_OP(move, 16, d, a) 1.5677 +{ 1.5678 + uint res = MASK_OUT_ABOVE_16(AY); 1.5679 + uint* r_dst = &DX; 1.5680 + 1.5681 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.5682 + 1.5683 + FLAG_N = NFLAG_16(res); 1.5684 + FLAG_Z = res; 1.5685 + FLAG_V = VFLAG_CLEAR; 1.5686 + FLAG_C = CFLAG_CLEAR; 1.5687 +} 1.5688 + 1.5689 + 1.5690 +M68KMAKE_OP(move, 16, d, .) 1.5691 +{ 1.5692 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5693 + uint* r_dst = &DX; 1.5694 + 1.5695 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.5696 + 1.5697 + FLAG_N = NFLAG_16(res); 1.5698 + FLAG_Z = res; 1.5699 + FLAG_V = VFLAG_CLEAR; 1.5700 + FLAG_C = CFLAG_CLEAR; 1.5701 +} 1.5702 + 1.5703 + 1.5704 +M68KMAKE_OP(move, 16, ai, d) 1.5705 +{ 1.5706 + uint res = MASK_OUT_ABOVE_16(DY); 1.5707 + uint ea = EA_AX_AI_16(); 1.5708 + 1.5709 + m68ki_write_16(ea, res); 1.5710 + 1.5711 + FLAG_N = NFLAG_16(res); 1.5712 + FLAG_Z = res; 1.5713 + FLAG_V = VFLAG_CLEAR; 1.5714 + FLAG_C = CFLAG_CLEAR; 1.5715 +} 1.5716 + 1.5717 + 1.5718 +M68KMAKE_OP(move, 16, ai, a) 1.5719 +{ 1.5720 + uint res = MASK_OUT_ABOVE_16(AY); 1.5721 + uint ea = EA_AX_AI_16(); 1.5722 + 1.5723 + m68ki_write_16(ea, res); 1.5724 + 1.5725 + FLAG_N = NFLAG_16(res); 1.5726 + FLAG_Z = res; 1.5727 + FLAG_V = VFLAG_CLEAR; 1.5728 + FLAG_C = CFLAG_CLEAR; 1.5729 +} 1.5730 + 1.5731 + 1.5732 +M68KMAKE_OP(move, 16, ai, .) 1.5733 +{ 1.5734 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5735 + uint ea = EA_AX_AI_16(); 1.5736 + 1.5737 + m68ki_write_16(ea, res); 1.5738 + 1.5739 + FLAG_N = NFLAG_16(res); 1.5740 + FLAG_Z = res; 1.5741 + FLAG_V = VFLAG_CLEAR; 1.5742 + FLAG_C = CFLAG_CLEAR; 1.5743 +} 1.5744 + 1.5745 + 1.5746 +M68KMAKE_OP(move, 16, pi, d) 1.5747 +{ 1.5748 + uint res = MASK_OUT_ABOVE_16(DY); 1.5749 + uint ea = EA_AX_PI_16(); 1.5750 + 1.5751 + m68ki_write_16(ea, res); 1.5752 + 1.5753 + FLAG_N = NFLAG_16(res); 1.5754 + FLAG_Z = res; 1.5755 + FLAG_V = VFLAG_CLEAR; 1.5756 + FLAG_C = CFLAG_CLEAR; 1.5757 +} 1.5758 + 1.5759 + 1.5760 +M68KMAKE_OP(move, 16, pi, a) 1.5761 +{ 1.5762 + uint res = MASK_OUT_ABOVE_16(AY); 1.5763 + uint ea = EA_AX_PI_16(); 1.5764 + 1.5765 + m68ki_write_16(ea, res); 1.5766 + 1.5767 + FLAG_N = NFLAG_16(res); 1.5768 + FLAG_Z = res; 1.5769 + FLAG_V = VFLAG_CLEAR; 1.5770 + FLAG_C = CFLAG_CLEAR; 1.5771 +} 1.5772 + 1.5773 + 1.5774 +M68KMAKE_OP(move, 16, pi, .) 1.5775 +{ 1.5776 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5777 + uint ea = EA_AX_PI_16(); 1.5778 + 1.5779 + m68ki_write_16(ea, res); 1.5780 + 1.5781 + FLAG_N = NFLAG_16(res); 1.5782 + FLAG_Z = res; 1.5783 + FLAG_V = VFLAG_CLEAR; 1.5784 + FLAG_C = CFLAG_CLEAR; 1.5785 +} 1.5786 + 1.5787 + 1.5788 +M68KMAKE_OP(move, 16, pd, d) 1.5789 +{ 1.5790 + uint res = MASK_OUT_ABOVE_16(DY); 1.5791 + uint ea = EA_AX_PD_16(); 1.5792 + 1.5793 + m68ki_write_16(ea, res); 1.5794 + 1.5795 + FLAG_N = NFLAG_16(res); 1.5796 + FLAG_Z = res; 1.5797 + FLAG_V = VFLAG_CLEAR; 1.5798 + FLAG_C = CFLAG_CLEAR; 1.5799 +} 1.5800 + 1.5801 + 1.5802 +M68KMAKE_OP(move, 16, pd, a) 1.5803 +{ 1.5804 + uint res = MASK_OUT_ABOVE_16(AY); 1.5805 + uint ea = EA_AX_PD_16(); 1.5806 + 1.5807 + m68ki_write_16(ea, res); 1.5808 + 1.5809 + FLAG_N = NFLAG_16(res); 1.5810 + FLAG_Z = res; 1.5811 + FLAG_V = VFLAG_CLEAR; 1.5812 + FLAG_C = CFLAG_CLEAR; 1.5813 +} 1.5814 + 1.5815 + 1.5816 +M68KMAKE_OP(move, 16, pd, .) 1.5817 +{ 1.5818 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5819 + uint ea = EA_AX_PD_16(); 1.5820 + 1.5821 + m68ki_write_16(ea, res); 1.5822 + 1.5823 + FLAG_N = NFLAG_16(res); 1.5824 + FLAG_Z = res; 1.5825 + FLAG_V = VFLAG_CLEAR; 1.5826 + FLAG_C = CFLAG_CLEAR; 1.5827 +} 1.5828 + 1.5829 + 1.5830 +M68KMAKE_OP(move, 16, di, d) 1.5831 +{ 1.5832 + uint res = MASK_OUT_ABOVE_16(DY); 1.5833 + uint ea = EA_AX_DI_16(); 1.5834 + 1.5835 + m68ki_write_16(ea, res); 1.5836 + 1.5837 + FLAG_N = NFLAG_16(res); 1.5838 + FLAG_Z = res; 1.5839 + FLAG_V = VFLAG_CLEAR; 1.5840 + FLAG_C = CFLAG_CLEAR; 1.5841 +} 1.5842 + 1.5843 + 1.5844 +M68KMAKE_OP(move, 16, di, a) 1.5845 +{ 1.5846 + uint res = MASK_OUT_ABOVE_16(AY); 1.5847 + uint ea = EA_AX_DI_16(); 1.5848 + 1.5849 + m68ki_write_16(ea, res); 1.5850 + 1.5851 + FLAG_N = NFLAG_16(res); 1.5852 + FLAG_Z = res; 1.5853 + FLAG_V = VFLAG_CLEAR; 1.5854 + FLAG_C = CFLAG_CLEAR; 1.5855 +} 1.5856 + 1.5857 + 1.5858 +M68KMAKE_OP(move, 16, di, .) 1.5859 +{ 1.5860 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5861 + uint ea = EA_AX_DI_16(); 1.5862 + 1.5863 + m68ki_write_16(ea, res); 1.5864 + 1.5865 + FLAG_N = NFLAG_16(res); 1.5866 + FLAG_Z = res; 1.5867 + FLAG_V = VFLAG_CLEAR; 1.5868 + FLAG_C = CFLAG_CLEAR; 1.5869 +} 1.5870 + 1.5871 + 1.5872 +M68KMAKE_OP(move, 16, ix, d) 1.5873 +{ 1.5874 + uint res = MASK_OUT_ABOVE_16(DY); 1.5875 + uint ea = EA_AX_IX_16(); 1.5876 + 1.5877 + m68ki_write_16(ea, res); 1.5878 + 1.5879 + FLAG_N = NFLAG_16(res); 1.5880 + FLAG_Z = res; 1.5881 + FLAG_V = VFLAG_CLEAR; 1.5882 + FLAG_C = CFLAG_CLEAR; 1.5883 +} 1.5884 + 1.5885 + 1.5886 +M68KMAKE_OP(move, 16, ix, a) 1.5887 +{ 1.5888 + uint res = MASK_OUT_ABOVE_16(AY); 1.5889 + uint ea = EA_AX_IX_16(); 1.5890 + 1.5891 + m68ki_write_16(ea, res); 1.5892 + 1.5893 + FLAG_N = NFLAG_16(res); 1.5894 + FLAG_Z = res; 1.5895 + FLAG_V = VFLAG_CLEAR; 1.5896 + FLAG_C = CFLAG_CLEAR; 1.5897 +} 1.5898 + 1.5899 + 1.5900 +M68KMAKE_OP(move, 16, ix, .) 1.5901 +{ 1.5902 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5903 + uint ea = EA_AX_IX_16(); 1.5904 + 1.5905 + m68ki_write_16(ea, res); 1.5906 + 1.5907 + FLAG_N = NFLAG_16(res); 1.5908 + FLAG_Z = res; 1.5909 + FLAG_V = VFLAG_CLEAR; 1.5910 + FLAG_C = CFLAG_CLEAR; 1.5911 +} 1.5912 + 1.5913 + 1.5914 +M68KMAKE_OP(move, 16, aw, d) 1.5915 +{ 1.5916 + uint res = MASK_OUT_ABOVE_16(DY); 1.5917 + uint ea = EA_AW_16(); 1.5918 + 1.5919 + m68ki_write_16(ea, res); 1.5920 + 1.5921 + FLAG_N = NFLAG_16(res); 1.5922 + FLAG_Z = res; 1.5923 + FLAG_V = VFLAG_CLEAR; 1.5924 + FLAG_C = CFLAG_CLEAR; 1.5925 +} 1.5926 + 1.5927 + 1.5928 +M68KMAKE_OP(move, 16, aw, a) 1.5929 +{ 1.5930 + uint res = MASK_OUT_ABOVE_16(AY); 1.5931 + uint ea = EA_AW_16(); 1.5932 + 1.5933 + m68ki_write_16(ea, res); 1.5934 + 1.5935 + FLAG_N = NFLAG_16(res); 1.5936 + FLAG_Z = res; 1.5937 + FLAG_V = VFLAG_CLEAR; 1.5938 + FLAG_C = CFLAG_CLEAR; 1.5939 +} 1.5940 + 1.5941 + 1.5942 +M68KMAKE_OP(move, 16, aw, .) 1.5943 +{ 1.5944 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5945 + uint ea = EA_AW_16(); 1.5946 + 1.5947 + m68ki_write_16(ea, res); 1.5948 + 1.5949 + FLAG_N = NFLAG_16(res); 1.5950 + FLAG_Z = res; 1.5951 + FLAG_V = VFLAG_CLEAR; 1.5952 + FLAG_C = CFLAG_CLEAR; 1.5953 +} 1.5954 + 1.5955 + 1.5956 +M68KMAKE_OP(move, 16, al, d) 1.5957 +{ 1.5958 + uint res = MASK_OUT_ABOVE_16(DY); 1.5959 + uint ea = EA_AL_16(); 1.5960 + 1.5961 + m68ki_write_16(ea, res); 1.5962 + 1.5963 + FLAG_N = NFLAG_16(res); 1.5964 + FLAG_Z = res; 1.5965 + FLAG_V = VFLAG_CLEAR; 1.5966 + FLAG_C = CFLAG_CLEAR; 1.5967 +} 1.5968 + 1.5969 + 1.5970 +M68KMAKE_OP(move, 16, al, a) 1.5971 +{ 1.5972 + uint res = MASK_OUT_ABOVE_16(AY); 1.5973 + uint ea = EA_AL_16(); 1.5974 + 1.5975 + m68ki_write_16(ea, res); 1.5976 + 1.5977 + FLAG_N = NFLAG_16(res); 1.5978 + FLAG_Z = res; 1.5979 + FLAG_V = VFLAG_CLEAR; 1.5980 + FLAG_C = CFLAG_CLEAR; 1.5981 +} 1.5982 + 1.5983 + 1.5984 +M68KMAKE_OP(move, 16, al, .) 1.5985 +{ 1.5986 + uint res = M68KMAKE_GET_OPER_AY_16; 1.5987 + uint ea = EA_AL_16(); 1.5988 + 1.5989 + m68ki_write_16(ea, res); 1.5990 + 1.5991 + FLAG_N = NFLAG_16(res); 1.5992 + FLAG_Z = res; 1.5993 + FLAG_V = VFLAG_CLEAR; 1.5994 + FLAG_C = CFLAG_CLEAR; 1.5995 +} 1.5996 + 1.5997 + 1.5998 +M68KMAKE_OP(move, 32, d, d) 1.5999 +{ 1.6000 + uint res = DY; 1.6001 + uint* r_dst = &DX; 1.6002 + 1.6003 + *r_dst = res; 1.6004 + 1.6005 + FLAG_N = NFLAG_32(res); 1.6006 + FLAG_Z = res; 1.6007 + FLAG_V = VFLAG_CLEAR; 1.6008 + FLAG_C = CFLAG_CLEAR; 1.6009 +} 1.6010 + 1.6011 + 1.6012 +M68KMAKE_OP(move, 32, d, a) 1.6013 +{ 1.6014 + uint res = AY; 1.6015 + uint* r_dst = &DX; 1.6016 + 1.6017 + *r_dst = res; 1.6018 + 1.6019 + FLAG_N = NFLAG_32(res); 1.6020 + FLAG_Z = res; 1.6021 + FLAG_V = VFLAG_CLEAR; 1.6022 + FLAG_C = CFLAG_CLEAR; 1.6023 +} 1.6024 + 1.6025 + 1.6026 +M68KMAKE_OP(move, 32, d, .) 1.6027 +{ 1.6028 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6029 + uint* r_dst = &DX; 1.6030 + 1.6031 + *r_dst = res; 1.6032 + 1.6033 + FLAG_N = NFLAG_32(res); 1.6034 + FLAG_Z = res; 1.6035 + FLAG_V = VFLAG_CLEAR; 1.6036 + FLAG_C = CFLAG_CLEAR; 1.6037 +} 1.6038 + 1.6039 + 1.6040 +M68KMAKE_OP(move, 32, ai, d) 1.6041 +{ 1.6042 + uint res = DY; 1.6043 + uint ea = EA_AX_AI_32(); 1.6044 + 1.6045 + m68ki_write_32(ea, res); 1.6046 + 1.6047 + FLAG_N = NFLAG_32(res); 1.6048 + FLAG_Z = res; 1.6049 + FLAG_V = VFLAG_CLEAR; 1.6050 + FLAG_C = CFLAG_CLEAR; 1.6051 +} 1.6052 + 1.6053 + 1.6054 +M68KMAKE_OP(move, 32, ai, a) 1.6055 +{ 1.6056 + uint res = AY; 1.6057 + uint ea = EA_AX_AI_32(); 1.6058 + 1.6059 + m68ki_write_32(ea, res); 1.6060 + 1.6061 + FLAG_N = NFLAG_32(res); 1.6062 + FLAG_Z = res; 1.6063 + FLAG_V = VFLAG_CLEAR; 1.6064 + FLAG_C = CFLAG_CLEAR; 1.6065 +} 1.6066 + 1.6067 + 1.6068 +M68KMAKE_OP(move, 32, ai, .) 1.6069 +{ 1.6070 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6071 + uint ea = EA_AX_AI_32(); 1.6072 + 1.6073 + m68ki_write_32(ea, res); 1.6074 + 1.6075 + FLAG_N = NFLAG_32(res); 1.6076 + FLAG_Z = res; 1.6077 + FLAG_V = VFLAG_CLEAR; 1.6078 + FLAG_C = CFLAG_CLEAR; 1.6079 +} 1.6080 + 1.6081 + 1.6082 +M68KMAKE_OP(move, 32, pi, d) 1.6083 +{ 1.6084 + uint res = DY; 1.6085 + uint ea = EA_AX_PI_32(); 1.6086 + 1.6087 + m68ki_write_32(ea, res); 1.6088 + 1.6089 + FLAG_N = NFLAG_32(res); 1.6090 + FLAG_Z = res; 1.6091 + FLAG_V = VFLAG_CLEAR; 1.6092 + FLAG_C = CFLAG_CLEAR; 1.6093 +} 1.6094 + 1.6095 + 1.6096 +M68KMAKE_OP(move, 32, pi, a) 1.6097 +{ 1.6098 + uint res = AY; 1.6099 + uint ea = EA_AX_PI_32(); 1.6100 + 1.6101 + m68ki_write_32(ea, res); 1.6102 + 1.6103 + FLAG_N = NFLAG_32(res); 1.6104 + FLAG_Z = res; 1.6105 + FLAG_V = VFLAG_CLEAR; 1.6106 + FLAG_C = CFLAG_CLEAR; 1.6107 +} 1.6108 + 1.6109 + 1.6110 +M68KMAKE_OP(move, 32, pi, .) 1.6111 +{ 1.6112 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6113 + uint ea = EA_AX_PI_32(); 1.6114 + 1.6115 + m68ki_write_32(ea, res); 1.6116 + 1.6117 + FLAG_N = NFLAG_32(res); 1.6118 + FLAG_Z = res; 1.6119 + FLAG_V = VFLAG_CLEAR; 1.6120 + FLAG_C = CFLAG_CLEAR; 1.6121 +} 1.6122 + 1.6123 + 1.6124 +M68KMAKE_OP(move, 32, pd, d) 1.6125 +{ 1.6126 + uint res = DY; 1.6127 + uint ea = EA_AX_PD_32(); 1.6128 + 1.6129 + m68ki_write_32(ea, res); 1.6130 + 1.6131 + FLAG_N = NFLAG_32(res); 1.6132 + FLAG_Z = res; 1.6133 + FLAG_V = VFLAG_CLEAR; 1.6134 + FLAG_C = CFLAG_CLEAR; 1.6135 +} 1.6136 + 1.6137 + 1.6138 +M68KMAKE_OP(move, 32, pd, a) 1.6139 +{ 1.6140 + uint res = AY; 1.6141 + uint ea = EA_AX_PD_32(); 1.6142 + 1.6143 + m68ki_write_32(ea, res); 1.6144 + 1.6145 + FLAG_N = NFLAG_32(res); 1.6146 + FLAG_Z = res; 1.6147 + FLAG_V = VFLAG_CLEAR; 1.6148 + FLAG_C = CFLAG_CLEAR; 1.6149 +} 1.6150 + 1.6151 + 1.6152 +M68KMAKE_OP(move, 32, pd, .) 1.6153 +{ 1.6154 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6155 + uint ea = EA_AX_PD_32(); 1.6156 + 1.6157 + m68ki_write_32(ea, res); 1.6158 + 1.6159 + FLAG_N = NFLAG_32(res); 1.6160 + FLAG_Z = res; 1.6161 + FLAG_V = VFLAG_CLEAR; 1.6162 + FLAG_C = CFLAG_CLEAR; 1.6163 +} 1.6164 + 1.6165 + 1.6166 +M68KMAKE_OP(move, 32, di, d) 1.6167 +{ 1.6168 + uint res = DY; 1.6169 + uint ea = EA_AX_DI_32(); 1.6170 + 1.6171 + m68ki_write_32(ea, res); 1.6172 + 1.6173 + FLAG_N = NFLAG_32(res); 1.6174 + FLAG_Z = res; 1.6175 + FLAG_V = VFLAG_CLEAR; 1.6176 + FLAG_C = CFLAG_CLEAR; 1.6177 +} 1.6178 + 1.6179 + 1.6180 +M68KMAKE_OP(move, 32, di, a) 1.6181 +{ 1.6182 + uint res = AY; 1.6183 + uint ea = EA_AX_DI_32(); 1.6184 + 1.6185 + m68ki_write_32(ea, res); 1.6186 + 1.6187 + FLAG_N = NFLAG_32(res); 1.6188 + FLAG_Z = res; 1.6189 + FLAG_V = VFLAG_CLEAR; 1.6190 + FLAG_C = CFLAG_CLEAR; 1.6191 +} 1.6192 + 1.6193 + 1.6194 +M68KMAKE_OP(move, 32, di, .) 1.6195 +{ 1.6196 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6197 + uint ea = EA_AX_DI_32(); 1.6198 + 1.6199 + m68ki_write_32(ea, res); 1.6200 + 1.6201 + FLAG_N = NFLAG_32(res); 1.6202 + FLAG_Z = res; 1.6203 + FLAG_V = VFLAG_CLEAR; 1.6204 + FLAG_C = CFLAG_CLEAR; 1.6205 +} 1.6206 + 1.6207 + 1.6208 +M68KMAKE_OP(move, 32, ix, d) 1.6209 +{ 1.6210 + uint res = DY; 1.6211 + uint ea = EA_AX_IX_32(); 1.6212 + 1.6213 + m68ki_write_32(ea, res); 1.6214 + 1.6215 + FLAG_N = NFLAG_32(res); 1.6216 + FLAG_Z = res; 1.6217 + FLAG_V = VFLAG_CLEAR; 1.6218 + FLAG_C = CFLAG_CLEAR; 1.6219 +} 1.6220 + 1.6221 + 1.6222 +M68KMAKE_OP(move, 32, ix, a) 1.6223 +{ 1.6224 + uint res = AY; 1.6225 + uint ea = EA_AX_IX_32(); 1.6226 + 1.6227 + m68ki_write_32(ea, res); 1.6228 + 1.6229 + FLAG_N = NFLAG_32(res); 1.6230 + FLAG_Z = res; 1.6231 + FLAG_V = VFLAG_CLEAR; 1.6232 + FLAG_C = CFLAG_CLEAR; 1.6233 +} 1.6234 + 1.6235 + 1.6236 +M68KMAKE_OP(move, 32, ix, .) 1.6237 +{ 1.6238 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6239 + uint ea = EA_AX_IX_32(); 1.6240 + 1.6241 + m68ki_write_32(ea, res); 1.6242 + 1.6243 + FLAG_N = NFLAG_32(res); 1.6244 + FLAG_Z = res; 1.6245 + FLAG_V = VFLAG_CLEAR; 1.6246 + FLAG_C = CFLAG_CLEAR; 1.6247 +} 1.6248 + 1.6249 + 1.6250 +M68KMAKE_OP(move, 32, aw, d) 1.6251 +{ 1.6252 + uint res = DY; 1.6253 + uint ea = EA_AW_32(); 1.6254 + 1.6255 + m68ki_write_32(ea, res); 1.6256 + 1.6257 + FLAG_N = NFLAG_32(res); 1.6258 + FLAG_Z = res; 1.6259 + FLAG_V = VFLAG_CLEAR; 1.6260 + FLAG_C = CFLAG_CLEAR; 1.6261 +} 1.6262 + 1.6263 + 1.6264 +M68KMAKE_OP(move, 32, aw, a) 1.6265 +{ 1.6266 + uint res = AY; 1.6267 + uint ea = EA_AW_32(); 1.6268 + 1.6269 + m68ki_write_32(ea, res); 1.6270 + 1.6271 + FLAG_N = NFLAG_32(res); 1.6272 + FLAG_Z = res; 1.6273 + FLAG_V = VFLAG_CLEAR; 1.6274 + FLAG_C = CFLAG_CLEAR; 1.6275 +} 1.6276 + 1.6277 + 1.6278 +M68KMAKE_OP(move, 32, aw, .) 1.6279 +{ 1.6280 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6281 + uint ea = EA_AW_32(); 1.6282 + 1.6283 + m68ki_write_32(ea, res); 1.6284 + 1.6285 + FLAG_N = NFLAG_32(res); 1.6286 + FLAG_Z = res; 1.6287 + FLAG_V = VFLAG_CLEAR; 1.6288 + FLAG_C = CFLAG_CLEAR; 1.6289 +} 1.6290 + 1.6291 + 1.6292 +M68KMAKE_OP(move, 32, al, d) 1.6293 +{ 1.6294 + uint res = DY; 1.6295 + uint ea = EA_AL_32(); 1.6296 + 1.6297 + m68ki_write_32(ea, res); 1.6298 + 1.6299 + FLAG_N = NFLAG_32(res); 1.6300 + FLAG_Z = res; 1.6301 + FLAG_V = VFLAG_CLEAR; 1.6302 + FLAG_C = CFLAG_CLEAR; 1.6303 +} 1.6304 + 1.6305 + 1.6306 +M68KMAKE_OP(move, 32, al, a) 1.6307 +{ 1.6308 + uint res = AY; 1.6309 + uint ea = EA_AL_32(); 1.6310 + 1.6311 + m68ki_write_32(ea, res); 1.6312 + 1.6313 + FLAG_N = NFLAG_32(res); 1.6314 + FLAG_Z = res; 1.6315 + FLAG_V = VFLAG_CLEAR; 1.6316 + FLAG_C = CFLAG_CLEAR; 1.6317 +} 1.6318 + 1.6319 + 1.6320 +M68KMAKE_OP(move, 32, al, .) 1.6321 +{ 1.6322 + uint res = M68KMAKE_GET_OPER_AY_32; 1.6323 + uint ea = EA_AL_32(); 1.6324 + 1.6325 + m68ki_write_32(ea, res); 1.6326 + 1.6327 + FLAG_N = NFLAG_32(res); 1.6328 + FLAG_Z = res; 1.6329 + FLAG_V = VFLAG_CLEAR; 1.6330 + FLAG_C = CFLAG_CLEAR; 1.6331 +} 1.6332 + 1.6333 + 1.6334 +M68KMAKE_OP(movea, 16, ., d) 1.6335 +{ 1.6336 + AX = MAKE_INT_16(DY); 1.6337 +} 1.6338 + 1.6339 + 1.6340 +M68KMAKE_OP(movea, 16, ., a) 1.6341 +{ 1.6342 + AX = MAKE_INT_16(AY); 1.6343 +} 1.6344 + 1.6345 + 1.6346 +M68KMAKE_OP(movea, 16, ., .) 1.6347 +{ 1.6348 + AX = MAKE_INT_16(M68KMAKE_GET_OPER_AY_16); 1.6349 +} 1.6350 + 1.6351 + 1.6352 +M68KMAKE_OP(movea, 32, ., d) 1.6353 +{ 1.6354 + AX = DY; 1.6355 +} 1.6356 + 1.6357 + 1.6358 +M68KMAKE_OP(movea, 32, ., a) 1.6359 +{ 1.6360 + AX = AY; 1.6361 +} 1.6362 + 1.6363 + 1.6364 +M68KMAKE_OP(movea, 32, ., .) 1.6365 +{ 1.6366 + AX = M68KMAKE_GET_OPER_AY_32; 1.6367 +} 1.6368 + 1.6369 + 1.6370 +M68KMAKE_OP(move, 16, frc, d) 1.6371 +{ 1.6372 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.6373 + { 1.6374 + DY = MASK_OUT_BELOW_16(DY) | m68ki_get_ccr(); 1.6375 + return; 1.6376 + } 1.6377 + m68ki_exception_illegal(); 1.6378 +} 1.6379 + 1.6380 + 1.6381 +M68KMAKE_OP(move, 16, frc, .) 1.6382 +{ 1.6383 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.6384 + { 1.6385 + m68ki_write_16(M68KMAKE_GET_EA_AY_16, m68ki_get_ccr()); 1.6386 + return; 1.6387 + } 1.6388 + m68ki_exception_illegal(); 1.6389 +} 1.6390 + 1.6391 + 1.6392 +M68KMAKE_OP(move, 16, toc, d) 1.6393 +{ 1.6394 + m68ki_set_ccr(DY); 1.6395 +} 1.6396 + 1.6397 + 1.6398 +M68KMAKE_OP(move, 16, toc, .) 1.6399 +{ 1.6400 + m68ki_set_ccr(M68KMAKE_GET_OPER_AY_16); 1.6401 +} 1.6402 + 1.6403 + 1.6404 +M68KMAKE_OP(move, 16, frs, d) 1.6405 +{ 1.6406 + if(CPU_TYPE_IS_000(CPU_TYPE) || FLAG_S) /* NS990408 */ 1.6407 + { 1.6408 + DY = MASK_OUT_BELOW_16(DY) | m68ki_get_sr(); 1.6409 + return; 1.6410 + } 1.6411 + m68ki_exception_privilege_violation(); 1.6412 +} 1.6413 + 1.6414 + 1.6415 +M68KMAKE_OP(move, 16, frs, .) 1.6416 +{ 1.6417 + if(CPU_TYPE_IS_000(CPU_TYPE) || FLAG_S) /* NS990408 */ 1.6418 + { 1.6419 + uint ea = M68KMAKE_GET_EA_AY_16; 1.6420 + m68ki_write_16(ea, m68ki_get_sr()); 1.6421 + return; 1.6422 + } 1.6423 + m68ki_exception_privilege_violation(); 1.6424 +} 1.6425 + 1.6426 + 1.6427 +M68KMAKE_OP(move, 16, tos, d) 1.6428 +{ 1.6429 + if(FLAG_S) 1.6430 + { 1.6431 + m68ki_set_sr(DY); 1.6432 + return; 1.6433 + } 1.6434 + m68ki_exception_privilege_violation(); 1.6435 +} 1.6436 + 1.6437 + 1.6438 +M68KMAKE_OP(move, 16, tos, .) 1.6439 +{ 1.6440 + if(FLAG_S) 1.6441 + { 1.6442 + uint new_sr = M68KMAKE_GET_OPER_AY_16; 1.6443 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.6444 + m68ki_set_sr(new_sr); 1.6445 + return; 1.6446 + } 1.6447 + m68ki_exception_privilege_violation(); 1.6448 +} 1.6449 + 1.6450 + 1.6451 +M68KMAKE_OP(move, 32, fru, .) 1.6452 +{ 1.6453 + if(FLAG_S) 1.6454 + { 1.6455 + AY = REG_USP; 1.6456 + return; 1.6457 + } 1.6458 + m68ki_exception_privilege_violation(); 1.6459 +} 1.6460 + 1.6461 + 1.6462 +M68KMAKE_OP(move, 32, tou, .) 1.6463 +{ 1.6464 + if(FLAG_S) 1.6465 + { 1.6466 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.6467 + REG_USP = AY; 1.6468 + return; 1.6469 + } 1.6470 + m68ki_exception_privilege_violation(); 1.6471 +} 1.6472 + 1.6473 + 1.6474 +M68KMAKE_OP(movec, 32, cr, .) 1.6475 +{ 1.6476 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.6477 + { 1.6478 + if(FLAG_S) 1.6479 + { 1.6480 + uint word2 = OPER_I_16(); 1.6481 + 1.6482 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.6483 + switch (word2 & 0xfff) 1.6484 + { 1.6485 + case 0x000: /* SFC */ 1.6486 + REG_DA[(word2 >> 12) & 15] = REG_SFC; 1.6487 + return; 1.6488 + case 0x001: /* DFC */ 1.6489 + REG_DA[(word2 >> 12) & 15] = REG_DFC; 1.6490 + return; 1.6491 + case 0x002: /* CACR */ 1.6492 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6493 + { 1.6494 + REG_DA[(word2 >> 12) & 15] = REG_CACR; 1.6495 + return; 1.6496 + } 1.6497 + return; 1.6498 + case 0x800: /* USP */ 1.6499 + REG_DA[(word2 >> 12) & 15] = REG_USP; 1.6500 + return; 1.6501 + case 0x801: /* VBR */ 1.6502 + REG_DA[(word2 >> 12) & 15] = REG_VBR; 1.6503 + return; 1.6504 + case 0x802: /* CAAR */ 1.6505 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6506 + { 1.6507 + REG_DA[(word2 >> 12) & 15] = REG_CAAR; 1.6508 + return; 1.6509 + } 1.6510 + m68ki_exception_illegal(); 1.6511 + break; 1.6512 + case 0x803: /* MSP */ 1.6513 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6514 + { 1.6515 + REG_DA[(word2 >> 12) & 15] = FLAG_M ? REG_SP : REG_MSP; 1.6516 + return; 1.6517 + } 1.6518 + m68ki_exception_illegal(); 1.6519 + return; 1.6520 + case 0x804: /* ISP */ 1.6521 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6522 + { 1.6523 + REG_DA[(word2 >> 12) & 15] = FLAG_M ? REG_ISP : REG_SP; 1.6524 + return; 1.6525 + } 1.6526 + m68ki_exception_illegal(); 1.6527 + return; 1.6528 + default: 1.6529 + m68ki_exception_illegal(); 1.6530 + return; 1.6531 + } 1.6532 + } 1.6533 + m68ki_exception_privilege_violation(); 1.6534 + return; 1.6535 + } 1.6536 + m68ki_exception_illegal(); 1.6537 +} 1.6538 + 1.6539 + 1.6540 +M68KMAKE_OP(movec, 32, rc, .) 1.6541 +{ 1.6542 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.6543 + { 1.6544 + if(FLAG_S) 1.6545 + { 1.6546 + uint word2 = OPER_I_16(); 1.6547 + 1.6548 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.6549 + switch (word2 & 0xfff) 1.6550 + { 1.6551 + case 0x000: /* SFC */ 1.6552 + REG_SFC = REG_DA[(word2 >> 12) & 15] & 7; 1.6553 + return; 1.6554 + case 0x001: /* DFC */ 1.6555 + REG_DFC = REG_DA[(word2 >> 12) & 15] & 7; 1.6556 + return; 1.6557 + case 0x002: /* CACR */ 1.6558 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6559 + { 1.6560 + REG_CACR = REG_DA[(word2 >> 12) & 15]; 1.6561 + return; 1.6562 + } 1.6563 + m68ki_exception_illegal(); 1.6564 + return; 1.6565 + case 0x800: /* USP */ 1.6566 + REG_USP = REG_DA[(word2 >> 12) & 15]; 1.6567 + return; 1.6568 + case 0x801: /* VBR */ 1.6569 + REG_VBR = REG_DA[(word2 >> 12) & 15]; 1.6570 + return; 1.6571 + case 0x802: /* CAAR */ 1.6572 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6573 + { 1.6574 + REG_CAAR = REG_DA[(word2 >> 12) & 15]; 1.6575 + return; 1.6576 + } 1.6577 + m68ki_exception_illegal(); 1.6578 + return; 1.6579 + case 0x803: /* MSP */ 1.6580 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6581 + { 1.6582 + /* we are in supervisor mode so just check for M flag */ 1.6583 + if(!FLAG_M) 1.6584 + { 1.6585 + REG_MSP = REG_DA[(word2 >> 12) & 15]; 1.6586 + return; 1.6587 + } 1.6588 + REG_SP = REG_DA[(word2 >> 12) & 15]; 1.6589 + return; 1.6590 + } 1.6591 + m68ki_exception_illegal(); 1.6592 + return; 1.6593 + case 0x804: /* ISP */ 1.6594 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6595 + { 1.6596 + if(!FLAG_M) 1.6597 + { 1.6598 + REG_SP = REG_DA[(word2 >> 12) & 15]; 1.6599 + return; 1.6600 + } 1.6601 + REG_ISP = REG_DA[(word2 >> 12) & 15]; 1.6602 + return; 1.6603 + } 1.6604 + m68ki_exception_illegal(); 1.6605 + return; 1.6606 + default: 1.6607 + m68ki_exception_illegal(); 1.6608 + return; 1.6609 + } 1.6610 + } 1.6611 + m68ki_exception_privilege_violation(); 1.6612 + return; 1.6613 + } 1.6614 + m68ki_exception_illegal(); 1.6615 +} 1.6616 + 1.6617 + 1.6618 +M68KMAKE_OP(movem, 16, re, pd) 1.6619 +{ 1.6620 + uint i = 0; 1.6621 + uint register_list = OPER_I_16(); 1.6622 + uint ea = AY; 1.6623 + uint count = 0; 1.6624 + 1.6625 + for(; i < 16; i++) 1.6626 + if(register_list & (1 << i)) 1.6627 + { 1.6628 + ea -= 2; 1.6629 + m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[15-i])); 1.6630 + count++; 1.6631 + } 1.6632 + AY = ea; 1.6633 + 1.6634 + USE_CYCLES(count<<CYC_MOVEM_W); 1.6635 +} 1.6636 + 1.6637 + 1.6638 +M68KMAKE_OP(movem, 16, re, .) 1.6639 +{ 1.6640 + uint i = 0; 1.6641 + uint register_list = OPER_I_16(); 1.6642 + uint ea = M68KMAKE_GET_EA_AY_16; 1.6643 + uint count = 0; 1.6644 + 1.6645 + for(; i < 16; i++) 1.6646 + if(register_list & (1 << i)) 1.6647 + { 1.6648 + m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i])); 1.6649 + ea += 2; 1.6650 + count++; 1.6651 + } 1.6652 + 1.6653 + USE_CYCLES(count<<CYC_MOVEM_W); 1.6654 +} 1.6655 + 1.6656 + 1.6657 +M68KMAKE_OP(movem, 32, re, pd) 1.6658 +{ 1.6659 + uint i = 0; 1.6660 + uint register_list = OPER_I_16(); 1.6661 + uint ea = AY; 1.6662 + uint count = 0; 1.6663 + 1.6664 + for(; i < 16; i++) 1.6665 + if(register_list & (1 << i)) 1.6666 + { 1.6667 + ea -= 4; 1.6668 + m68ki_write_32(ea, REG_DA[15-i]); 1.6669 + count++; 1.6670 + } 1.6671 + AY = ea; 1.6672 + 1.6673 + USE_CYCLES(count<<CYC_MOVEM_L); 1.6674 +} 1.6675 + 1.6676 + 1.6677 +M68KMAKE_OP(movem, 32, re, .) 1.6678 +{ 1.6679 + uint i = 0; 1.6680 + uint register_list = OPER_I_16(); 1.6681 + uint ea = M68KMAKE_GET_EA_AY_32; 1.6682 + uint count = 0; 1.6683 + 1.6684 + for(; i < 16; i++) 1.6685 + if(register_list & (1 << i)) 1.6686 + { 1.6687 + m68ki_write_32(ea, REG_DA[i]); 1.6688 + ea += 4; 1.6689 + count++; 1.6690 + } 1.6691 + 1.6692 + USE_CYCLES(count<<CYC_MOVEM_L); 1.6693 +} 1.6694 + 1.6695 + 1.6696 +M68KMAKE_OP(movem, 16, er, pi) 1.6697 +{ 1.6698 + uint i = 0; 1.6699 + uint register_list = OPER_I_16(); 1.6700 + uint ea = AY; 1.6701 + uint count = 0; 1.6702 + 1.6703 + for(; i < 16; i++) 1.6704 + if(register_list & (1 << i)) 1.6705 + { 1.6706 + REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea))); 1.6707 + ea += 2; 1.6708 + count++; 1.6709 + } 1.6710 + AY = ea; 1.6711 + 1.6712 + USE_CYCLES(count<<CYC_MOVEM_W); 1.6713 +} 1.6714 + 1.6715 + 1.6716 +M68KMAKE_OP(movem, 16, er, .) 1.6717 +{ 1.6718 + uint i = 0; 1.6719 + uint register_list = OPER_I_16(); 1.6720 + uint ea = M68KMAKE_GET_EA_AY_16; 1.6721 + uint count = 0; 1.6722 + 1.6723 + for(; i < 16; i++) 1.6724 + if(register_list & (1 << i)) 1.6725 + { 1.6726 + REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea))); 1.6727 + ea += 2; 1.6728 + count++; 1.6729 + } 1.6730 + 1.6731 + USE_CYCLES(count<<CYC_MOVEM_W); 1.6732 +} 1.6733 + 1.6734 + 1.6735 +M68KMAKE_OP(movem, 32, er, pi) 1.6736 +{ 1.6737 + uint i = 0; 1.6738 + uint register_list = OPER_I_16(); 1.6739 + uint ea = AY; 1.6740 + uint count = 0; 1.6741 + 1.6742 + for(; i < 16; i++) 1.6743 + if(register_list & (1 << i)) 1.6744 + { 1.6745 + REG_DA[i] = m68ki_read_32(ea); 1.6746 + ea += 4; 1.6747 + count++; 1.6748 + } 1.6749 + AY = ea; 1.6750 + 1.6751 + USE_CYCLES(count<<CYC_MOVEM_L); 1.6752 +} 1.6753 + 1.6754 + 1.6755 +M68KMAKE_OP(movem, 32, er, .) 1.6756 +{ 1.6757 + uint i = 0; 1.6758 + uint register_list = OPER_I_16(); 1.6759 + uint ea = M68KMAKE_GET_EA_AY_32; 1.6760 + uint count = 0; 1.6761 + 1.6762 + for(; i < 16; i++) 1.6763 + if(register_list & (1 << i)) 1.6764 + { 1.6765 + REG_DA[i] = m68ki_read_32(ea); 1.6766 + ea += 4; 1.6767 + count++; 1.6768 + } 1.6769 + 1.6770 + USE_CYCLES(count<<CYC_MOVEM_L); 1.6771 +} 1.6772 + 1.6773 + 1.6774 +M68KMAKE_OP(movep, 16, re, .) 1.6775 +{ 1.6776 + uint ea = EA_AY_DI_16(); 1.6777 + uint src = DX; 1.6778 + 1.6779 + m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 8)); 1.6780 + m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src)); 1.6781 +} 1.6782 + 1.6783 + 1.6784 +M68KMAKE_OP(movep, 32, re, .) 1.6785 +{ 1.6786 + uint ea = EA_AY_DI_32(); 1.6787 + uint src = DX; 1.6788 + 1.6789 + m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 24)); 1.6790 + m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 16)); 1.6791 + m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 8)); 1.6792 + m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src)); 1.6793 +} 1.6794 + 1.6795 + 1.6796 +M68KMAKE_OP(movep, 16, er, .) 1.6797 +{ 1.6798 + uint ea = EA_AY_DI_16(); 1.6799 + uint* r_dst = &DX; 1.6800 + 1.6801 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | ((m68ki_read_8(ea) << 8) + m68ki_read_8(ea + 2)); 1.6802 +} 1.6803 + 1.6804 + 1.6805 +M68KMAKE_OP(movep, 32, er, .) 1.6806 +{ 1.6807 + uint ea = EA_AY_DI_32(); 1.6808 + 1.6809 + DX = (m68ki_read_8(ea) << 24) + (m68ki_read_8(ea + 2) << 16) 1.6810 + + (m68ki_read_8(ea + 4) << 8) + m68ki_read_8(ea + 6); 1.6811 +} 1.6812 + 1.6813 + 1.6814 +M68KMAKE_OP(moves, 8, ., .) 1.6815 +{ 1.6816 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.6817 + { 1.6818 + if(FLAG_S) 1.6819 + { 1.6820 + uint word2 = OPER_I_16(); 1.6821 + uint ea = M68KMAKE_GET_EA_AY_8; 1.6822 + 1.6823 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.6824 + if(BIT_B(word2)) /* Register to memory */ 1.6825 + { 1.6826 + m68ki_write_8_fc(ea, REG_DFC, MASK_OUT_ABOVE_8(REG_DA[(word2 >> 12) & 15])); 1.6827 + return; 1.6828 + } 1.6829 + if(BIT_F(word2)) /* Memory to address register */ 1.6830 + { 1.6831 + REG_A[(word2 >> 12) & 7] = MAKE_INT_8(m68ki_read_8_fc(ea, REG_SFC)); 1.6832 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.6833 + USE_CYCLES(2); 1.6834 + return; 1.6835 + } 1.6836 + /* Memory to data register */ 1.6837 + REG_D[(word2 >> 12) & 7] = MASK_OUT_BELOW_8(REG_D[(word2 >> 12) & 7]) | m68ki_read_8_fc(ea, REG_SFC); 1.6838 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.6839 + USE_CYCLES(2); 1.6840 + return; 1.6841 + } 1.6842 + m68ki_exception_privilege_violation(); 1.6843 + return; 1.6844 + } 1.6845 + m68ki_exception_illegal(); 1.6846 +} 1.6847 + 1.6848 + 1.6849 +M68KMAKE_OP(moves, 16, ., .) 1.6850 +{ 1.6851 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.6852 + { 1.6853 + if(FLAG_S) 1.6854 + { 1.6855 + uint word2 = OPER_I_16(); 1.6856 + uint ea = M68KMAKE_GET_EA_AY_16; 1.6857 + 1.6858 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.6859 + if(BIT_B(word2)) /* Register to memory */ 1.6860 + { 1.6861 + m68ki_write_16_fc(ea, REG_DFC, MASK_OUT_ABOVE_16(REG_DA[(word2 >> 12) & 15])); 1.6862 + return; 1.6863 + } 1.6864 + if(BIT_F(word2)) /* Memory to address register */ 1.6865 + { 1.6866 + REG_A[(word2 >> 12) & 7] = MAKE_INT_16(m68ki_read_16_fc(ea, REG_SFC)); 1.6867 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.6868 + USE_CYCLES(2); 1.6869 + return; 1.6870 + } 1.6871 + /* Memory to data register */ 1.6872 + REG_D[(word2 >> 12) & 7] = MASK_OUT_BELOW_16(REG_D[(word2 >> 12) & 7]) | m68ki_read_16_fc(ea, REG_SFC); 1.6873 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.6874 + USE_CYCLES(2); 1.6875 + return; 1.6876 + } 1.6877 + m68ki_exception_privilege_violation(); 1.6878 + return; 1.6879 + } 1.6880 + m68ki_exception_illegal(); 1.6881 +} 1.6882 + 1.6883 + 1.6884 +M68KMAKE_OP(moves, 32, ., .) 1.6885 +{ 1.6886 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.6887 + { 1.6888 + if(FLAG_S) 1.6889 + { 1.6890 + uint word2 = OPER_I_16(); 1.6891 + uint ea = M68KMAKE_GET_EA_AY_32; 1.6892 + 1.6893 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.6894 + if(BIT_B(word2)) /* Register to memory */ 1.6895 + { 1.6896 + m68ki_write_32_fc(ea, REG_DFC, REG_DA[(word2 >> 12) & 15]); 1.6897 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.6898 + USE_CYCLES(2); 1.6899 + return; 1.6900 + } 1.6901 + /* Memory to register */ 1.6902 + REG_DA[(word2 >> 12) & 15] = m68ki_read_32_fc(ea, REG_SFC); 1.6903 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.6904 + USE_CYCLES(2); 1.6905 + return; 1.6906 + } 1.6907 + m68ki_exception_privilege_violation(); 1.6908 + return; 1.6909 + } 1.6910 + m68ki_exception_illegal(); 1.6911 +} 1.6912 + 1.6913 + 1.6914 +M68KMAKE_OP(moveq, 32, ., .) 1.6915 +{ 1.6916 + uint res = DX = MAKE_INT_8(MASK_OUT_ABOVE_8(REG_IR)); 1.6917 + 1.6918 + FLAG_N = NFLAG_32(res); 1.6919 + FLAG_Z = res; 1.6920 + FLAG_V = VFLAG_CLEAR; 1.6921 + FLAG_C = CFLAG_CLEAR; 1.6922 +} 1.6923 + 1.6924 + 1.6925 +M68KMAKE_OP(muls, 16, ., d) 1.6926 +{ 1.6927 + uint* r_dst = &DX; 1.6928 + uint res = MASK_OUT_ABOVE_32(MAKE_INT_16(DY) * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst))); 1.6929 + 1.6930 + *r_dst = res; 1.6931 + 1.6932 + FLAG_Z = res; 1.6933 + FLAG_N = NFLAG_32(res); 1.6934 + FLAG_V = VFLAG_CLEAR; 1.6935 + FLAG_C = CFLAG_CLEAR; 1.6936 +} 1.6937 + 1.6938 + 1.6939 +M68KMAKE_OP(muls, 16, ., .) 1.6940 +{ 1.6941 + uint* r_dst = &DX; 1.6942 + uint res = MASK_OUT_ABOVE_32(MAKE_INT_16(M68KMAKE_GET_OPER_AY_16) * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst))); 1.6943 + 1.6944 + *r_dst = res; 1.6945 + 1.6946 + FLAG_Z = res; 1.6947 + FLAG_N = NFLAG_32(res); 1.6948 + FLAG_V = VFLAG_CLEAR; 1.6949 + FLAG_C = CFLAG_CLEAR; 1.6950 +} 1.6951 + 1.6952 + 1.6953 +M68KMAKE_OP(mulu, 16, ., d) 1.6954 +{ 1.6955 + uint* r_dst = &DX; 1.6956 + uint res = MASK_OUT_ABOVE_16(DY) * MASK_OUT_ABOVE_16(*r_dst); 1.6957 + 1.6958 + *r_dst = res; 1.6959 + 1.6960 + FLAG_Z = res; 1.6961 + FLAG_N = NFLAG_32(res); 1.6962 + FLAG_V = VFLAG_CLEAR; 1.6963 + FLAG_C = CFLAG_CLEAR; 1.6964 +} 1.6965 + 1.6966 + 1.6967 +M68KMAKE_OP(mulu, 16, ., .) 1.6968 +{ 1.6969 + uint* r_dst = &DX; 1.6970 + uint res = M68KMAKE_GET_OPER_AY_16 * MASK_OUT_ABOVE_16(*r_dst); 1.6971 + 1.6972 + *r_dst = res; 1.6973 + 1.6974 + FLAG_Z = res; 1.6975 + FLAG_N = NFLAG_32(res); 1.6976 + FLAG_V = VFLAG_CLEAR; 1.6977 + FLAG_C = CFLAG_CLEAR; 1.6978 +} 1.6979 + 1.6980 + 1.6981 +M68KMAKE_OP(mull, 32, ., d) 1.6982 +{ 1.6983 +#if M68K_USE_64_BIT 1.6984 + 1.6985 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.6986 + { 1.6987 + uint word2 = OPER_I_16(); 1.6988 + uint64 src = DY; 1.6989 + uint64 dst = REG_D[(word2 >> 12) & 7]; 1.6990 + uint64 res; 1.6991 + 1.6992 + FLAG_C = CFLAG_CLEAR; 1.6993 + 1.6994 + if(BIT_B(word2)) /* signed */ 1.6995 + { 1.6996 + res = (sint64)((sint32)src) * (sint64)((sint32)dst); 1.6997 + if(!BIT_A(word2)) 1.6998 + { 1.6999 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.7000 + FLAG_N = NFLAG_32(res); 1.7001 + FLAG_V = ((sint64)res != (sint32)res)<<7; 1.7002 + REG_D[(word2 >> 12) & 7] = FLAG_Z; 1.7003 + return; 1.7004 + } 1.7005 + FLAG_Z = MASK_OUT_ABOVE_32(res) | (res>>32); 1.7006 + FLAG_N = NFLAG_64(res); 1.7007 + FLAG_V = VFLAG_CLEAR; 1.7008 + REG_D[word2 & 7] = (res >> 32); 1.7009 + REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(res); 1.7010 + return; 1.7011 + } 1.7012 + 1.7013 + res = src * dst; 1.7014 + if(!BIT_A(word2)) 1.7015 + { 1.7016 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.7017 + FLAG_N = NFLAG_32(res); 1.7018 + FLAG_V = (res > 0xffffffff)<<7; 1.7019 + REG_D[(word2 >> 12) & 7] = FLAG_Z; 1.7020 + return; 1.7021 + } 1.7022 + FLAG_Z = MASK_OUT_ABOVE_32(res) | (res>>32); 1.7023 + FLAG_N = NFLAG_64(res); 1.7024 + FLAG_V = VFLAG_CLEAR; 1.7025 + REG_D[word2 & 7] = (res >> 32); 1.7026 + REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(res); 1.7027 + return; 1.7028 + } 1.7029 + m68ki_exception_illegal(); 1.7030 + 1.7031 +#else 1.7032 + 1.7033 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7034 + { 1.7035 + uint word2 = OPER_I_16(); 1.7036 + uint src = DY; 1.7037 + uint dst = REG_D[(word2 >> 12) & 7]; 1.7038 + uint neg = GET_MSB_32(src ^ dst); 1.7039 + uint src1; 1.7040 + uint src2; 1.7041 + uint dst1; 1.7042 + uint dst2; 1.7043 + uint r1; 1.7044 + uint r2; 1.7045 + uint r3; 1.7046 + uint r4; 1.7047 + uint lo; 1.7048 + uint hi; 1.7049 + 1.7050 + FLAG_C = CFLAG_CLEAR; 1.7051 + 1.7052 + if(BIT_B(word2)) /* signed */ 1.7053 + { 1.7054 + if(GET_MSB_32(src)) 1.7055 + src = (uint)MASK_OUT_ABOVE_32(-(sint)src); 1.7056 + if(GET_MSB_32(dst)) 1.7057 + dst = (uint)MASK_OUT_ABOVE_32(-(sint)dst); 1.7058 + } 1.7059 + 1.7060 + src1 = MASK_OUT_ABOVE_16(src); 1.7061 + src2 = src>>16; 1.7062 + dst1 = MASK_OUT_ABOVE_16(dst); 1.7063 + dst2 = dst>>16; 1.7064 + 1.7065 + 1.7066 + r1 = src1 * dst1; 1.7067 + r2 = src1 * dst2; 1.7068 + r3 = src2 * dst1; 1.7069 + r4 = src2 * dst2; 1.7070 + 1.7071 + lo = r1 + (MASK_OUT_ABOVE_16(r2)<<16) + (MASK_OUT_ABOVE_16(r3)<<16); 1.7072 + hi = r4 + (r2>>16) + (r3>>16) + (((r1>>16) + MASK_OUT_ABOVE_16(r2) + MASK_OUT_ABOVE_16(r3)) >> 16); 1.7073 + 1.7074 + if(BIT_B(word2) && neg) 1.7075 + { 1.7076 + hi = (uint)MASK_OUT_ABOVE_32((-(sint)hi) - (lo != 0)); 1.7077 + lo = (uint)MASK_OUT_ABOVE_32(-(sint)lo); 1.7078 + } 1.7079 + 1.7080 + if(BIT_A(word2)) 1.7081 + { 1.7082 + REG_D[word2 & 7] = hi; 1.7083 + REG_D[(word2 >> 12) & 7] = lo; 1.7084 + FLAG_N = NFLAG_32(hi); 1.7085 + FLAG_Z = hi | lo; 1.7086 + FLAG_V = VFLAG_CLEAR; 1.7087 + return; 1.7088 + } 1.7089 + 1.7090 + REG_D[(word2 >> 12) & 7] = lo; 1.7091 + FLAG_N = NFLAG_32(lo); 1.7092 + FLAG_Z = lo; 1.7093 + if(BIT_B(word2)) 1.7094 + FLAG_V = (!((GET_MSB_32(lo) && hi == 0xffffffff) || (!GET_MSB_32(lo) && !hi)))<<7; 1.7095 + else 1.7096 + FLAG_V = (hi != 0) << 7; 1.7097 + return; 1.7098 + } 1.7099 + m68ki_exception_illegal(); 1.7100 + 1.7101 +#endif 1.7102 +} 1.7103 + 1.7104 + 1.7105 +M68KMAKE_OP(mull, 32, ., .) 1.7106 +{ 1.7107 +#if M68K_USE_64_BIT 1.7108 + 1.7109 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7110 + { 1.7111 + uint word2 = OPER_I_16(); 1.7112 + uint64 src = M68KMAKE_GET_OPER_AY_32; 1.7113 + uint64 dst = REG_D[(word2 >> 12) & 7]; 1.7114 + uint64 res; 1.7115 + 1.7116 + FLAG_C = CFLAG_CLEAR; 1.7117 + 1.7118 + if(BIT_B(word2)) /* signed */ 1.7119 + { 1.7120 + res = (sint64)((sint32)src) * (sint64)((sint32)dst); 1.7121 + if(!BIT_A(word2)) 1.7122 + { 1.7123 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.7124 + FLAG_N = NFLAG_32(res); 1.7125 + FLAG_V = ((sint64)res != (sint32)res)<<7; 1.7126 + REG_D[(word2 >> 12) & 7] = FLAG_Z; 1.7127 + return; 1.7128 + } 1.7129 + FLAG_Z = MASK_OUT_ABOVE_32(res) | (res>>32); 1.7130 + FLAG_N = NFLAG_64(res); 1.7131 + FLAG_V = VFLAG_CLEAR; 1.7132 + REG_D[word2 & 7] = (res >> 32); 1.7133 + REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(res); 1.7134 + return; 1.7135 + } 1.7136 + 1.7137 + res = src * dst; 1.7138 + if(!BIT_A(word2)) 1.7139 + { 1.7140 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.7141 + FLAG_N = NFLAG_32(res); 1.7142 + FLAG_V = (res > 0xffffffff)<<7; 1.7143 + REG_D[(word2 >> 12) & 7] = FLAG_Z; 1.7144 + return; 1.7145 + } 1.7146 + FLAG_Z = MASK_OUT_ABOVE_32(res) | (res>>32); 1.7147 + FLAG_N = NFLAG_64(res); 1.7148 + FLAG_V = VFLAG_CLEAR; 1.7149 + REG_D[word2 & 7] = (res >> 32); 1.7150 + REG_D[(word2 >> 12) & 7] = MASK_OUT_ABOVE_32(res); 1.7151 + return; 1.7152 + } 1.7153 + m68ki_exception_illegal(); 1.7154 + 1.7155 +#else 1.7156 + 1.7157 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7158 + { 1.7159 + uint word2 = OPER_I_16(); 1.7160 + uint src = M68KMAKE_GET_OPER_AY_32; 1.7161 + uint dst = REG_D[(word2 >> 12) & 7]; 1.7162 + uint neg = GET_MSB_32(src ^ dst); 1.7163 + uint src1; 1.7164 + uint src2; 1.7165 + uint dst1; 1.7166 + uint dst2; 1.7167 + uint r1; 1.7168 + uint r2; 1.7169 + uint r3; 1.7170 + uint r4; 1.7171 + uint lo; 1.7172 + uint hi; 1.7173 + 1.7174 + FLAG_C = CFLAG_CLEAR; 1.7175 + 1.7176 + if(BIT_B(word2)) /* signed */ 1.7177 + { 1.7178 + if(GET_MSB_32(src)) 1.7179 + src = (uint)MASK_OUT_ABOVE_32(-(sint)src); 1.7180 + if(GET_MSB_32(dst)) 1.7181 + dst = (uint)MASK_OUT_ABOVE_32(-(sint)dst); 1.7182 + } 1.7183 + 1.7184 + src1 = MASK_OUT_ABOVE_16(src); 1.7185 + src2 = src>>16; 1.7186 + dst1 = MASK_OUT_ABOVE_16(dst); 1.7187 + dst2 = dst>>16; 1.7188 + 1.7189 + 1.7190 + r1 = src1 * dst1; 1.7191 + r2 = src1 * dst2; 1.7192 + r3 = src2 * dst1; 1.7193 + r4 = src2 * dst2; 1.7194 + 1.7195 + lo = r1 + (MASK_OUT_ABOVE_16(r2)<<16) + (MASK_OUT_ABOVE_16(r3)<<16); 1.7196 + hi = r4 + (r2>>16) + (r3>>16) + (((r1>>16) + MASK_OUT_ABOVE_16(r2) + MASK_OUT_ABOVE_16(r3)) >> 16); 1.7197 + 1.7198 + if(BIT_B(word2) && neg) 1.7199 + { 1.7200 + hi = (uint)MASK_OUT_ABOVE_32((-(sint)hi) - (lo != 0)); 1.7201 + lo = (uint)MASK_OUT_ABOVE_32(-(sint)lo); 1.7202 + } 1.7203 + 1.7204 + if(BIT_A(word2)) 1.7205 + { 1.7206 + REG_D[word2 & 7] = hi; 1.7207 + REG_D[(word2 >> 12) & 7] = lo; 1.7208 + FLAG_N = NFLAG_32(hi); 1.7209 + FLAG_Z = hi | lo; 1.7210 + FLAG_V = VFLAG_CLEAR; 1.7211 + return; 1.7212 + } 1.7213 + 1.7214 + REG_D[(word2 >> 12) & 7] = lo; 1.7215 + FLAG_N = NFLAG_32(lo); 1.7216 + FLAG_Z = lo; 1.7217 + if(BIT_B(word2)) 1.7218 + FLAG_V = (!((GET_MSB_32(lo) && hi == 0xffffffff) || (!GET_MSB_32(lo) && !hi)))<<7; 1.7219 + else 1.7220 + FLAG_V = (hi != 0) << 7; 1.7221 + return; 1.7222 + } 1.7223 + m68ki_exception_illegal(); 1.7224 + 1.7225 +#endif 1.7226 +} 1.7227 + 1.7228 + 1.7229 +M68KMAKE_OP(nbcd, 8, ., d) 1.7230 +{ 1.7231 + uint* r_dst = &DY; 1.7232 + uint dst = *r_dst; 1.7233 + uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1()); 1.7234 + 1.7235 + if(res != 0x9a) 1.7236 + { 1.7237 + if((res & 0x0f) == 0xa) 1.7238 + res = (res & 0xf0) + 0x10; 1.7239 + 1.7240 + res = MASK_OUT_ABOVE_8(res); 1.7241 + 1.7242 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.7243 + 1.7244 + FLAG_Z |= res; 1.7245 + FLAG_C = CFLAG_SET; 1.7246 + FLAG_X = XFLAG_SET; 1.7247 + } 1.7248 + else 1.7249 + { 1.7250 + FLAG_C = CFLAG_CLEAR; 1.7251 + FLAG_X = XFLAG_CLEAR; 1.7252 + } 1.7253 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.7254 +} 1.7255 + 1.7256 + 1.7257 +M68KMAKE_OP(nbcd, 8, ., .) 1.7258 +{ 1.7259 + uint ea = M68KMAKE_GET_EA_AY_8; 1.7260 + uint dst = m68ki_read_8(ea); 1.7261 + uint res = MASK_OUT_ABOVE_8(0x9a - dst - XFLAG_AS_1()); 1.7262 + 1.7263 + if(res != 0x9a) 1.7264 + { 1.7265 + if((res & 0x0f) == 0xa) 1.7266 + res = (res & 0xf0) + 0x10; 1.7267 + 1.7268 + res = MASK_OUT_ABOVE_8(res); 1.7269 + 1.7270 + m68ki_write_8(ea, MASK_OUT_ABOVE_8(res)); 1.7271 + 1.7272 + FLAG_Z |= res; 1.7273 + FLAG_C = CFLAG_SET; 1.7274 + FLAG_X = XFLAG_SET; 1.7275 + } 1.7276 + else 1.7277 + { 1.7278 + FLAG_C = CFLAG_CLEAR; 1.7279 + FLAG_X = XFLAG_CLEAR; 1.7280 + } 1.7281 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.7282 +} 1.7283 + 1.7284 + 1.7285 +M68KMAKE_OP(neg, 8, ., d) 1.7286 +{ 1.7287 + uint* r_dst = &DY; 1.7288 + uint res = 0 - MASK_OUT_ABOVE_8(*r_dst); 1.7289 + 1.7290 + FLAG_N = NFLAG_8(res); 1.7291 + FLAG_C = FLAG_X = CFLAG_8(res); 1.7292 + FLAG_V = *r_dst & res; 1.7293 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.7294 + 1.7295 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.7296 +} 1.7297 + 1.7298 + 1.7299 +M68KMAKE_OP(neg, 8, ., .) 1.7300 +{ 1.7301 + uint ea = M68KMAKE_GET_EA_AY_8; 1.7302 + uint src = m68ki_read_8(ea); 1.7303 + uint res = 0 - src; 1.7304 + 1.7305 + FLAG_N = NFLAG_8(res); 1.7306 + FLAG_C = FLAG_X = CFLAG_8(res); 1.7307 + FLAG_V = src & res; 1.7308 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.7309 + 1.7310 + m68ki_write_8(ea, FLAG_Z); 1.7311 +} 1.7312 + 1.7313 + 1.7314 +M68KMAKE_OP(neg, 16, ., d) 1.7315 +{ 1.7316 + uint* r_dst = &DY; 1.7317 + uint res = 0 - MASK_OUT_ABOVE_16(*r_dst); 1.7318 + 1.7319 + FLAG_N = NFLAG_16(res); 1.7320 + FLAG_C = FLAG_X = CFLAG_16(res); 1.7321 + FLAG_V = (*r_dst & res)>>8; 1.7322 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.7323 + 1.7324 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.7325 +} 1.7326 + 1.7327 + 1.7328 +M68KMAKE_OP(neg, 16, ., .) 1.7329 +{ 1.7330 + uint ea = M68KMAKE_GET_EA_AY_16; 1.7331 + uint src = m68ki_read_16(ea); 1.7332 + uint res = 0 - src; 1.7333 + 1.7334 + FLAG_N = NFLAG_16(res); 1.7335 + FLAG_C = FLAG_X = CFLAG_16(res); 1.7336 + FLAG_V = (src & res)>>8; 1.7337 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.7338 + 1.7339 + m68ki_write_16(ea, FLAG_Z); 1.7340 +} 1.7341 + 1.7342 + 1.7343 +M68KMAKE_OP(neg, 32, ., d) 1.7344 +{ 1.7345 + uint* r_dst = &DY; 1.7346 + uint res = 0 - *r_dst; 1.7347 + 1.7348 + FLAG_N = NFLAG_32(res); 1.7349 + FLAG_C = FLAG_X = CFLAG_SUB_32(*r_dst, 0, res); 1.7350 + FLAG_V = (*r_dst & res)>>24; 1.7351 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.7352 + 1.7353 + *r_dst = FLAG_Z; 1.7354 +} 1.7355 + 1.7356 + 1.7357 +M68KMAKE_OP(neg, 32, ., .) 1.7358 +{ 1.7359 + uint ea = M68KMAKE_GET_EA_AY_32; 1.7360 + uint src = m68ki_read_32(ea); 1.7361 + uint res = 0 - src; 1.7362 + 1.7363 + FLAG_N = NFLAG_32(res); 1.7364 + FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res); 1.7365 + FLAG_V = (src & res)>>24; 1.7366 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.7367 + 1.7368 + m68ki_write_32(ea, FLAG_Z); 1.7369 +} 1.7370 + 1.7371 + 1.7372 +M68KMAKE_OP(negx, 8, ., d) 1.7373 +{ 1.7374 + uint* r_dst = &DY; 1.7375 + uint res = 0 - MASK_OUT_ABOVE_8(*r_dst) - XFLAG_AS_1(); 1.7376 + 1.7377 + FLAG_N = NFLAG_8(res); 1.7378 + FLAG_X = FLAG_C = CFLAG_8(res); 1.7379 + FLAG_V = *r_dst & res; 1.7380 + 1.7381 + res = MASK_OUT_ABOVE_8(res); 1.7382 + FLAG_Z |= res; 1.7383 + 1.7384 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.7385 +} 1.7386 + 1.7387 + 1.7388 +M68KMAKE_OP(negx, 8, ., .) 1.7389 +{ 1.7390 + uint ea = M68KMAKE_GET_EA_AY_8; 1.7391 + uint src = m68ki_read_8(ea); 1.7392 + uint res = 0 - src - XFLAG_AS_1(); 1.7393 + 1.7394 + FLAG_N = NFLAG_8(res); 1.7395 + FLAG_X = FLAG_C = CFLAG_8(res); 1.7396 + FLAG_V = src & res; 1.7397 + 1.7398 + res = MASK_OUT_ABOVE_8(res); 1.7399 + FLAG_Z |= res; 1.7400 + 1.7401 + m68ki_write_8(ea, res); 1.7402 +} 1.7403 + 1.7404 + 1.7405 +M68KMAKE_OP(negx, 16, ., d) 1.7406 +{ 1.7407 + uint* r_dst = &DY; 1.7408 + uint res = 0 - MASK_OUT_ABOVE_16(*r_dst) - XFLAG_AS_1(); 1.7409 + 1.7410 + FLAG_N = NFLAG_16(res); 1.7411 + FLAG_X = FLAG_C = CFLAG_16(res); 1.7412 + FLAG_V = (*r_dst & res)>>8; 1.7413 + 1.7414 + res = MASK_OUT_ABOVE_16(res); 1.7415 + FLAG_Z |= res; 1.7416 + 1.7417 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.7418 +} 1.7419 + 1.7420 + 1.7421 +M68KMAKE_OP(negx, 16, ., .) 1.7422 +{ 1.7423 + uint ea = M68KMAKE_GET_EA_AY_16; 1.7424 + uint src = m68ki_read_16(ea); 1.7425 + uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1(); 1.7426 + 1.7427 + FLAG_N = NFLAG_16(res); 1.7428 + FLAG_X = FLAG_C = CFLAG_16(res); 1.7429 + FLAG_V = (src & res)>>8; 1.7430 + 1.7431 + res = MASK_OUT_ABOVE_16(res); 1.7432 + FLAG_Z |= res; 1.7433 + 1.7434 + m68ki_write_16(ea, res); 1.7435 +} 1.7436 + 1.7437 + 1.7438 +M68KMAKE_OP(negx, 32, ., d) 1.7439 +{ 1.7440 + uint* r_dst = &DY; 1.7441 + uint res = 0 - MASK_OUT_ABOVE_32(*r_dst) - XFLAG_AS_1(); 1.7442 + 1.7443 + FLAG_N = NFLAG_32(res); 1.7444 + FLAG_X = FLAG_C = CFLAG_SUB_32(*r_dst, 0, res); 1.7445 + FLAG_V = (*r_dst & res)>>24; 1.7446 + 1.7447 + res = MASK_OUT_ABOVE_32(res); 1.7448 + FLAG_Z |= res; 1.7449 + 1.7450 + *r_dst = res; 1.7451 +} 1.7452 + 1.7453 + 1.7454 +M68KMAKE_OP(negx, 32, ., .) 1.7455 +{ 1.7456 + uint ea = M68KMAKE_GET_EA_AY_32; 1.7457 + uint src = m68ki_read_32(ea); 1.7458 + uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1(); 1.7459 + 1.7460 + FLAG_N = NFLAG_32(res); 1.7461 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res); 1.7462 + FLAG_V = (src & res)>>24; 1.7463 + 1.7464 + res = MASK_OUT_ABOVE_32(res); 1.7465 + FLAG_Z |= res; 1.7466 + 1.7467 + m68ki_write_32(ea, res); 1.7468 +} 1.7469 + 1.7470 + 1.7471 +M68KMAKE_OP(nop, 0, ., .) 1.7472 +{ 1.7473 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.7474 +} 1.7475 + 1.7476 + 1.7477 +M68KMAKE_OP(not, 8, ., d) 1.7478 +{ 1.7479 + uint* r_dst = &DY; 1.7480 + uint res = MASK_OUT_ABOVE_8(~*r_dst); 1.7481 + 1.7482 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.7483 + 1.7484 + FLAG_N = NFLAG_8(res); 1.7485 + FLAG_Z = res; 1.7486 + FLAG_C = CFLAG_CLEAR; 1.7487 + FLAG_V = VFLAG_CLEAR; 1.7488 +} 1.7489 + 1.7490 + 1.7491 +M68KMAKE_OP(not, 8, ., .) 1.7492 +{ 1.7493 + uint ea = M68KMAKE_GET_EA_AY_8; 1.7494 + uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea)); 1.7495 + 1.7496 + m68ki_write_8(ea, res); 1.7497 + 1.7498 + FLAG_N = NFLAG_8(res); 1.7499 + FLAG_Z = res; 1.7500 + FLAG_C = CFLAG_CLEAR; 1.7501 + FLAG_V = VFLAG_CLEAR; 1.7502 +} 1.7503 + 1.7504 + 1.7505 +M68KMAKE_OP(not, 16, ., d) 1.7506 +{ 1.7507 + uint* r_dst = &DY; 1.7508 + uint res = MASK_OUT_ABOVE_16(~*r_dst); 1.7509 + 1.7510 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.7511 + 1.7512 + FLAG_N = NFLAG_16(res); 1.7513 + FLAG_Z = res; 1.7514 + FLAG_C = CFLAG_CLEAR; 1.7515 + FLAG_V = VFLAG_CLEAR; 1.7516 +} 1.7517 + 1.7518 + 1.7519 +M68KMAKE_OP(not, 16, ., .) 1.7520 +{ 1.7521 + uint ea = M68KMAKE_GET_EA_AY_16; 1.7522 + uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea)); 1.7523 + 1.7524 + m68ki_write_16(ea, res); 1.7525 + 1.7526 + FLAG_N = NFLAG_16(res); 1.7527 + FLAG_Z = res; 1.7528 + FLAG_C = CFLAG_CLEAR; 1.7529 + FLAG_V = VFLAG_CLEAR; 1.7530 +} 1.7531 + 1.7532 + 1.7533 +M68KMAKE_OP(not, 32, ., d) 1.7534 +{ 1.7535 + uint* r_dst = &DY; 1.7536 + uint res = *r_dst = MASK_OUT_ABOVE_32(~*r_dst); 1.7537 + 1.7538 + FLAG_N = NFLAG_32(res); 1.7539 + FLAG_Z = res; 1.7540 + FLAG_C = CFLAG_CLEAR; 1.7541 + FLAG_V = VFLAG_CLEAR; 1.7542 +} 1.7543 + 1.7544 + 1.7545 +M68KMAKE_OP(not, 32, ., .) 1.7546 +{ 1.7547 + uint ea = M68KMAKE_GET_EA_AY_32; 1.7548 + uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea)); 1.7549 + 1.7550 + m68ki_write_32(ea, res); 1.7551 + 1.7552 + FLAG_N = NFLAG_32(res); 1.7553 + FLAG_Z = res; 1.7554 + FLAG_C = CFLAG_CLEAR; 1.7555 + FLAG_V = VFLAG_CLEAR; 1.7556 +} 1.7557 + 1.7558 + 1.7559 +M68KMAKE_OP(or, 8, er, d) 1.7560 +{ 1.7561 + uint res = MASK_OUT_ABOVE_8((DX |= MASK_OUT_ABOVE_8(DY))); 1.7562 + 1.7563 + FLAG_N = NFLAG_8(res); 1.7564 + FLAG_Z = res; 1.7565 + FLAG_C = CFLAG_CLEAR; 1.7566 + FLAG_V = VFLAG_CLEAR; 1.7567 +} 1.7568 + 1.7569 + 1.7570 +M68KMAKE_OP(or, 8, er, .) 1.7571 +{ 1.7572 + uint res = MASK_OUT_ABOVE_8((DX |= M68KMAKE_GET_OPER_AY_8)); 1.7573 + 1.7574 + FLAG_N = NFLAG_8(res); 1.7575 + FLAG_Z = res; 1.7576 + FLAG_C = CFLAG_CLEAR; 1.7577 + FLAG_V = VFLAG_CLEAR; 1.7578 +} 1.7579 + 1.7580 + 1.7581 +M68KMAKE_OP(or, 16, er, d) 1.7582 +{ 1.7583 + uint res = MASK_OUT_ABOVE_16((DX |= MASK_OUT_ABOVE_16(DY))); 1.7584 + 1.7585 + FLAG_N = NFLAG_16(res); 1.7586 + FLAG_Z = res; 1.7587 + FLAG_C = CFLAG_CLEAR; 1.7588 + FLAG_V = VFLAG_CLEAR; 1.7589 +} 1.7590 + 1.7591 + 1.7592 +M68KMAKE_OP(or, 16, er, .) 1.7593 +{ 1.7594 + uint res = MASK_OUT_ABOVE_16((DX |= M68KMAKE_GET_OPER_AY_16)); 1.7595 + 1.7596 + FLAG_N = NFLAG_16(res); 1.7597 + FLAG_Z = res; 1.7598 + FLAG_C = CFLAG_CLEAR; 1.7599 + FLAG_V = VFLAG_CLEAR; 1.7600 +} 1.7601 + 1.7602 + 1.7603 +M68KMAKE_OP(or, 32, er, d) 1.7604 +{ 1.7605 + uint res = DX |= DY; 1.7606 + 1.7607 + FLAG_N = NFLAG_32(res); 1.7608 + FLAG_Z = res; 1.7609 + FLAG_C = CFLAG_CLEAR; 1.7610 + FLAG_V = VFLAG_CLEAR; 1.7611 +} 1.7612 + 1.7613 + 1.7614 +M68KMAKE_OP(or, 32, er, .) 1.7615 +{ 1.7616 + uint res = DX |= M68KMAKE_GET_OPER_AY_32; 1.7617 + 1.7618 + FLAG_N = NFLAG_32(res); 1.7619 + FLAG_Z = res; 1.7620 + FLAG_C = CFLAG_CLEAR; 1.7621 + FLAG_V = VFLAG_CLEAR; 1.7622 +} 1.7623 + 1.7624 + 1.7625 +M68KMAKE_OP(or, 8, re, .) 1.7626 +{ 1.7627 + uint ea = M68KMAKE_GET_EA_AY_8; 1.7628 + uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea)); 1.7629 + 1.7630 + m68ki_write_8(ea, res); 1.7631 + 1.7632 + FLAG_N = NFLAG_8(res); 1.7633 + FLAG_Z = res; 1.7634 + FLAG_C = CFLAG_CLEAR; 1.7635 + FLAG_V = VFLAG_CLEAR; 1.7636 +} 1.7637 + 1.7638 + 1.7639 +M68KMAKE_OP(or, 16, re, .) 1.7640 +{ 1.7641 + uint ea = M68KMAKE_GET_EA_AY_16; 1.7642 + uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea)); 1.7643 + 1.7644 + m68ki_write_16(ea, res); 1.7645 + 1.7646 + FLAG_N = NFLAG_16(res); 1.7647 + FLAG_Z = res; 1.7648 + FLAG_C = CFLAG_CLEAR; 1.7649 + FLAG_V = VFLAG_CLEAR; 1.7650 +} 1.7651 + 1.7652 + 1.7653 +M68KMAKE_OP(or, 32, re, .) 1.7654 +{ 1.7655 + uint ea = M68KMAKE_GET_EA_AY_32; 1.7656 + uint res = DX | m68ki_read_32(ea); 1.7657 + 1.7658 + m68ki_write_32(ea, res); 1.7659 + 1.7660 + FLAG_N = NFLAG_32(res); 1.7661 + FLAG_Z = res; 1.7662 + FLAG_C = CFLAG_CLEAR; 1.7663 + FLAG_V = VFLAG_CLEAR; 1.7664 +} 1.7665 + 1.7666 + 1.7667 +M68KMAKE_OP(ori, 8, ., d) 1.7668 +{ 1.7669 + uint res = MASK_OUT_ABOVE_8((DY |= OPER_I_8())); 1.7670 + 1.7671 + FLAG_N = NFLAG_8(res); 1.7672 + FLAG_Z = res; 1.7673 + FLAG_C = CFLAG_CLEAR; 1.7674 + FLAG_V = VFLAG_CLEAR; 1.7675 +} 1.7676 + 1.7677 + 1.7678 +M68KMAKE_OP(ori, 8, ., .) 1.7679 +{ 1.7680 + uint src = OPER_I_8(); 1.7681 + uint ea = M68KMAKE_GET_EA_AY_8; 1.7682 + uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea)); 1.7683 + 1.7684 + m68ki_write_8(ea, res); 1.7685 + 1.7686 + FLAG_N = NFLAG_8(res); 1.7687 + FLAG_Z = res; 1.7688 + FLAG_C = CFLAG_CLEAR; 1.7689 + FLAG_V = VFLAG_CLEAR; 1.7690 +} 1.7691 + 1.7692 + 1.7693 +M68KMAKE_OP(ori, 16, ., d) 1.7694 +{ 1.7695 + uint res = MASK_OUT_ABOVE_16(DY |= OPER_I_16()); 1.7696 + 1.7697 + FLAG_N = NFLAG_16(res); 1.7698 + FLAG_Z = res; 1.7699 + FLAG_C = CFLAG_CLEAR; 1.7700 + FLAG_V = VFLAG_CLEAR; 1.7701 +} 1.7702 + 1.7703 + 1.7704 +M68KMAKE_OP(ori, 16, ., .) 1.7705 +{ 1.7706 + uint src = OPER_I_16(); 1.7707 + uint ea = M68KMAKE_GET_EA_AY_16; 1.7708 + uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea)); 1.7709 + 1.7710 + m68ki_write_16(ea, res); 1.7711 + 1.7712 + FLAG_N = NFLAG_16(res); 1.7713 + FLAG_Z = res; 1.7714 + FLAG_C = CFLAG_CLEAR; 1.7715 + FLAG_V = VFLAG_CLEAR; 1.7716 +} 1.7717 + 1.7718 + 1.7719 +M68KMAKE_OP(ori, 32, ., d) 1.7720 +{ 1.7721 + uint res = DY |= OPER_I_32(); 1.7722 + 1.7723 + FLAG_N = NFLAG_32(res); 1.7724 + FLAG_Z = res; 1.7725 + FLAG_C = CFLAG_CLEAR; 1.7726 + FLAG_V = VFLAG_CLEAR; 1.7727 +} 1.7728 + 1.7729 + 1.7730 +M68KMAKE_OP(ori, 32, ., .) 1.7731 +{ 1.7732 + uint src = OPER_I_32(); 1.7733 + uint ea = M68KMAKE_GET_EA_AY_32; 1.7734 + uint res = src | m68ki_read_32(ea); 1.7735 + 1.7736 + m68ki_write_32(ea, res); 1.7737 + 1.7738 + FLAG_N = NFLAG_32(res); 1.7739 + FLAG_Z = res; 1.7740 + FLAG_C = CFLAG_CLEAR; 1.7741 + FLAG_V = VFLAG_CLEAR; 1.7742 +} 1.7743 + 1.7744 + 1.7745 +M68KMAKE_OP(ori, 16, toc, .) 1.7746 +{ 1.7747 + m68ki_set_ccr(m68ki_get_ccr() | OPER_I_16()); 1.7748 +} 1.7749 + 1.7750 + 1.7751 +M68KMAKE_OP(ori, 16, tos, .) 1.7752 +{ 1.7753 + if(FLAG_S) 1.7754 + { 1.7755 + uint src = OPER_I_16(); 1.7756 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.7757 + m68ki_set_sr(m68ki_get_sr() | src); 1.7758 + return; 1.7759 + } 1.7760 + m68ki_exception_privilege_violation(); 1.7761 +} 1.7762 + 1.7763 + 1.7764 +M68KMAKE_OP(pack, 16, rr, .) 1.7765 +{ 1.7766 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7767 + { 1.7768 + /* Note: DX and DY are reversed in Motorola's docs */ 1.7769 + uint src = DY + OPER_I_16(); 1.7770 + uint* r_dst = &DX; 1.7771 + 1.7772 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | ((src >> 4) & 0x00f0) | (src & 0x000f); 1.7773 + return; 1.7774 + } 1.7775 + m68ki_exception_illegal(); 1.7776 +} 1.7777 + 1.7778 + 1.7779 +M68KMAKE_OP(pack, 16, mm, ax7) 1.7780 +{ 1.7781 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7782 + { 1.7783 + /* Note: AX and AY are reversed in Motorola's docs */ 1.7784 + uint ea_src = EA_AY_PD_8(); 1.7785 + uint src = m68ki_read_8(ea_src); 1.7786 + ea_src = EA_AY_PD_8(); 1.7787 + src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16(); 1.7788 + 1.7789 + m68ki_write_8(EA_A7_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f)); 1.7790 + return; 1.7791 + } 1.7792 + m68ki_exception_illegal(); 1.7793 +} 1.7794 + 1.7795 + 1.7796 +M68KMAKE_OP(pack, 16, mm, ay7) 1.7797 +{ 1.7798 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7799 + { 1.7800 + /* Note: AX and AY are reversed in Motorola's docs */ 1.7801 + uint ea_src = EA_A7_PD_8(); 1.7802 + uint src = m68ki_read_8(ea_src); 1.7803 + ea_src = EA_A7_PD_8(); 1.7804 + src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16(); 1.7805 + 1.7806 + m68ki_write_8(EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f)); 1.7807 + return; 1.7808 + } 1.7809 + m68ki_exception_illegal(); 1.7810 +} 1.7811 + 1.7812 + 1.7813 +M68KMAKE_OP(pack, 16, mm, axy7) 1.7814 +{ 1.7815 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7816 + { 1.7817 + uint ea_src = EA_A7_PD_8(); 1.7818 + uint src = m68ki_read_8(ea_src); 1.7819 + ea_src = EA_A7_PD_8(); 1.7820 + src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16(); 1.7821 + 1.7822 + m68ki_write_8(EA_A7_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f)); 1.7823 + return; 1.7824 + } 1.7825 + m68ki_exception_illegal(); 1.7826 +} 1.7827 + 1.7828 + 1.7829 +M68KMAKE_OP(pack, 16, mm, .) 1.7830 +{ 1.7831 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.7832 + { 1.7833 + /* Note: AX and AY are reversed in Motorola's docs */ 1.7834 + uint ea_src = EA_AY_PD_8(); 1.7835 + uint src = m68ki_read_8(ea_src); 1.7836 + ea_src = EA_AY_PD_8(); 1.7837 + src = ((src << 8) | m68ki_read_8(ea_src)) + OPER_I_16(); 1.7838 + 1.7839 + m68ki_write_8(EA_AX_PD_8(), ((src >> 4) & 0x00f0) | (src & 0x000f)); 1.7840 + return; 1.7841 + } 1.7842 + m68ki_exception_illegal(); 1.7843 +} 1.7844 + 1.7845 + 1.7846 +M68KMAKE_OP(pea, 32, ., .) 1.7847 +{ 1.7848 + uint ea = M68KMAKE_GET_EA_AY_32; 1.7849 + 1.7850 + m68ki_push_32(ea); 1.7851 +} 1.7852 + 1.7853 + 1.7854 +M68KMAKE_OP(reset, 0, ., .) 1.7855 +{ 1.7856 + if(FLAG_S) 1.7857 + { 1.7858 + m68ki_output_reset(); /* auto-disable (see m68kcpu.h) */ 1.7859 + USE_CYCLES(CYC_RESET); 1.7860 + return; 1.7861 + } 1.7862 + m68ki_exception_privilege_violation(); 1.7863 +} 1.7864 + 1.7865 + 1.7866 +M68KMAKE_OP(ror, 8, s, .) 1.7867 +{ 1.7868 + uint* r_dst = &DY; 1.7869 + uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.7870 + uint shift = orig_shift & 7; 1.7871 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.7872 + uint res = ROR_8(src, shift); 1.7873 + 1.7874 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.7875 + 1.7876 + FLAG_N = NFLAG_8(res); 1.7877 + FLAG_Z = res; 1.7878 + FLAG_C = src << (9-orig_shift); 1.7879 + FLAG_V = VFLAG_CLEAR; 1.7880 +} 1.7881 + 1.7882 + 1.7883 +M68KMAKE_OP(ror, 16, s, .) 1.7884 +{ 1.7885 + uint* r_dst = &DY; 1.7886 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.7887 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.7888 + uint res = ROR_16(src, shift); 1.7889 + 1.7890 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.7891 + 1.7892 + FLAG_N = NFLAG_16(res); 1.7893 + FLAG_Z = res; 1.7894 + FLAG_C = src << (9-shift); 1.7895 + FLAG_V = VFLAG_CLEAR; 1.7896 +} 1.7897 + 1.7898 + 1.7899 +M68KMAKE_OP(ror, 32, s, .) 1.7900 +{ 1.7901 + uint* r_dst = &DY; 1.7902 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.7903 + uint64 src = *r_dst; 1.7904 + uint res = ROR_32(src, shift); 1.7905 + 1.7906 + *r_dst = res; 1.7907 + 1.7908 + FLAG_N = NFLAG_32(res); 1.7909 + FLAG_Z = res; 1.7910 + FLAG_C = src << (9-shift); 1.7911 + FLAG_V = VFLAG_CLEAR; 1.7912 +} 1.7913 + 1.7914 + 1.7915 +M68KMAKE_OP(ror, 8, r, .) 1.7916 +{ 1.7917 + uint* r_dst = &DY; 1.7918 + uint orig_shift = DX & 0x3f; 1.7919 + uint shift = orig_shift & 7; 1.7920 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.7921 + uint res = ROR_8(src, shift); 1.7922 + 1.7923 + if(orig_shift != 0) 1.7924 + { 1.7925 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.7926 + 1.7927 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.7928 + FLAG_C = src << (8-((shift-1)&7)); 1.7929 + FLAG_N = NFLAG_8(res); 1.7930 + FLAG_Z = res; 1.7931 + FLAG_V = VFLAG_CLEAR; 1.7932 + return; 1.7933 + } 1.7934 + 1.7935 + FLAG_C = CFLAG_CLEAR; 1.7936 + FLAG_N = NFLAG_8(src); 1.7937 + FLAG_Z = src; 1.7938 + FLAG_V = VFLAG_CLEAR; 1.7939 +} 1.7940 + 1.7941 + 1.7942 +M68KMAKE_OP(ror, 16, r, .) 1.7943 +{ 1.7944 + uint* r_dst = &DY; 1.7945 + uint orig_shift = DX & 0x3f; 1.7946 + uint shift = orig_shift & 15; 1.7947 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.7948 + uint res = ROR_16(src, shift); 1.7949 + 1.7950 + if(orig_shift != 0) 1.7951 + { 1.7952 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.7953 + 1.7954 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.7955 + FLAG_C = (src >> ((shift - 1) & 15)) << 8; 1.7956 + FLAG_N = NFLAG_16(res); 1.7957 + FLAG_Z = res; 1.7958 + FLAG_V = VFLAG_CLEAR; 1.7959 + return; 1.7960 + } 1.7961 + 1.7962 + FLAG_C = CFLAG_CLEAR; 1.7963 + FLAG_N = NFLAG_16(src); 1.7964 + FLAG_Z = src; 1.7965 + FLAG_V = VFLAG_CLEAR; 1.7966 +} 1.7967 + 1.7968 + 1.7969 +M68KMAKE_OP(ror, 32, r, .) 1.7970 +{ 1.7971 + uint* r_dst = &DY; 1.7972 + uint orig_shift = DX & 0x3f; 1.7973 + uint shift = orig_shift & 31; 1.7974 + uint64 src = *r_dst; 1.7975 + uint res = ROR_32(src, shift); 1.7976 + 1.7977 + if(orig_shift != 0) 1.7978 + { 1.7979 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.7980 + 1.7981 + *r_dst = res; 1.7982 + FLAG_C = (src >> ((shift - 1) & 31)) << 8; 1.7983 + FLAG_N = NFLAG_32(res); 1.7984 + FLAG_Z = res; 1.7985 + FLAG_V = VFLAG_CLEAR; 1.7986 + return; 1.7987 + } 1.7988 + 1.7989 + FLAG_C = CFLAG_CLEAR; 1.7990 + FLAG_N = NFLAG_32(src); 1.7991 + FLAG_Z = src; 1.7992 + FLAG_V = VFLAG_CLEAR; 1.7993 +} 1.7994 + 1.7995 + 1.7996 +M68KMAKE_OP(ror, 16, ., .) 1.7997 +{ 1.7998 + uint ea = M68KMAKE_GET_EA_AY_16; 1.7999 + uint src = m68ki_read_16(ea); 1.8000 + uint res = ROR_16(src, 1); 1.8001 + 1.8002 + m68ki_write_16(ea, res); 1.8003 + 1.8004 + FLAG_N = NFLAG_16(res); 1.8005 + FLAG_Z = res; 1.8006 + FLAG_C = src << 8; 1.8007 + FLAG_V = VFLAG_CLEAR; 1.8008 +} 1.8009 + 1.8010 + 1.8011 +M68KMAKE_OP(rol, 8, s, .) 1.8012 +{ 1.8013 + uint* r_dst = &DY; 1.8014 + uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8015 + uint shift = orig_shift & 7; 1.8016 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.8017 + uint res = ROL_8(src, shift); 1.8018 + 1.8019 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.8020 + 1.8021 + FLAG_N = NFLAG_8(res); 1.8022 + FLAG_Z = res; 1.8023 + FLAG_C = src << orig_shift; 1.8024 + FLAG_V = VFLAG_CLEAR; 1.8025 +} 1.8026 + 1.8027 + 1.8028 +M68KMAKE_OP(rol, 16, s, .) 1.8029 +{ 1.8030 + uint* r_dst = &DY; 1.8031 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8032 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.8033 + uint res = ROL_16(src, shift); 1.8034 + 1.8035 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.8036 + 1.8037 + FLAG_N = NFLAG_16(res); 1.8038 + FLAG_Z = res; 1.8039 + FLAG_C = src >> (8-shift); 1.8040 + FLAG_V = VFLAG_CLEAR; 1.8041 +} 1.8042 + 1.8043 + 1.8044 +M68KMAKE_OP(rol, 32, s, .) 1.8045 +{ 1.8046 + uint* r_dst = &DY; 1.8047 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8048 + uint64 src = *r_dst; 1.8049 + uint res = ROL_32(src, shift); 1.8050 + 1.8051 + *r_dst = res; 1.8052 + 1.8053 + FLAG_N = NFLAG_32(res); 1.8054 + FLAG_Z = res; 1.8055 + FLAG_C = src >> (24-shift); 1.8056 + FLAG_V = VFLAG_CLEAR; 1.8057 +} 1.8058 + 1.8059 + 1.8060 +M68KMAKE_OP(rol, 8, r, .) 1.8061 +{ 1.8062 + uint* r_dst = &DY; 1.8063 + uint orig_shift = DX & 0x3f; 1.8064 + uint shift = orig_shift & 7; 1.8065 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.8066 + uint res = ROL_8(src, shift); 1.8067 + 1.8068 + if(orig_shift != 0) 1.8069 + { 1.8070 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8071 + 1.8072 + if(shift != 0) 1.8073 + { 1.8074 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.8075 + FLAG_C = src << shift; 1.8076 + FLAG_N = NFLAG_8(res); 1.8077 + FLAG_Z = res; 1.8078 + FLAG_V = VFLAG_CLEAR; 1.8079 + return; 1.8080 + } 1.8081 + FLAG_C = (src & 1)<<8; 1.8082 + FLAG_N = NFLAG_8(src); 1.8083 + FLAG_Z = src; 1.8084 + FLAG_V = VFLAG_CLEAR; 1.8085 + return; 1.8086 + } 1.8087 + 1.8088 + FLAG_C = CFLAG_CLEAR; 1.8089 + FLAG_N = NFLAG_8(src); 1.8090 + FLAG_Z = src; 1.8091 + FLAG_V = VFLAG_CLEAR; 1.8092 +} 1.8093 + 1.8094 + 1.8095 +M68KMAKE_OP(rol, 16, r, .) 1.8096 +{ 1.8097 + uint* r_dst = &DY; 1.8098 + uint orig_shift = DX & 0x3f; 1.8099 + uint shift = orig_shift & 15; 1.8100 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.8101 + uint res = MASK_OUT_ABOVE_16(ROL_16(src, shift)); 1.8102 + 1.8103 + if(orig_shift != 0) 1.8104 + { 1.8105 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8106 + 1.8107 + if(shift != 0) 1.8108 + { 1.8109 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.8110 + FLAG_C = (src << shift) >> 8; 1.8111 + FLAG_N = NFLAG_16(res); 1.8112 + FLAG_Z = res; 1.8113 + FLAG_V = VFLAG_CLEAR; 1.8114 + return; 1.8115 + } 1.8116 + FLAG_C = (src & 1)<<8; 1.8117 + FLAG_N = NFLAG_16(src); 1.8118 + FLAG_Z = src; 1.8119 + FLAG_V = VFLAG_CLEAR; 1.8120 + return; 1.8121 + } 1.8122 + 1.8123 + FLAG_C = CFLAG_CLEAR; 1.8124 + FLAG_N = NFLAG_16(src); 1.8125 + FLAG_Z = src; 1.8126 + FLAG_V = VFLAG_CLEAR; 1.8127 +} 1.8128 + 1.8129 + 1.8130 +M68KMAKE_OP(rol, 32, r, .) 1.8131 +{ 1.8132 + uint* r_dst = &DY; 1.8133 + uint orig_shift = DX & 0x3f; 1.8134 + uint shift = orig_shift & 31; 1.8135 + uint64 src = *r_dst; 1.8136 + uint res = ROL_32(src, shift); 1.8137 + 1.8138 + if(orig_shift != 0) 1.8139 + { 1.8140 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8141 + 1.8142 + *r_dst = res; 1.8143 + 1.8144 + FLAG_C = (src >> (32 - shift)) << 8; 1.8145 + FLAG_N = NFLAG_32(res); 1.8146 + FLAG_Z = res; 1.8147 + FLAG_V = VFLAG_CLEAR; 1.8148 + return; 1.8149 + } 1.8150 + 1.8151 + FLAG_C = CFLAG_CLEAR; 1.8152 + FLAG_N = NFLAG_32(src); 1.8153 + FLAG_Z = src; 1.8154 + FLAG_V = VFLAG_CLEAR; 1.8155 +} 1.8156 + 1.8157 + 1.8158 +M68KMAKE_OP(rol, 16, ., .) 1.8159 +{ 1.8160 + uint ea = M68KMAKE_GET_EA_AY_16; 1.8161 + uint src = m68ki_read_16(ea); 1.8162 + uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1)); 1.8163 + 1.8164 + m68ki_write_16(ea, res); 1.8165 + 1.8166 + FLAG_N = NFLAG_16(res); 1.8167 + FLAG_Z = res; 1.8168 + FLAG_C = src >> 7; 1.8169 + FLAG_V = VFLAG_CLEAR; 1.8170 +} 1.8171 + 1.8172 + 1.8173 +M68KMAKE_OP(roxr, 8, s, .) 1.8174 +{ 1.8175 + uint* r_dst = &DY; 1.8176 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8177 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.8178 + uint res = ROR_9(src | (XFLAG_AS_1() << 8), shift); 1.8179 + 1.8180 + FLAG_C = FLAG_X = res; 1.8181 + res = MASK_OUT_ABOVE_8(res); 1.8182 + 1.8183 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.8184 + 1.8185 + FLAG_N = NFLAG_8(res); 1.8186 + FLAG_Z = res; 1.8187 + FLAG_V = VFLAG_CLEAR; 1.8188 +} 1.8189 + 1.8190 + 1.8191 +M68KMAKE_OP(roxr, 16, s, .) 1.8192 +{ 1.8193 + uint* r_dst = &DY; 1.8194 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8195 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.8196 + uint res = ROR_17(src | (XFLAG_AS_1() << 16), shift); 1.8197 + 1.8198 + FLAG_C = FLAG_X = res >> 8; 1.8199 + res = MASK_OUT_ABOVE_16(res); 1.8200 + 1.8201 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.8202 + 1.8203 + FLAG_N = NFLAG_16(res); 1.8204 + FLAG_Z = res; 1.8205 + FLAG_V = VFLAG_CLEAR; 1.8206 +} 1.8207 + 1.8208 + 1.8209 +M68KMAKE_OP(roxr, 32, s, .) 1.8210 +{ 1.8211 +#if M68K_USE_64_BIT 1.8212 + 1.8213 + uint* r_dst = &DY; 1.8214 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8215 + uint64 src = *r_dst; 1.8216 + uint64 res = src | (((uint64)XFLAG_AS_1()) << 32); 1.8217 + 1.8218 + res = ROR_33_64(res, shift); 1.8219 + 1.8220 + FLAG_C = FLAG_X = res >> 24; 1.8221 + res = MASK_OUT_ABOVE_32(res); 1.8222 + 1.8223 + *r_dst = res; 1.8224 + 1.8225 + FLAG_N = NFLAG_32(res); 1.8226 + FLAG_Z = res; 1.8227 + FLAG_V = VFLAG_CLEAR; 1.8228 + 1.8229 +#else 1.8230 + 1.8231 + uint* r_dst = &DY; 1.8232 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8233 + uint src = *r_dst; 1.8234 + uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift))); 1.8235 + uint new_x_flag = src & (1 << (shift - 1)); 1.8236 + 1.8237 + *r_dst = res; 1.8238 + 1.8239 + FLAG_C = FLAG_X = (new_x_flag != 0)<<8; 1.8240 + FLAG_N = NFLAG_32(res); 1.8241 + FLAG_Z = res; 1.8242 + FLAG_V = VFLAG_CLEAR; 1.8243 + 1.8244 +#endif 1.8245 +} 1.8246 + 1.8247 + 1.8248 +M68KMAKE_OP(roxr, 8, r, .) 1.8249 +{ 1.8250 + uint* r_dst = &DY; 1.8251 + uint orig_shift = DX & 0x3f; 1.8252 + 1.8253 + if(orig_shift != 0) 1.8254 + { 1.8255 + uint shift = orig_shift % 9; 1.8256 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.8257 + uint res = ROR_9(src | (XFLAG_AS_1() << 8), shift); 1.8258 + 1.8259 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8260 + 1.8261 + FLAG_C = FLAG_X = res; 1.8262 + res = MASK_OUT_ABOVE_8(res); 1.8263 + 1.8264 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.8265 + FLAG_N = NFLAG_8(res); 1.8266 + FLAG_Z = res; 1.8267 + FLAG_V = VFLAG_CLEAR; 1.8268 + return; 1.8269 + } 1.8270 + 1.8271 + FLAG_C = FLAG_X; 1.8272 + FLAG_N = NFLAG_8(*r_dst); 1.8273 + FLAG_Z = MASK_OUT_ABOVE_8(*r_dst); 1.8274 + FLAG_V = VFLAG_CLEAR; 1.8275 +} 1.8276 + 1.8277 + 1.8278 +M68KMAKE_OP(roxr, 16, r, .) 1.8279 +{ 1.8280 + uint* r_dst = &DY; 1.8281 + uint orig_shift = DX & 0x3f; 1.8282 + 1.8283 + if(orig_shift != 0) 1.8284 + { 1.8285 + uint shift = orig_shift % 17; 1.8286 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.8287 + uint res = ROR_17(src | (XFLAG_AS_1() << 16), shift); 1.8288 + 1.8289 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8290 + 1.8291 + FLAG_C = FLAG_X = res >> 8; 1.8292 + res = MASK_OUT_ABOVE_16(res); 1.8293 + 1.8294 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.8295 + FLAG_N = NFLAG_16(res); 1.8296 + FLAG_Z = res; 1.8297 + FLAG_V = VFLAG_CLEAR; 1.8298 + return; 1.8299 + } 1.8300 + 1.8301 + FLAG_C = FLAG_X; 1.8302 + FLAG_N = NFLAG_16(*r_dst); 1.8303 + FLAG_Z = MASK_OUT_ABOVE_16(*r_dst); 1.8304 + FLAG_V = VFLAG_CLEAR; 1.8305 +} 1.8306 + 1.8307 + 1.8308 +M68KMAKE_OP(roxr, 32, r, .) 1.8309 +{ 1.8310 +#if M68K_USE_64_BIT 1.8311 + 1.8312 + uint* r_dst = &DY; 1.8313 + uint orig_shift = DX & 0x3f; 1.8314 + 1.8315 + if(orig_shift != 0) 1.8316 + { 1.8317 + uint shift = orig_shift % 33; 1.8318 + uint64 src = *r_dst; 1.8319 + uint64 res = src | (((uint64)XFLAG_AS_1()) << 32); 1.8320 + 1.8321 + res = ROR_33_64(res, shift); 1.8322 + 1.8323 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8324 + 1.8325 + FLAG_C = FLAG_X = res >> 24; 1.8326 + res = MASK_OUT_ABOVE_32(res); 1.8327 + 1.8328 + *r_dst = res; 1.8329 + FLAG_N = NFLAG_32(res); 1.8330 + FLAG_Z = res; 1.8331 + FLAG_V = VFLAG_CLEAR; 1.8332 + return; 1.8333 + } 1.8334 + 1.8335 + FLAG_C = FLAG_X; 1.8336 + FLAG_N = NFLAG_32(*r_dst); 1.8337 + FLAG_Z = *r_dst; 1.8338 + FLAG_V = VFLAG_CLEAR; 1.8339 + 1.8340 +#else 1.8341 + 1.8342 + uint* r_dst = &DY; 1.8343 + uint orig_shift = DX & 0x3f; 1.8344 + uint shift = orig_shift % 33; 1.8345 + uint src = *r_dst; 1.8346 + uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift))); 1.8347 + uint new_x_flag = src & (1 << (shift - 1)); 1.8348 + 1.8349 + if(orig_shift != 0) 1.8350 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8351 + 1.8352 + if(shift != 0) 1.8353 + { 1.8354 + *r_dst = res; 1.8355 + FLAG_X = (new_x_flag != 0)<<8; 1.8356 + } 1.8357 + else 1.8358 + res = src; 1.8359 + FLAG_C = FLAG_X; 1.8360 + FLAG_N = NFLAG_32(res); 1.8361 + FLAG_Z = res; 1.8362 + FLAG_V = VFLAG_CLEAR; 1.8363 + 1.8364 +#endif 1.8365 +} 1.8366 + 1.8367 + 1.8368 +M68KMAKE_OP(roxr, 16, ., .) 1.8369 +{ 1.8370 + uint ea = M68KMAKE_GET_EA_AY_16; 1.8371 + uint src = m68ki_read_16(ea); 1.8372 + uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1); 1.8373 + 1.8374 + FLAG_C = FLAG_X = res >> 8; 1.8375 + res = MASK_OUT_ABOVE_16(res); 1.8376 + 1.8377 + m68ki_write_16(ea, res); 1.8378 + 1.8379 + FLAG_N = NFLAG_16(res); 1.8380 + FLAG_Z = res; 1.8381 + FLAG_V = VFLAG_CLEAR; 1.8382 +} 1.8383 + 1.8384 + 1.8385 +M68KMAKE_OP(roxl, 8, s, .) 1.8386 +{ 1.8387 + uint* r_dst = &DY; 1.8388 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8389 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.8390 + uint res = ROL_9(src | (XFLAG_AS_1() << 8), shift); 1.8391 + 1.8392 + FLAG_C = FLAG_X = res; 1.8393 + res = MASK_OUT_ABOVE_8(res); 1.8394 + 1.8395 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.8396 + 1.8397 + FLAG_N = NFLAG_8(res); 1.8398 + FLAG_Z = res; 1.8399 + FLAG_V = VFLAG_CLEAR; 1.8400 +} 1.8401 + 1.8402 + 1.8403 +M68KMAKE_OP(roxl, 16, s, .) 1.8404 +{ 1.8405 + uint* r_dst = &DY; 1.8406 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8407 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.8408 + uint res = ROL_17(src | (XFLAG_AS_1() << 16), shift); 1.8409 + 1.8410 + FLAG_C = FLAG_X = res >> 8; 1.8411 + res = MASK_OUT_ABOVE_16(res); 1.8412 + 1.8413 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.8414 + 1.8415 + FLAG_N = NFLAG_16(res); 1.8416 + FLAG_Z = res; 1.8417 + FLAG_V = VFLAG_CLEAR; 1.8418 +} 1.8419 + 1.8420 + 1.8421 +M68KMAKE_OP(roxl, 32, s, .) 1.8422 +{ 1.8423 +#if M68K_USE_64_BIT 1.8424 + 1.8425 + uint* r_dst = &DY; 1.8426 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8427 + uint64 src = *r_dst; 1.8428 + uint64 res = src | (((uint64)XFLAG_AS_1()) << 32); 1.8429 + 1.8430 + res = ROL_33_64(res, shift); 1.8431 + 1.8432 + FLAG_C = FLAG_X = res >> 24; 1.8433 + res = MASK_OUT_ABOVE_32(res); 1.8434 + 1.8435 + *r_dst = res; 1.8436 + 1.8437 + FLAG_N = NFLAG_32(res); 1.8438 + FLAG_Z = res; 1.8439 + FLAG_V = VFLAG_CLEAR; 1.8440 + 1.8441 +#else 1.8442 + 1.8443 + uint* r_dst = &DY; 1.8444 + uint shift = (((REG_IR >> 9) - 1) & 7) + 1; 1.8445 + uint src = *r_dst; 1.8446 + uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1))); 1.8447 + uint new_x_flag = src & (1 << (32 - shift)); 1.8448 + 1.8449 + *r_dst = res; 1.8450 + 1.8451 + FLAG_C = FLAG_X = (new_x_flag != 0)<<8; 1.8452 + FLAG_N = NFLAG_32(res); 1.8453 + FLAG_Z = res; 1.8454 + FLAG_V = VFLAG_CLEAR; 1.8455 + 1.8456 +#endif 1.8457 +} 1.8458 + 1.8459 + 1.8460 +M68KMAKE_OP(roxl, 8, r, .) 1.8461 +{ 1.8462 + uint* r_dst = &DY; 1.8463 + uint orig_shift = DX & 0x3f; 1.8464 + 1.8465 + 1.8466 + if(orig_shift != 0) 1.8467 + { 1.8468 + uint shift = orig_shift % 9; 1.8469 + uint src = MASK_OUT_ABOVE_8(*r_dst); 1.8470 + uint res = ROL_9(src | (XFLAG_AS_1() << 8), shift); 1.8471 + 1.8472 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8473 + 1.8474 + FLAG_C = FLAG_X = res; 1.8475 + res = MASK_OUT_ABOVE_8(res); 1.8476 + 1.8477 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.8478 + FLAG_N = NFLAG_8(res); 1.8479 + FLAG_Z = res; 1.8480 + FLAG_V = VFLAG_CLEAR; 1.8481 + return; 1.8482 + } 1.8483 + 1.8484 + FLAG_C = FLAG_X; 1.8485 + FLAG_N = NFLAG_8(*r_dst); 1.8486 + FLAG_Z = MASK_OUT_ABOVE_8(*r_dst); 1.8487 + FLAG_V = VFLAG_CLEAR; 1.8488 +} 1.8489 + 1.8490 + 1.8491 +M68KMAKE_OP(roxl, 16, r, .) 1.8492 +{ 1.8493 + uint* r_dst = &DY; 1.8494 + uint orig_shift = DX & 0x3f; 1.8495 + 1.8496 + if(orig_shift != 0) 1.8497 + { 1.8498 + uint shift = orig_shift % 17; 1.8499 + uint src = MASK_OUT_ABOVE_16(*r_dst); 1.8500 + uint res = ROL_17(src | (XFLAG_AS_1() << 16), shift); 1.8501 + 1.8502 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8503 + 1.8504 + FLAG_C = FLAG_X = res >> 8; 1.8505 + res = MASK_OUT_ABOVE_16(res); 1.8506 + 1.8507 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.8508 + FLAG_N = NFLAG_16(res); 1.8509 + FLAG_Z = res; 1.8510 + FLAG_V = VFLAG_CLEAR; 1.8511 + return; 1.8512 + } 1.8513 + 1.8514 + FLAG_C = FLAG_X; 1.8515 + FLAG_N = NFLAG_16(*r_dst); 1.8516 + FLAG_Z = MASK_OUT_ABOVE_16(*r_dst); 1.8517 + FLAG_V = VFLAG_CLEAR; 1.8518 +} 1.8519 + 1.8520 + 1.8521 +M68KMAKE_OP(roxl, 32, r, .) 1.8522 +{ 1.8523 +#if M68K_USE_64_BIT 1.8524 + 1.8525 + uint* r_dst = &DY; 1.8526 + uint orig_shift = DX & 0x3f; 1.8527 + 1.8528 + if(orig_shift != 0) 1.8529 + { 1.8530 + uint shift = orig_shift % 33; 1.8531 + uint64 src = *r_dst; 1.8532 + uint64 res = src | (((uint64)XFLAG_AS_1()) << 32); 1.8533 + 1.8534 + res = ROL_33_64(res, shift); 1.8535 + 1.8536 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8537 + 1.8538 + FLAG_C = FLAG_X = res >> 24; 1.8539 + res = MASK_OUT_ABOVE_32(res); 1.8540 + 1.8541 + *r_dst = res; 1.8542 + FLAG_N = NFLAG_32(res); 1.8543 + FLAG_Z = res; 1.8544 + FLAG_V = VFLAG_CLEAR; 1.8545 + return; 1.8546 + } 1.8547 + 1.8548 + FLAG_C = FLAG_X; 1.8549 + FLAG_N = NFLAG_32(*r_dst); 1.8550 + FLAG_Z = *r_dst; 1.8551 + FLAG_V = VFLAG_CLEAR; 1.8552 + 1.8553 +#else 1.8554 + 1.8555 + uint* r_dst = &DY; 1.8556 + uint orig_shift = DX & 0x3f; 1.8557 + uint shift = orig_shift % 33; 1.8558 + uint src = *r_dst; 1.8559 + uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1))); 1.8560 + uint new_x_flag = src & (1 << (32 - shift)); 1.8561 + 1.8562 + if(orig_shift != 0) 1.8563 + USE_CYCLES(orig_shift<<CYC_SHIFT); 1.8564 + 1.8565 + if(shift != 0) 1.8566 + { 1.8567 + *r_dst = res; 1.8568 + FLAG_X = (new_x_flag != 0)<<8; 1.8569 + } 1.8570 + else 1.8571 + res = src; 1.8572 + FLAG_C = FLAG_X; 1.8573 + FLAG_N = NFLAG_32(res); 1.8574 + FLAG_Z = res; 1.8575 + FLAG_V = VFLAG_CLEAR; 1.8576 + 1.8577 +#endif 1.8578 +} 1.8579 + 1.8580 + 1.8581 +M68KMAKE_OP(roxl, 16, ., .) 1.8582 +{ 1.8583 + uint ea = M68KMAKE_GET_EA_AY_16; 1.8584 + uint src = m68ki_read_16(ea); 1.8585 + uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1); 1.8586 + 1.8587 + FLAG_C = FLAG_X = res >> 8; 1.8588 + res = MASK_OUT_ABOVE_16(res); 1.8589 + 1.8590 + m68ki_write_16(ea, res); 1.8591 + 1.8592 + FLAG_N = NFLAG_16(res); 1.8593 + FLAG_Z = res; 1.8594 + FLAG_V = VFLAG_CLEAR; 1.8595 +} 1.8596 + 1.8597 + 1.8598 +M68KMAKE_OP(rtd, 32, ., .) 1.8599 +{ 1.8600 + if(CPU_TYPE_IS_010_PLUS(CPU_TYPE)) 1.8601 + { 1.8602 + uint new_pc = m68ki_pull_32(); 1.8603 + 1.8604 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.8605 + REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16())); 1.8606 + m68ki_jump(new_pc); 1.8607 + return; 1.8608 + } 1.8609 + m68ki_exception_illegal(); 1.8610 +} 1.8611 + 1.8612 + 1.8613 +M68KMAKE_OP(rte, 32, ., .) 1.8614 +{ 1.8615 + if(FLAG_S) 1.8616 + { 1.8617 + uint new_sr; 1.8618 + uint new_pc; 1.8619 + uint format_word; 1.8620 + 1.8621 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.8622 + 1.8623 + if(CPU_TYPE_IS_000(CPU_TYPE)) 1.8624 + { 1.8625 + new_sr = m68ki_pull_16(); 1.8626 + new_pc = m68ki_pull_32(); 1.8627 + m68ki_jump(new_pc); 1.8628 + m68ki_set_sr(new_sr); 1.8629 + return; 1.8630 + } 1.8631 + 1.8632 + if(CPU_TYPE_IS_010(CPU_TYPE)) 1.8633 + { 1.8634 + format_word = m68ki_read_16(REG_A[7]+6) >> 12; 1.8635 + if(format_word == 0) 1.8636 + { 1.8637 + new_sr = m68ki_pull_16(); 1.8638 + new_pc = m68ki_pull_32(); 1.8639 + m68ki_fake_pull_16(); /* format word */ 1.8640 + m68ki_jump(new_pc); 1.8641 + m68ki_set_sr(new_sr); 1.8642 + return; 1.8643 + } 1.8644 + /* Not handling bus fault (9) */ 1.8645 + m68ki_exception_format_error(); 1.8646 + return; 1.8647 + } 1.8648 + 1.8649 + /* Otherwise it's 020 */ 1.8650 +rte_loop: 1.8651 + format_word = m68ki_read_16(REG_A[7]+6) >> 12; 1.8652 + switch(format_word) 1.8653 + { 1.8654 + case 0: /* Normal */ 1.8655 + new_sr = m68ki_pull_16(); 1.8656 + new_pc = m68ki_pull_32(); 1.8657 + m68ki_fake_pull_16(); /* format word */ 1.8658 + m68ki_jump(new_pc); 1.8659 + m68ki_set_sr(new_sr); 1.8660 + return; 1.8661 + case 1: /* Throwaway */ 1.8662 + new_sr = m68ki_pull_16(); 1.8663 + m68ki_fake_pull_32(); /* program counter */ 1.8664 + m68ki_fake_pull_16(); /* format word */ 1.8665 + m68ki_set_sr_noint(new_sr); 1.8666 + goto rte_loop; 1.8667 + case 2: /* Trap */ 1.8668 + new_sr = m68ki_pull_16(); 1.8669 + new_pc = m68ki_pull_32(); 1.8670 + m68ki_fake_pull_16(); /* format word */ 1.8671 + m68ki_fake_pull_32(); /* address */ 1.8672 + m68ki_jump(new_pc); 1.8673 + m68ki_set_sr(new_sr); 1.8674 + return; 1.8675 + } 1.8676 + /* Not handling long or short bus fault */ 1.8677 + m68ki_exception_format_error(); 1.8678 + return; 1.8679 + } 1.8680 + m68ki_exception_privilege_violation(); 1.8681 +} 1.8682 + 1.8683 + 1.8684 +M68KMAKE_OP(rtm, 32, ., .) 1.8685 +{ 1.8686 + if(CPU_TYPE_IS_020_VARIANT(CPU_TYPE)) 1.8687 + { 1.8688 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.8689 + M68K_DO_LOG((M68K_LOG_FILEHANDLE "%s at %08x: called unimplemented instruction %04x (%s)\n", 1.8690 + m68ki_cpu_names[CPU_TYPE], ADDRESS_68K(REG_PC - 2), REG_IR, 1.8691 + m68k_disassemble_quick(ADDRESS_68K(REG_PC - 2)))); 1.8692 + return; 1.8693 + } 1.8694 + m68ki_exception_illegal(); 1.8695 +} 1.8696 + 1.8697 + 1.8698 +M68KMAKE_OP(rtr, 32, ., .) 1.8699 +{ 1.8700 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.8701 + m68ki_set_ccr(m68ki_pull_16()); 1.8702 + m68ki_jump(m68ki_pull_32()); 1.8703 +} 1.8704 + 1.8705 + 1.8706 +M68KMAKE_OP(rts, 32, ., .) 1.8707 +{ 1.8708 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.8709 + m68ki_jump(m68ki_pull_32()); 1.8710 +} 1.8711 + 1.8712 + 1.8713 +M68KMAKE_OP(sbcd, 8, rr, .) 1.8714 +{ 1.8715 + uint* r_dst = &DX; 1.8716 + uint src = DY; 1.8717 + uint dst = *r_dst; 1.8718 + uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1(); 1.8719 + 1.8720 + if(res > 9) 1.8721 + res -= 6; 1.8722 + res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src); 1.8723 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.8724 + if(FLAG_C) 1.8725 + res += 0xa0; 1.8726 + 1.8727 + res = MASK_OUT_ABOVE_8(res); 1.8728 + 1.8729 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.8730 + FLAG_Z |= res; 1.8731 + 1.8732 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.8733 +} 1.8734 + 1.8735 + 1.8736 +M68KMAKE_OP(sbcd, 8, mm, ax7) 1.8737 +{ 1.8738 + uint src = OPER_AY_PD_8(); 1.8739 + uint ea = EA_A7_PD_8(); 1.8740 + uint dst = m68ki_read_8(ea); 1.8741 + uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1(); 1.8742 + 1.8743 + if(res > 9) 1.8744 + res -= 6; 1.8745 + res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src); 1.8746 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.8747 + if(FLAG_C) 1.8748 + res += 0xa0; 1.8749 + 1.8750 + res = MASK_OUT_ABOVE_8(res); 1.8751 + 1.8752 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.8753 + FLAG_Z |= res; 1.8754 + 1.8755 + m68ki_write_8(ea, res); 1.8756 +} 1.8757 + 1.8758 + 1.8759 +M68KMAKE_OP(sbcd, 8, mm, ay7) 1.8760 +{ 1.8761 + uint src = OPER_A7_PD_8(); 1.8762 + uint ea = EA_AX_PD_8(); 1.8763 + uint dst = m68ki_read_8(ea); 1.8764 + uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1(); 1.8765 + 1.8766 + if(res > 9) 1.8767 + res -= 6; 1.8768 + res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src); 1.8769 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.8770 + if(FLAG_C) 1.8771 + res += 0xa0; 1.8772 + 1.8773 + res = MASK_OUT_ABOVE_8(res); 1.8774 + 1.8775 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.8776 + FLAG_Z |= res; 1.8777 + 1.8778 + m68ki_write_8(ea, res); 1.8779 +} 1.8780 + 1.8781 + 1.8782 +M68KMAKE_OP(sbcd, 8, mm, axy7) 1.8783 +{ 1.8784 + uint src = OPER_A7_PD_8(); 1.8785 + uint ea = EA_A7_PD_8(); 1.8786 + uint dst = m68ki_read_8(ea); 1.8787 + uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1(); 1.8788 + 1.8789 + if(res > 9) 1.8790 + res -= 6; 1.8791 + res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src); 1.8792 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.8793 + if(FLAG_C) 1.8794 + res += 0xa0; 1.8795 + 1.8796 + res = MASK_OUT_ABOVE_8(res); 1.8797 + 1.8798 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.8799 + FLAG_Z |= res; 1.8800 + 1.8801 + m68ki_write_8(ea, res); 1.8802 +} 1.8803 + 1.8804 + 1.8805 +M68KMAKE_OP(sbcd, 8, mm, .) 1.8806 +{ 1.8807 + uint src = OPER_AY_PD_8(); 1.8808 + uint ea = EA_AX_PD_8(); 1.8809 + uint dst = m68ki_read_8(ea); 1.8810 + uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1(); 1.8811 + 1.8812 + if(res > 9) 1.8813 + res -= 6; 1.8814 + res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src); 1.8815 + FLAG_X = FLAG_C = (res > 0x99) << 8; 1.8816 + if(FLAG_C) 1.8817 + res += 0xa0; 1.8818 + 1.8819 + res = MASK_OUT_ABOVE_8(res); 1.8820 + 1.8821 + FLAG_N = NFLAG_8(res); /* officially undefined */ 1.8822 + FLAG_Z |= res; 1.8823 + 1.8824 + m68ki_write_8(ea, res); 1.8825 +} 1.8826 + 1.8827 + 1.8828 +M68KMAKE_OP(st, 8, ., d) 1.8829 +{ 1.8830 + DY |= 0xff; 1.8831 +} 1.8832 + 1.8833 + 1.8834 +M68KMAKE_OP(st, 8, ., .) 1.8835 +{ 1.8836 + m68ki_write_8(M68KMAKE_GET_EA_AY_8, 0xff); 1.8837 +} 1.8838 + 1.8839 + 1.8840 +M68KMAKE_OP(sf, 8, ., d) 1.8841 +{ 1.8842 + DY &= 0xffffff00; 1.8843 +} 1.8844 + 1.8845 + 1.8846 +M68KMAKE_OP(sf, 8, ., .) 1.8847 +{ 1.8848 + m68ki_write_8(M68KMAKE_GET_EA_AY_8, 0); 1.8849 +} 1.8850 + 1.8851 + 1.8852 +M68KMAKE_OP(scc, 8, ., d) 1.8853 +{ 1.8854 + if(M68KMAKE_CC) 1.8855 + { 1.8856 + DY |= 0xff; 1.8857 + return; 1.8858 + } 1.8859 + DY &= 0xffffff00; 1.8860 +} 1.8861 + 1.8862 + 1.8863 +M68KMAKE_OP(scc, 8, ., .) 1.8864 +{ 1.8865 + m68ki_write_8(M68KMAKE_GET_EA_AY_8, M68KMAKE_CC ? 0xff : 0); 1.8866 +} 1.8867 + 1.8868 + 1.8869 +M68KMAKE_OP(stop, 0, ., .) 1.8870 +{ 1.8871 + if(FLAG_S) 1.8872 + { 1.8873 + uint new_sr = OPER_I_16(); 1.8874 + m68ki_trace_t0(); /* auto-disable (see m68kcpu.h) */ 1.8875 + CPU_STOPPED |= STOP_LEVEL_STOP; 1.8876 + m68ki_set_sr(new_sr); 1.8877 + m68ki_remaining_cycles = 0; 1.8878 + return; 1.8879 + } 1.8880 + m68ki_exception_privilege_violation(); 1.8881 +} 1.8882 + 1.8883 + 1.8884 +M68KMAKE_OP(sub, 8, er, d) 1.8885 +{ 1.8886 + uint* r_dst = &DX; 1.8887 + uint src = MASK_OUT_ABOVE_8(DY); 1.8888 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.8889 + uint res = dst - src; 1.8890 + 1.8891 + FLAG_N = NFLAG_8(res); 1.8892 + FLAG_X = FLAG_C = CFLAG_8(res); 1.8893 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.8894 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.8895 + 1.8896 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.8897 +} 1.8898 + 1.8899 + 1.8900 +M68KMAKE_OP(sub, 8, er, .) 1.8901 +{ 1.8902 + uint* r_dst = &DX; 1.8903 + uint src = M68KMAKE_GET_OPER_AY_8; 1.8904 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.8905 + uint res = dst - src; 1.8906 + 1.8907 + FLAG_N = NFLAG_8(res); 1.8908 + FLAG_X = FLAG_C = CFLAG_8(res); 1.8909 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.8910 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.8911 + 1.8912 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.8913 +} 1.8914 + 1.8915 + 1.8916 +M68KMAKE_OP(sub, 16, er, d) 1.8917 +{ 1.8918 + uint* r_dst = &DX; 1.8919 + uint src = MASK_OUT_ABOVE_16(DY); 1.8920 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.8921 + uint res = dst - src; 1.8922 + 1.8923 + FLAG_N = NFLAG_16(res); 1.8924 + FLAG_X = FLAG_C = CFLAG_16(res); 1.8925 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.8926 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.8927 + 1.8928 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.8929 +} 1.8930 + 1.8931 + 1.8932 +M68KMAKE_OP(sub, 16, er, a) 1.8933 +{ 1.8934 + uint* r_dst = &DX; 1.8935 + uint src = MASK_OUT_ABOVE_16(AY); 1.8936 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.8937 + uint res = dst - src; 1.8938 + 1.8939 + FLAG_N = NFLAG_16(res); 1.8940 + FLAG_X = FLAG_C = CFLAG_16(res); 1.8941 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.8942 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.8943 + 1.8944 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.8945 +} 1.8946 + 1.8947 + 1.8948 +M68KMAKE_OP(sub, 16, er, .) 1.8949 +{ 1.8950 + uint* r_dst = &DX; 1.8951 + uint src = M68KMAKE_GET_OPER_AY_16; 1.8952 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.8953 + uint res = dst - src; 1.8954 + 1.8955 + FLAG_N = NFLAG_16(res); 1.8956 + FLAG_X = FLAG_C = CFLAG_16(res); 1.8957 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.8958 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.8959 + 1.8960 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.8961 +} 1.8962 + 1.8963 + 1.8964 +M68KMAKE_OP(sub, 32, er, d) 1.8965 +{ 1.8966 + uint* r_dst = &DX; 1.8967 + uint src = DY; 1.8968 + uint dst = *r_dst; 1.8969 + uint res = dst - src; 1.8970 + 1.8971 + FLAG_N = NFLAG_32(res); 1.8972 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.8973 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.8974 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.8975 + 1.8976 + *r_dst = FLAG_Z; 1.8977 +} 1.8978 + 1.8979 + 1.8980 +M68KMAKE_OP(sub, 32, er, a) 1.8981 +{ 1.8982 + uint* r_dst = &DX; 1.8983 + uint src = AY; 1.8984 + uint dst = *r_dst; 1.8985 + uint res = dst - src; 1.8986 + 1.8987 + FLAG_N = NFLAG_32(res); 1.8988 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.8989 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.8990 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.8991 + 1.8992 + *r_dst = FLAG_Z; 1.8993 +} 1.8994 + 1.8995 + 1.8996 +M68KMAKE_OP(sub, 32, er, .) 1.8997 +{ 1.8998 + uint* r_dst = &DX; 1.8999 + uint src = M68KMAKE_GET_OPER_AY_32; 1.9000 + uint dst = *r_dst; 1.9001 + uint res = dst - src; 1.9002 + 1.9003 + FLAG_N = NFLAG_32(res); 1.9004 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9005 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9006 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.9007 + 1.9008 + *r_dst = FLAG_Z; 1.9009 +} 1.9010 + 1.9011 + 1.9012 +M68KMAKE_OP(sub, 8, re, .) 1.9013 +{ 1.9014 + uint ea = M68KMAKE_GET_EA_AY_8; 1.9015 + uint src = MASK_OUT_ABOVE_8(DX); 1.9016 + uint dst = m68ki_read_8(ea); 1.9017 + uint res = dst - src; 1.9018 + 1.9019 + FLAG_N = NFLAG_8(res); 1.9020 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.9021 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9022 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9023 + 1.9024 + m68ki_write_8(ea, FLAG_Z); 1.9025 +} 1.9026 + 1.9027 + 1.9028 +M68KMAKE_OP(sub, 16, re, .) 1.9029 +{ 1.9030 + uint ea = M68KMAKE_GET_EA_AY_16; 1.9031 + uint src = MASK_OUT_ABOVE_16(DX); 1.9032 + uint dst = m68ki_read_16(ea); 1.9033 + uint res = dst - src; 1.9034 + 1.9035 + FLAG_N = NFLAG_16(res); 1.9036 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.9037 + FLAG_X = FLAG_C = CFLAG_16(res); 1.9038 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.9039 + 1.9040 + m68ki_write_16(ea, FLAG_Z); 1.9041 +} 1.9042 + 1.9043 + 1.9044 +M68KMAKE_OP(sub, 32, re, .) 1.9045 +{ 1.9046 + uint ea = M68KMAKE_GET_EA_AY_32; 1.9047 + uint src = DX; 1.9048 + uint dst = m68ki_read_32(ea); 1.9049 + uint res = dst - src; 1.9050 + 1.9051 + FLAG_N = NFLAG_32(res); 1.9052 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.9053 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9054 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9055 + 1.9056 + m68ki_write_32(ea, FLAG_Z); 1.9057 +} 1.9058 + 1.9059 + 1.9060 +M68KMAKE_OP(suba, 16, ., d) 1.9061 +{ 1.9062 + uint* r_dst = &AX; 1.9063 + 1.9064 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(DY)); 1.9065 +} 1.9066 + 1.9067 + 1.9068 +M68KMAKE_OP(suba, 16, ., a) 1.9069 +{ 1.9070 + uint* r_dst = &AX; 1.9071 + 1.9072 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(AY)); 1.9073 +} 1.9074 + 1.9075 + 1.9076 +M68KMAKE_OP(suba, 16, ., .) 1.9077 +{ 1.9078 + uint* r_dst = &AX; 1.9079 + 1.9080 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(M68KMAKE_GET_OPER_AY_16)); 1.9081 +} 1.9082 + 1.9083 + 1.9084 +M68KMAKE_OP(suba, 32, ., d) 1.9085 +{ 1.9086 + uint* r_dst = &AX; 1.9087 + 1.9088 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - DY); 1.9089 +} 1.9090 + 1.9091 + 1.9092 +M68KMAKE_OP(suba, 32, ., a) 1.9093 +{ 1.9094 + uint* r_dst = &AX; 1.9095 + 1.9096 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - AY); 1.9097 +} 1.9098 + 1.9099 + 1.9100 +M68KMAKE_OP(suba, 32, ., .) 1.9101 +{ 1.9102 + uint* r_dst = &AX; 1.9103 + 1.9104 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - M68KMAKE_GET_OPER_AY_32); 1.9105 +} 1.9106 + 1.9107 + 1.9108 +M68KMAKE_OP(subi, 8, ., d) 1.9109 +{ 1.9110 + uint* r_dst = &DY; 1.9111 + uint src = OPER_I_8(); 1.9112 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.9113 + uint res = dst - src; 1.9114 + 1.9115 + FLAG_N = NFLAG_8(res); 1.9116 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.9117 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9118 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9119 + 1.9120 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.9121 +} 1.9122 + 1.9123 + 1.9124 +M68KMAKE_OP(subi, 8, ., .) 1.9125 +{ 1.9126 + uint src = OPER_I_8(); 1.9127 + uint ea = M68KMAKE_GET_EA_AY_8; 1.9128 + uint dst = m68ki_read_8(ea); 1.9129 + uint res = dst - src; 1.9130 + 1.9131 + FLAG_N = NFLAG_8(res); 1.9132 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.9133 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9134 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9135 + 1.9136 + m68ki_write_8(ea, FLAG_Z); 1.9137 +} 1.9138 + 1.9139 + 1.9140 +M68KMAKE_OP(subi, 16, ., d) 1.9141 +{ 1.9142 + uint* r_dst = &DY; 1.9143 + uint src = OPER_I_16(); 1.9144 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.9145 + uint res = dst - src; 1.9146 + 1.9147 + FLAG_N = NFLAG_16(res); 1.9148 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.9149 + FLAG_X = FLAG_C = CFLAG_16(res); 1.9150 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.9151 + 1.9152 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.9153 +} 1.9154 + 1.9155 + 1.9156 +M68KMAKE_OP(subi, 16, ., .) 1.9157 +{ 1.9158 + uint src = OPER_I_16(); 1.9159 + uint ea = M68KMAKE_GET_EA_AY_16; 1.9160 + uint dst = m68ki_read_16(ea); 1.9161 + uint res = dst - src; 1.9162 + 1.9163 + FLAG_N = NFLAG_16(res); 1.9164 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.9165 + FLAG_X = FLAG_C = CFLAG_16(res); 1.9166 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.9167 + 1.9168 + m68ki_write_16(ea, FLAG_Z); 1.9169 +} 1.9170 + 1.9171 + 1.9172 +M68KMAKE_OP(subi, 32, ., d) 1.9173 +{ 1.9174 + uint* r_dst = &DY; 1.9175 + uint src = OPER_I_32(); 1.9176 + uint dst = *r_dst; 1.9177 + uint res = dst - src; 1.9178 + 1.9179 + FLAG_N = NFLAG_32(res); 1.9180 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.9181 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9182 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9183 + 1.9184 + *r_dst = FLAG_Z; 1.9185 +} 1.9186 + 1.9187 + 1.9188 +M68KMAKE_OP(subi, 32, ., .) 1.9189 +{ 1.9190 + uint src = OPER_I_32(); 1.9191 + uint ea = M68KMAKE_GET_EA_AY_32; 1.9192 + uint dst = m68ki_read_32(ea); 1.9193 + uint res = dst - src; 1.9194 + 1.9195 + FLAG_N = NFLAG_32(res); 1.9196 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.9197 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9198 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9199 + 1.9200 + m68ki_write_32(ea, FLAG_Z); 1.9201 +} 1.9202 + 1.9203 + 1.9204 +M68KMAKE_OP(subq, 8, ., d) 1.9205 +{ 1.9206 + uint* r_dst = &DY; 1.9207 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.9208 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.9209 + uint res = dst - src; 1.9210 + 1.9211 + FLAG_N = NFLAG_8(res); 1.9212 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.9213 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9214 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9215 + 1.9216 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z; 1.9217 +} 1.9218 + 1.9219 + 1.9220 +M68KMAKE_OP(subq, 8, ., .) 1.9221 +{ 1.9222 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.9223 + uint ea = M68KMAKE_GET_EA_AY_8; 1.9224 + uint dst = m68ki_read_8(ea); 1.9225 + uint res = dst - src; 1.9226 + 1.9227 + FLAG_N = NFLAG_8(res); 1.9228 + FLAG_Z = MASK_OUT_ABOVE_8(res); 1.9229 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9230 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9231 + 1.9232 + m68ki_write_8(ea, FLAG_Z); 1.9233 +} 1.9234 + 1.9235 + 1.9236 +M68KMAKE_OP(subq, 16, ., d) 1.9237 +{ 1.9238 + uint* r_dst = &DY; 1.9239 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.9240 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.9241 + uint res = dst - src; 1.9242 + 1.9243 + FLAG_N = NFLAG_16(res); 1.9244 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.9245 + FLAG_X = FLAG_C = CFLAG_16(res); 1.9246 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.9247 + 1.9248 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z; 1.9249 +} 1.9250 + 1.9251 + 1.9252 +M68KMAKE_OP(subq, 16, ., a) 1.9253 +{ 1.9254 + uint* r_dst = &AY; 1.9255 + 1.9256 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1)); 1.9257 +} 1.9258 + 1.9259 + 1.9260 +M68KMAKE_OP(subq, 16, ., .) 1.9261 +{ 1.9262 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.9263 + uint ea = M68KMAKE_GET_EA_AY_16; 1.9264 + uint dst = m68ki_read_16(ea); 1.9265 + uint res = dst - src; 1.9266 + 1.9267 + FLAG_N = NFLAG_16(res); 1.9268 + FLAG_Z = MASK_OUT_ABOVE_16(res); 1.9269 + FLAG_X = FLAG_C = CFLAG_16(res); 1.9270 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.9271 + 1.9272 + m68ki_write_16(ea, FLAG_Z); 1.9273 +} 1.9274 + 1.9275 + 1.9276 +M68KMAKE_OP(subq, 32, ., d) 1.9277 +{ 1.9278 + uint* r_dst = &DY; 1.9279 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.9280 + uint dst = *r_dst; 1.9281 + uint res = dst - src; 1.9282 + 1.9283 + FLAG_N = NFLAG_32(res); 1.9284 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.9285 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9286 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9287 + 1.9288 + *r_dst = FLAG_Z; 1.9289 +} 1.9290 + 1.9291 + 1.9292 +M68KMAKE_OP(subq, 32, ., a) 1.9293 +{ 1.9294 + uint* r_dst = &AY; 1.9295 + 1.9296 + *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1)); 1.9297 +} 1.9298 + 1.9299 + 1.9300 +M68KMAKE_OP(subq, 32, ., .) 1.9301 +{ 1.9302 + uint src = (((REG_IR >> 9) - 1) & 7) + 1; 1.9303 + uint ea = M68KMAKE_GET_EA_AY_32; 1.9304 + uint dst = m68ki_read_32(ea); 1.9305 + uint res = dst - src; 1.9306 + 1.9307 + FLAG_N = NFLAG_32(res); 1.9308 + FLAG_Z = MASK_OUT_ABOVE_32(res); 1.9309 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9310 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9311 + 1.9312 + m68ki_write_32(ea, FLAG_Z); 1.9313 +} 1.9314 + 1.9315 + 1.9316 +M68KMAKE_OP(subx, 8, rr, .) 1.9317 +{ 1.9318 + uint* r_dst = &DX; 1.9319 + uint src = MASK_OUT_ABOVE_8(DY); 1.9320 + uint dst = MASK_OUT_ABOVE_8(*r_dst); 1.9321 + uint res = dst - src - XFLAG_AS_1(); 1.9322 + 1.9323 + FLAG_N = NFLAG_8(res); 1.9324 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9325 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9326 + 1.9327 + res = MASK_OUT_ABOVE_8(res); 1.9328 + FLAG_Z |= res; 1.9329 + 1.9330 + *r_dst = MASK_OUT_BELOW_8(*r_dst) | res; 1.9331 +} 1.9332 + 1.9333 + 1.9334 +M68KMAKE_OP(subx, 16, rr, .) 1.9335 +{ 1.9336 + uint* r_dst = &DX; 1.9337 + uint src = MASK_OUT_ABOVE_16(DY); 1.9338 + uint dst = MASK_OUT_ABOVE_16(*r_dst); 1.9339 + uint res = dst - src - XFLAG_AS_1(); 1.9340 + 1.9341 + FLAG_N = NFLAG_16(res); 1.9342 + FLAG_X = FLAG_C = CFLAG_16(res); 1.9343 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.9344 + 1.9345 + res = MASK_OUT_ABOVE_16(res); 1.9346 + FLAG_Z |= res; 1.9347 + 1.9348 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | res; 1.9349 +} 1.9350 + 1.9351 + 1.9352 +M68KMAKE_OP(subx, 32, rr, .) 1.9353 +{ 1.9354 + uint* r_dst = &DX; 1.9355 + uint src = DY; 1.9356 + uint dst = *r_dst; 1.9357 + uint res = dst - src - XFLAG_AS_1(); 1.9358 + 1.9359 + FLAG_N = NFLAG_32(res); 1.9360 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9361 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9362 + 1.9363 + res = MASK_OUT_ABOVE_32(res); 1.9364 + FLAG_Z |= res; 1.9365 + 1.9366 + *r_dst = res; 1.9367 +} 1.9368 + 1.9369 + 1.9370 +M68KMAKE_OP(subx, 8, mm, ax7) 1.9371 +{ 1.9372 + uint src = OPER_AY_PD_8(); 1.9373 + uint ea = EA_A7_PD_8(); 1.9374 + uint dst = m68ki_read_8(ea); 1.9375 + uint res = dst - src - XFLAG_AS_1(); 1.9376 + 1.9377 + FLAG_N = NFLAG_8(res); 1.9378 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9379 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9380 + 1.9381 + res = MASK_OUT_ABOVE_8(res); 1.9382 + FLAG_Z |= res; 1.9383 + 1.9384 + m68ki_write_8(ea, res); 1.9385 +} 1.9386 + 1.9387 + 1.9388 +M68KMAKE_OP(subx, 8, mm, ay7) 1.9389 +{ 1.9390 + uint src = OPER_A7_PD_8(); 1.9391 + uint ea = EA_AX_PD_8(); 1.9392 + uint dst = m68ki_read_8(ea); 1.9393 + uint res = dst - src - XFLAG_AS_1(); 1.9394 + 1.9395 + FLAG_N = NFLAG_8(res); 1.9396 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9397 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9398 + 1.9399 + res = MASK_OUT_ABOVE_8(res); 1.9400 + FLAG_Z |= res; 1.9401 + 1.9402 + m68ki_write_8(ea, res); 1.9403 +} 1.9404 + 1.9405 + 1.9406 +M68KMAKE_OP(subx, 8, mm, axy7) 1.9407 +{ 1.9408 + uint src = OPER_A7_PD_8(); 1.9409 + uint ea = EA_A7_PD_8(); 1.9410 + uint dst = m68ki_read_8(ea); 1.9411 + uint res = dst - src - XFLAG_AS_1(); 1.9412 + 1.9413 + FLAG_N = NFLAG_8(res); 1.9414 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9415 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9416 + 1.9417 + res = MASK_OUT_ABOVE_8(res); 1.9418 + FLAG_Z |= res; 1.9419 + 1.9420 + m68ki_write_8(ea, res); 1.9421 +} 1.9422 + 1.9423 + 1.9424 +M68KMAKE_OP(subx, 8, mm, .) 1.9425 +{ 1.9426 + uint src = OPER_AY_PD_8(); 1.9427 + uint ea = EA_AX_PD_8(); 1.9428 + uint dst = m68ki_read_8(ea); 1.9429 + uint res = dst - src - XFLAG_AS_1(); 1.9430 + 1.9431 + FLAG_N = NFLAG_8(res); 1.9432 + FLAG_X = FLAG_C = CFLAG_8(res); 1.9433 + FLAG_V = VFLAG_SUB_8(src, dst, res); 1.9434 + 1.9435 + res = MASK_OUT_ABOVE_8(res); 1.9436 + FLAG_Z |= res; 1.9437 + 1.9438 + m68ki_write_8(ea, res); 1.9439 +} 1.9440 + 1.9441 + 1.9442 +M68KMAKE_OP(subx, 16, mm, .) 1.9443 +{ 1.9444 + uint src = OPER_AY_PD_16(); 1.9445 + uint ea = EA_AX_PD_16(); 1.9446 + uint dst = m68ki_read_16(ea); 1.9447 + uint res = dst - src - XFLAG_AS_1(); 1.9448 + 1.9449 + FLAG_N = NFLAG_16(res); 1.9450 + FLAG_X = FLAG_C = CFLAG_16(res); 1.9451 + FLAG_V = VFLAG_SUB_16(src, dst, res); 1.9452 + 1.9453 + res = MASK_OUT_ABOVE_16(res); 1.9454 + FLAG_Z |= res; 1.9455 + 1.9456 + m68ki_write_16(ea, res); 1.9457 +} 1.9458 + 1.9459 + 1.9460 +M68KMAKE_OP(subx, 32, mm, .) 1.9461 +{ 1.9462 + uint src = OPER_AY_PD_32(); 1.9463 + uint ea = EA_AX_PD_32(); 1.9464 + uint dst = m68ki_read_32(ea); 1.9465 + uint res = dst - src - XFLAG_AS_1(); 1.9466 + 1.9467 + FLAG_N = NFLAG_32(res); 1.9468 + FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res); 1.9469 + FLAG_V = VFLAG_SUB_32(src, dst, res); 1.9470 + 1.9471 + res = MASK_OUT_ABOVE_32(res); 1.9472 + FLAG_Z |= res; 1.9473 + 1.9474 + m68ki_write_32(ea, res); 1.9475 +} 1.9476 + 1.9477 + 1.9478 +M68KMAKE_OP(swap, 32, ., .) 1.9479 +{ 1.9480 + uint* r_dst = &DY; 1.9481 + 1.9482 + FLAG_Z = MASK_OUT_ABOVE_32(*r_dst<<16); 1.9483 + *r_dst = (*r_dst>>16) | FLAG_Z; 1.9484 + 1.9485 + FLAG_Z = *r_dst; 1.9486 + FLAG_N = NFLAG_32(*r_dst); 1.9487 + FLAG_C = CFLAG_CLEAR; 1.9488 + FLAG_V = VFLAG_CLEAR; 1.9489 +} 1.9490 + 1.9491 + 1.9492 +M68KMAKE_OP(tas, 8, ., d) 1.9493 +{ 1.9494 + uint* r_dst = &DY; 1.9495 + 1.9496 + FLAG_Z = MASK_OUT_ABOVE_8(*r_dst); 1.9497 + FLAG_N = NFLAG_8(*r_dst); 1.9498 + FLAG_V = VFLAG_CLEAR; 1.9499 + FLAG_C = CFLAG_CLEAR; 1.9500 + *r_dst |= 0x80; 1.9501 +} 1.9502 + 1.9503 + 1.9504 +M68KMAKE_OP(tas, 8, ., .) 1.9505 +{ 1.9506 + uint ea = M68KMAKE_GET_EA_AY_8; 1.9507 + uint dst = m68ki_read_8(ea); 1.9508 + 1.9509 + FLAG_Z = dst; 1.9510 + FLAG_N = NFLAG_8(dst); 1.9511 + FLAG_V = VFLAG_CLEAR; 1.9512 + FLAG_C = CFLAG_CLEAR; 1.9513 + m68ki_write_8(ea, dst | 0x80); 1.9514 +} 1.9515 + 1.9516 + 1.9517 +M68KMAKE_OP(trap, 0, ., .) 1.9518 +{ 1.9519 + /* Trap#n stacks exception frame type 0 */ 1.9520 + m68ki_exception_trapN(EXCEPTION_TRAP_BASE + (REG_IR & 0xf)); /* HJB 990403 */ 1.9521 +} 1.9522 + 1.9523 + 1.9524 +M68KMAKE_OP(trapt, 0, ., .) 1.9525 +{ 1.9526 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9527 + { 1.9528 + m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */ 1.9529 + return; 1.9530 + } 1.9531 + m68ki_exception_illegal(); 1.9532 +} 1.9533 + 1.9534 + 1.9535 +M68KMAKE_OP(trapt, 16, ., .) 1.9536 +{ 1.9537 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9538 + { 1.9539 + m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */ 1.9540 + return; 1.9541 + } 1.9542 + m68ki_exception_illegal(); 1.9543 +} 1.9544 + 1.9545 + 1.9546 +M68KMAKE_OP(trapt, 32, ., .) 1.9547 +{ 1.9548 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9549 + { 1.9550 + m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */ 1.9551 + return; 1.9552 + } 1.9553 + m68ki_exception_illegal(); 1.9554 +} 1.9555 + 1.9556 + 1.9557 +M68KMAKE_OP(trapf, 0, ., .) 1.9558 +{ 1.9559 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9560 + { 1.9561 + return; 1.9562 + } 1.9563 + m68ki_exception_illegal(); 1.9564 +} 1.9565 + 1.9566 + 1.9567 +M68KMAKE_OP(trapf, 16, ., .) 1.9568 +{ 1.9569 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9570 + { 1.9571 + REG_PC += 2; 1.9572 + return; 1.9573 + } 1.9574 + m68ki_exception_illegal(); 1.9575 +} 1.9576 + 1.9577 + 1.9578 +M68KMAKE_OP(trapf, 32, ., .) 1.9579 +{ 1.9580 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9581 + { 1.9582 + REG_PC += 4; 1.9583 + return; 1.9584 + } 1.9585 + m68ki_exception_illegal(); 1.9586 +} 1.9587 + 1.9588 + 1.9589 +M68KMAKE_OP(trapcc, 0, ., .) 1.9590 +{ 1.9591 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9592 + { 1.9593 + if(M68KMAKE_CC) 1.9594 + m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */ 1.9595 + return; 1.9596 + } 1.9597 + m68ki_exception_illegal(); 1.9598 +} 1.9599 + 1.9600 + 1.9601 +M68KMAKE_OP(trapcc, 16, ., .) 1.9602 +{ 1.9603 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9604 + { 1.9605 + if(M68KMAKE_CC) 1.9606 + { 1.9607 + m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */ 1.9608 + return; 1.9609 + } 1.9610 + REG_PC += 2; 1.9611 + return; 1.9612 + } 1.9613 + m68ki_exception_illegal(); 1.9614 +} 1.9615 + 1.9616 + 1.9617 +M68KMAKE_OP(trapcc, 32, ., .) 1.9618 +{ 1.9619 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9620 + { 1.9621 + if(M68KMAKE_CC) 1.9622 + { 1.9623 + m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */ 1.9624 + return; 1.9625 + } 1.9626 + REG_PC += 4; 1.9627 + return; 1.9628 + } 1.9629 + m68ki_exception_illegal(); 1.9630 +} 1.9631 + 1.9632 + 1.9633 +M68KMAKE_OP(trapv, 0, ., .) 1.9634 +{ 1.9635 + if(COND_VC()) 1.9636 + { 1.9637 + return; 1.9638 + } 1.9639 + m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */ 1.9640 +} 1.9641 + 1.9642 + 1.9643 +M68KMAKE_OP(tst, 8, ., d) 1.9644 +{ 1.9645 + uint res = MASK_OUT_ABOVE_8(DY); 1.9646 + 1.9647 + FLAG_N = NFLAG_8(res); 1.9648 + FLAG_Z = res; 1.9649 + FLAG_V = VFLAG_CLEAR; 1.9650 + FLAG_C = CFLAG_CLEAR; 1.9651 +} 1.9652 + 1.9653 + 1.9654 +M68KMAKE_OP(tst, 8, ., .) 1.9655 +{ 1.9656 + uint ea = M68KMAKE_GET_EA_AY_8; 1.9657 + uint res = m68ki_read_8(ea); 1.9658 + 1.9659 + FLAG_N = NFLAG_8(res); 1.9660 + FLAG_Z = res; 1.9661 + FLAG_V = VFLAG_CLEAR; 1.9662 + FLAG_C = CFLAG_CLEAR; 1.9663 +} 1.9664 + 1.9665 + 1.9666 +M68KMAKE_OP(tst, 8, ., pcdi) 1.9667 +{ 1.9668 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9669 + { 1.9670 + uint res = OPER_PCDI_8(); 1.9671 + 1.9672 + FLAG_N = NFLAG_8(res); 1.9673 + FLAG_Z = res; 1.9674 + FLAG_V = VFLAG_CLEAR; 1.9675 + FLAG_C = CFLAG_CLEAR; 1.9676 + return; 1.9677 + } 1.9678 + m68ki_exception_illegal(); 1.9679 +} 1.9680 + 1.9681 + 1.9682 +M68KMAKE_OP(tst, 8, ., pcix) 1.9683 +{ 1.9684 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9685 + { 1.9686 + uint res = OPER_PCIX_8(); 1.9687 + 1.9688 + FLAG_N = NFLAG_8(res); 1.9689 + FLAG_Z = res; 1.9690 + FLAG_V = VFLAG_CLEAR; 1.9691 + FLAG_C = CFLAG_CLEAR; 1.9692 + return; 1.9693 + } 1.9694 + m68ki_exception_illegal(); 1.9695 +} 1.9696 + 1.9697 + 1.9698 +M68KMAKE_OP(tst, 8, ., i) 1.9699 +{ 1.9700 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9701 + { 1.9702 + uint res = OPER_I_8(); 1.9703 + 1.9704 + FLAG_N = NFLAG_8(res); 1.9705 + FLAG_Z = res; 1.9706 + FLAG_V = VFLAG_CLEAR; 1.9707 + FLAG_C = CFLAG_CLEAR; 1.9708 + return; 1.9709 + } 1.9710 + m68ki_exception_illegal(); 1.9711 +} 1.9712 + 1.9713 + 1.9714 +M68KMAKE_OP(tst, 16, ., d) 1.9715 +{ 1.9716 + uint res = MASK_OUT_ABOVE_16(DY); 1.9717 + 1.9718 + FLAG_N = NFLAG_16(res); 1.9719 + FLAG_Z = res; 1.9720 + FLAG_V = VFLAG_CLEAR; 1.9721 + FLAG_C = CFLAG_CLEAR; 1.9722 +} 1.9723 + 1.9724 + 1.9725 +M68KMAKE_OP(tst, 16, ., a) 1.9726 +{ 1.9727 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9728 + { 1.9729 + uint res = MAKE_INT_16(AY); 1.9730 + 1.9731 + FLAG_N = NFLAG_16(res); 1.9732 + FLAG_Z = res; 1.9733 + FLAG_V = VFLAG_CLEAR; 1.9734 + FLAG_C = CFLAG_CLEAR; 1.9735 + return; 1.9736 + } 1.9737 + m68ki_exception_illegal(); 1.9738 +} 1.9739 + 1.9740 + 1.9741 +M68KMAKE_OP(tst, 16, ., .) 1.9742 +{ 1.9743 + uint res = M68KMAKE_GET_OPER_AY_16; 1.9744 + 1.9745 + FLAG_N = NFLAG_16(res); 1.9746 + FLAG_Z = res; 1.9747 + FLAG_V = VFLAG_CLEAR; 1.9748 + FLAG_C = CFLAG_CLEAR; 1.9749 +} 1.9750 + 1.9751 + 1.9752 +M68KMAKE_OP(tst, 16, ., pcdi) 1.9753 +{ 1.9754 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9755 + { 1.9756 + uint res = OPER_PCDI_16(); 1.9757 + 1.9758 + FLAG_N = NFLAG_16(res); 1.9759 + FLAG_Z = res; 1.9760 + FLAG_V = VFLAG_CLEAR; 1.9761 + FLAG_C = CFLAG_CLEAR; 1.9762 + return; 1.9763 + } 1.9764 + m68ki_exception_illegal(); 1.9765 +} 1.9766 + 1.9767 + 1.9768 +M68KMAKE_OP(tst, 16, ., pcix) 1.9769 +{ 1.9770 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9771 + { 1.9772 + uint res = OPER_PCIX_16(); 1.9773 + 1.9774 + FLAG_N = NFLAG_16(res); 1.9775 + FLAG_Z = res; 1.9776 + FLAG_V = VFLAG_CLEAR; 1.9777 + FLAG_C = CFLAG_CLEAR; 1.9778 + return; 1.9779 + } 1.9780 + m68ki_exception_illegal(); 1.9781 +} 1.9782 + 1.9783 + 1.9784 +M68KMAKE_OP(tst, 16, ., i) 1.9785 +{ 1.9786 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9787 + { 1.9788 + uint res = OPER_I_16(); 1.9789 + 1.9790 + FLAG_N = NFLAG_16(res); 1.9791 + FLAG_Z = res; 1.9792 + FLAG_V = VFLAG_CLEAR; 1.9793 + FLAG_C = CFLAG_CLEAR; 1.9794 + return; 1.9795 + } 1.9796 + m68ki_exception_illegal(); 1.9797 +} 1.9798 + 1.9799 + 1.9800 +M68KMAKE_OP(tst, 32, ., d) 1.9801 +{ 1.9802 + uint res = DY; 1.9803 + 1.9804 + FLAG_N = NFLAG_32(res); 1.9805 + FLAG_Z = res; 1.9806 + FLAG_V = VFLAG_CLEAR; 1.9807 + FLAG_C = CFLAG_CLEAR; 1.9808 +} 1.9809 + 1.9810 + 1.9811 +M68KMAKE_OP(tst, 32, ., a) 1.9812 +{ 1.9813 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9814 + { 1.9815 + uint res = AY; 1.9816 + 1.9817 + FLAG_N = NFLAG_32(res); 1.9818 + FLAG_Z = res; 1.9819 + FLAG_V = VFLAG_CLEAR; 1.9820 + FLAG_C = CFLAG_CLEAR; 1.9821 + return; 1.9822 + } 1.9823 + m68ki_exception_illegal(); 1.9824 +} 1.9825 + 1.9826 + 1.9827 +M68KMAKE_OP(tst, 32, ., .) 1.9828 +{ 1.9829 + uint res = M68KMAKE_GET_OPER_AY_32; 1.9830 + 1.9831 + FLAG_N = NFLAG_32(res); 1.9832 + FLAG_Z = res; 1.9833 + FLAG_V = VFLAG_CLEAR; 1.9834 + FLAG_C = CFLAG_CLEAR; 1.9835 +} 1.9836 + 1.9837 + 1.9838 +M68KMAKE_OP(tst, 32, ., pcdi) 1.9839 +{ 1.9840 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9841 + { 1.9842 + uint res = OPER_PCDI_32(); 1.9843 + 1.9844 + FLAG_N = NFLAG_32(res); 1.9845 + FLAG_Z = res; 1.9846 + FLAG_V = VFLAG_CLEAR; 1.9847 + FLAG_C = CFLAG_CLEAR; 1.9848 + return; 1.9849 + } 1.9850 + m68ki_exception_illegal(); 1.9851 +} 1.9852 + 1.9853 + 1.9854 +M68KMAKE_OP(tst, 32, ., pcix) 1.9855 +{ 1.9856 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9857 + { 1.9858 + uint res = OPER_PCIX_32(); 1.9859 + 1.9860 + FLAG_N = NFLAG_32(res); 1.9861 + FLAG_Z = res; 1.9862 + FLAG_V = VFLAG_CLEAR; 1.9863 + FLAG_C = CFLAG_CLEAR; 1.9864 + return; 1.9865 + } 1.9866 + m68ki_exception_illegal(); 1.9867 +} 1.9868 + 1.9869 + 1.9870 +M68KMAKE_OP(tst, 32, ., i) 1.9871 +{ 1.9872 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9873 + { 1.9874 + uint res = OPER_I_32(); 1.9875 + 1.9876 + FLAG_N = NFLAG_32(res); 1.9877 + FLAG_Z = res; 1.9878 + FLAG_V = VFLAG_CLEAR; 1.9879 + FLAG_C = CFLAG_CLEAR; 1.9880 + return; 1.9881 + } 1.9882 + m68ki_exception_illegal(); 1.9883 +} 1.9884 + 1.9885 + 1.9886 +M68KMAKE_OP(unlk, 32, ., a7) 1.9887 +{ 1.9888 + REG_A[7] = m68ki_read_32(REG_A[7]); 1.9889 +} 1.9890 + 1.9891 + 1.9892 +M68KMAKE_OP(unlk, 32, ., .) 1.9893 +{ 1.9894 + uint* r_dst = &AY; 1.9895 + 1.9896 + REG_A[7] = *r_dst; 1.9897 + *r_dst = m68ki_pull_32(); 1.9898 +} 1.9899 + 1.9900 + 1.9901 +M68KMAKE_OP(unpk, 16, rr, .) 1.9902 +{ 1.9903 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9904 + { 1.9905 + /* Note: DX and DY are reversed in Motorola's docs */ 1.9906 + uint src = DY; 1.9907 + uint* r_dst = &DX; 1.9908 + 1.9909 + *r_dst = MASK_OUT_BELOW_16(*r_dst) | (((((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16()) & 0xffff); 1.9910 + return; 1.9911 + } 1.9912 + m68ki_exception_illegal(); 1.9913 +} 1.9914 + 1.9915 + 1.9916 +M68KMAKE_OP(unpk, 16, mm, ax7) 1.9917 +{ 1.9918 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9919 + { 1.9920 + /* Note: AX and AY are reversed in Motorola's docs */ 1.9921 + uint src = OPER_AY_PD_8(); 1.9922 + uint ea_dst; 1.9923 + 1.9924 + src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(); 1.9925 + ea_dst = EA_A7_PD_8(); 1.9926 + m68ki_write_8(ea_dst, (src >> 8) & 0xff); 1.9927 + ea_dst = EA_A7_PD_8(); 1.9928 + m68ki_write_8(ea_dst, src & 0xff); 1.9929 + return; 1.9930 + } 1.9931 + m68ki_exception_illegal(); 1.9932 +} 1.9933 + 1.9934 + 1.9935 +M68KMAKE_OP(unpk, 16, mm, ay7) 1.9936 +{ 1.9937 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9938 + { 1.9939 + /* Note: AX and AY are reversed in Motorola's docs */ 1.9940 + uint src = OPER_A7_PD_8(); 1.9941 + uint ea_dst; 1.9942 + 1.9943 + src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(); 1.9944 + ea_dst = EA_AX_PD_8(); 1.9945 + m68ki_write_8(ea_dst, (src >> 8) & 0xff); 1.9946 + ea_dst = EA_AX_PD_8(); 1.9947 + m68ki_write_8(ea_dst, src & 0xff); 1.9948 + return; 1.9949 + } 1.9950 + m68ki_exception_illegal(); 1.9951 +} 1.9952 + 1.9953 + 1.9954 +M68KMAKE_OP(unpk, 16, mm, axy7) 1.9955 +{ 1.9956 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9957 + { 1.9958 + uint src = OPER_A7_PD_8(); 1.9959 + uint ea_dst; 1.9960 + 1.9961 + src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(); 1.9962 + ea_dst = EA_A7_PD_8(); 1.9963 + m68ki_write_8(ea_dst, (src >> 8) & 0xff); 1.9964 + ea_dst = EA_A7_PD_8(); 1.9965 + m68ki_write_8(ea_dst, src & 0xff); 1.9966 + return; 1.9967 + } 1.9968 + m68ki_exception_illegal(); 1.9969 +} 1.9970 + 1.9971 + 1.9972 +M68KMAKE_OP(unpk, 16, mm, .) 1.9973 +{ 1.9974 + if(CPU_TYPE_IS_EC020_PLUS(CPU_TYPE)) 1.9975 + { 1.9976 + /* Note: AX and AY are reversed in Motorola's docs */ 1.9977 + uint src = OPER_AY_PD_8(); 1.9978 + uint ea_dst; 1.9979 + 1.9980 + src = (((src << 4) & 0x0f00) | (src & 0x000f)) + OPER_I_16(); 1.9981 + ea_dst = EA_AX_PD_8(); 1.9982 + m68ki_write_8(ea_dst, (src >> 8) & 0xff); 1.9983 + ea_dst = EA_AX_PD_8(); 1.9984 + m68ki_write_8(ea_dst, src & 0xff); 1.9985 + return; 1.9986 + } 1.9987 + m68ki_exception_illegal(); 1.9988 +} 1.9989 + 1.9990 + 1.9991 + 1.9992 +XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 1.9993 +M68KMAKE_END