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