rl78-decode.c revision 1.1.1.2
1#line 1 "rl78-decode.opc" 2/* -*- c -*- */ 3/* Copyright (C) 2012-2015 Free Software Foundation, Inc. 4 Contributed by Red Hat. 5 Written by DJ Delorie. 6 7 This file is part of the GNU opcodes library. 8 9 This library is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 It is distributed in the hope that it will be useful, but WITHOUT 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 17 License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 22 MA 02110-1301, USA. */ 23 24#include "sysdep.h" 25#include <stdio.h> 26#include <stdlib.h> 27#include <string.h> 28#include "ansidecl.h" 29#include "opcode/rl78.h" 30 31static int trace = 0; 32 33typedef struct 34{ 35 RL78_Opcode_Decoded * rl78; 36 int (* getbyte)(void *); 37 void * ptr; 38 unsigned char * op; 39} LocalData; 40 41#define ID(x) rl78->id = RLO_##x, rl78->lineno = __LINE__ 42#define OP(n,t,r,a) (rl78->op[n].type = t, \ 43 rl78->op[n].reg = r, \ 44 rl78->op[n].addend = a ) 45#define OPX(n,t,r1,r2,a) \ 46 (rl78->op[n].type = t, \ 47 rl78->op[n].reg = r1, \ 48 rl78->op[n].reg2 = r2, \ 49 rl78->op[n].addend = a ) 50 51#define W() rl78->size = RL78_Word 52 53#define AU ATTRIBUTE_UNUSED 54#define GETBYTE() (ld->op [ld->rl78->n_bytes++] = ld->getbyte (ld->ptr)) 55#define B ((unsigned long) GETBYTE()) 56 57#define SYNTAX(x) rl78->syntax = x 58 59#define UNSUPPORTED() \ 60 rl78->syntax = "*unknown*" 61 62#define RB(x) ((x)+RL78_Reg_X) 63#define RW(x) ((x)+RL78_Reg_AX) 64 65#define Fz rl78->flags = RL78_PSW_Z 66#define Fza rl78->flags = RL78_PSW_Z | RL78_PSW_AC 67#define Fzc rl78->flags = RL78_PSW_Z | RL78_PSW_CY 68#define Fzac rl78->flags = RL78_PSW_Z | RL78_PSW_AC | RL78_PSW_CY 69#define Fa rl78->flags = RL78_PSW_AC 70#define Fc rl78->flags = RL78_PSW_CY 71#define Fac rl78->flags = RL78_PSW_AC | RL78_PSW_CY 72 73#define IMMU(bytes) immediate (bytes, 0, ld) 74#define IMMS(bytes) immediate (bytes, 1, ld) 75 76static int 77immediate (int bytes, int sign_extend, LocalData * ld) 78{ 79 unsigned long i = 0; 80 81 switch (bytes) 82 { 83 case 1: 84 i |= B; 85 if (sign_extend && (i & 0x80)) 86 i -= 0x100; 87 break; 88 case 2: 89 i |= B; 90 i |= B << 8; 91 if (sign_extend && (i & 0x8000)) 92 i -= 0x10000; 93 break; 94 case 3: 95 i |= B; 96 i |= B << 8; 97 i |= B << 16; 98 if (sign_extend && (i & 0x800000)) 99 i -= 0x1000000; 100 break; 101 default: 102 fprintf (stderr, "Programmer error: immediate() called with invalid byte count %d\n", bytes); 103 abort(); 104 } 105 return i; 106} 107 108#define DC(c) OP (0, RL78_Operand_Immediate, 0, c) 109#define DR(r) OP (0, RL78_Operand_Register, RL78_Reg_##r, 0) 110#define DRB(r) OP (0, RL78_Operand_Register, RB(r), 0) 111#define DRW(r) OP (0, RL78_Operand_Register, RW(r), 0) 112#define DM(r,a) OP (0, RL78_Operand_Indirect, RL78_Reg_##r, a) 113#define DM2(r1,r2,a) OPX (0, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a) 114#define DE() rl78->op[0].use_es = 1 115#define DB(b) set_bit (rl78->op, b) 116#define DCY() DR(PSW); DB(0) 117#define DPUSH() OP (0, RL78_Operand_PreDec, RL78_Reg_SP, 0); 118 119#define SC(c) OP (1, RL78_Operand_Immediate, 0, c) 120#define SR(r) OP (1, RL78_Operand_Register, RL78_Reg_##r, 0) 121#define SRB(r) OP (1, RL78_Operand_Register, RB(r), 0) 122#define SRW(r) OP (1, RL78_Operand_Register, RW(r), 0) 123#define SM(r,a) OP (1, RL78_Operand_Indirect, RL78_Reg_##r, a) 124#define SM2(r1,r2,a) OPX (1, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a) 125#define SE() rl78->op[1].use_es = 1 126#define SB(b) set_bit (rl78->op+1, b) 127#define SCY() SR(PSW); SB(0) 128#define COND(c) rl78->op[1].condition = RL78_Condition_##c 129#define SPOP() OP (1, RL78_Operand_PostInc, RL78_Reg_SP, 0); 130 131static void 132set_bit (RL78_Opcode_Operand *op, int bit) 133{ 134 op->bit_number = bit; 135 switch (op->type) { 136 case RL78_Operand_Register: 137 op->type = RL78_Operand_Bit; 138 break; 139 case RL78_Operand_Indirect: 140 op->type = RL78_Operand_BitIndirect; 141 break; 142 default: 143 break; 144 } 145} 146 147static int 148saddr (int x) 149{ 150 if (x < 0x20) 151 return 0xfff00 + x; 152 return 0xffe00 + x; 153} 154 155static int 156sfr (int x) 157{ 158 return 0xfff00 + x; 159} 160 161#define SADDR saddr (IMMU (1)) 162#define SFR sfr (IMMU (1)) 163 164int 165rl78_decode_opcode (unsigned long pc AU, 166 RL78_Opcode_Decoded * rl78, 167 int (* getbyte)(void *), 168 void * ptr) 169{ 170 LocalData lds, * ld = &lds; 171 unsigned char op_buf[20] = {0}; 172 unsigned char *op = op_buf; 173 int op0, op1; 174 175 lds.rl78 = rl78; 176 lds.getbyte = getbyte; 177 lds.ptr = ptr; 178 lds.op = op; 179 180 memset (rl78, 0, sizeof (*rl78)); 181 182 start_again: 183 184/* Byte registers, not including A. */ 185/* Word registers, not including AX. */ 186 187/*----------------------------------------------------------------------*/ 188/* ES: prefix */ 189 190 GETBYTE (); 191 switch (op[0] & 0xff) 192 { 193 case 0x00: 194 { 195 /** 0000 0000 nop */ 196 if (trace) 197 { 198 printf ("\033[33m%s\033[0m %02x\n", 199 "/** 0000 0000 nop */", 200 op[0]); 201 } 202 SYNTAX("nop"); 203#line 910 "rl78-decode.opc" 204 ID(nop); 205 206 /*----------------------------------------------------------------------*/ 207 208 } 209 break; 210 case 0x01: 211 case 0x03: 212 case 0x05: 213 case 0x07: 214 { 215 /** 0000 0rw1 addw %0, %1 */ 216#line 273 "rl78-decode.opc" 217 int rw AU = (op[0] >> 1) & 0x03; 218 if (trace) 219 { 220 printf ("\033[33m%s\033[0m %02x\n", 221 "/** 0000 0rw1 addw %0, %1 */", 222 op[0]); 223 printf (" rw = 0x%x\n", rw); 224 } 225 SYNTAX("addw %0, %1"); 226#line 273 "rl78-decode.opc" 227 ID(add); W(); DR(AX); SRW(rw); Fzac; 228 229 } 230 break; 231 case 0x02: 232 { 233 /** 0000 0010 addw %0, %e!1 */ 234 if (trace) 235 { 236 printf ("\033[33m%s\033[0m %02x\n", 237 "/** 0000 0010 addw %0, %e!1 */", 238 op[0]); 239 } 240 SYNTAX("addw %0, %e!1"); 241#line 264 "rl78-decode.opc" 242 ID(add); W(); DR(AX); SM(None, IMMU(2)); Fzac; 243 244 } 245 break; 246 case 0x04: 247 { 248 /** 0000 0100 addw %0, #%1 */ 249 if (trace) 250 { 251 printf ("\033[33m%s\033[0m %02x\n", 252 "/** 0000 0100 addw %0, #%1 */", 253 op[0]); 254 } 255 SYNTAX("addw %0, #%1"); 256#line 270 "rl78-decode.opc" 257 ID(add); W(); DR(AX); SC(IMMU(2)); Fzac; 258 259 } 260 break; 261 case 0x06: 262 { 263 /** 0000 0110 addw %0, %1 */ 264 if (trace) 265 { 266 printf ("\033[33m%s\033[0m %02x\n", 267 "/** 0000 0110 addw %0, %1 */", 268 op[0]); 269 } 270 SYNTAX("addw %0, %1"); 271#line 276 "rl78-decode.opc" 272 ID(add); W(); DR(AX); SM(None, SADDR); Fzac; 273 274 } 275 break; 276 case 0x08: 277 { 278 /** 0000 1000 xch a, x */ 279 if (trace) 280 { 281 printf ("\033[33m%s\033[0m %02x\n", 282 "/** 0000 1000 xch a, x */", 283 op[0]); 284 } 285 SYNTAX("xch a, x"); 286#line 1233 "rl78-decode.opc" 287 ID(xch); DR(A); SR(X); 288 289 /*----------------------------------------------------------------------*/ 290 291 } 292 break; 293 case 0x09: 294 { 295 /** 0000 1001 mov %0, %e1 */ 296 if (trace) 297 { 298 printf ("\033[33m%s\033[0m %02x\n", 299 "/** 0000 1001 mov %0, %e1 */", 300 op[0]); 301 } 302 SYNTAX("mov %0, %e1"); 303#line 677 "rl78-decode.opc" 304 ID(mov); DR(A); SM(B, IMMU(2)); 305 306 } 307 break; 308 case 0x0a: 309 { 310 /** 0000 1010 add %0, #%1 */ 311 if (trace) 312 { 313 printf ("\033[33m%s\033[0m %02x\n", 314 "/** 0000 1010 add %0, #%1 */", 315 op[0]); 316 } 317 SYNTAX("add %0, #%1"); 318#line 227 "rl78-decode.opc" 319 ID(add); DM(None, SADDR); SC(IMMU(1)); Fzac; 320 321 /*----------------------------------------------------------------------*/ 322 323 } 324 break; 325 case 0x0b: 326 { 327 /** 0000 1011 add %0, %1 */ 328 if (trace) 329 { 330 printf ("\033[33m%s\033[0m %02x\n", 331 "/** 0000 1011 add %0, %1 */", 332 op[0]); 333 } 334 SYNTAX("add %0, %1"); 335#line 221 "rl78-decode.opc" 336 ID(add); DR(A); SM(None, SADDR); Fzac; 337 338 } 339 break; 340 case 0x0c: 341 { 342 /** 0000 1100 add %0, #%1 */ 343 if (trace) 344 { 345 printf ("\033[33m%s\033[0m %02x\n", 346 "/** 0000 1100 add %0, #%1 */", 347 op[0]); 348 } 349 SYNTAX("add %0, #%1"); 350#line 215 "rl78-decode.opc" 351 ID(add); DR(A); SC(IMMU(1)); Fzac; 352 353 } 354 break; 355 case 0x0d: 356 { 357 /** 0000 1101 add %0, %e1 */ 358 if (trace) 359 { 360 printf ("\033[33m%s\033[0m %02x\n", 361 "/** 0000 1101 add %0, %e1 */", 362 op[0]); 363 } 364 SYNTAX("add %0, %e1"); 365#line 203 "rl78-decode.opc" 366 ID(add); DR(A); SM(HL, 0); Fzac; 367 368 } 369 break; 370 case 0x0e: 371 { 372 /** 0000 1110 add %0, %e1 */ 373 if (trace) 374 { 375 printf ("\033[33m%s\033[0m %02x\n", 376 "/** 0000 1110 add %0, %e1 */", 377 op[0]); 378 } 379 SYNTAX("add %0, %e1"); 380#line 209 "rl78-decode.opc" 381 ID(add); DR(A); SM(HL, IMMU(1)); Fzac; 382 383 } 384 break; 385 case 0x0f: 386 { 387 /** 0000 1111 add %0, %e!1 */ 388 if (trace) 389 { 390 printf ("\033[33m%s\033[0m %02x\n", 391 "/** 0000 1111 add %0, %e!1 */", 392 op[0]); 393 } 394 SYNTAX("add %0, %e!1"); 395#line 200 "rl78-decode.opc" 396 ID(add); DR(A); SM(None, IMMU(2)); Fzac; 397 398 } 399 break; 400 case 0x10: 401 { 402 /** 0001 0000 addw %0, #%1 */ 403 if (trace) 404 { 405 printf ("\033[33m%s\033[0m %02x\n", 406 "/** 0001 0000 addw %0, #%1 */", 407 op[0]); 408 } 409 SYNTAX("addw %0, #%1"); 410#line 279 "rl78-decode.opc" 411 ID(add); W(); DR(SP); SC(IMMU(1)); Fzac; 412 413 /*----------------------------------------------------------------------*/ 414 415 } 416 break; 417 case 0x11: 418 { 419 /** 0001 0001 es: */ 420 if (trace) 421 { 422 printf ("\033[33m%s\033[0m %02x\n", 423 "/** 0001 0001 es: */", 424 op[0]); 425 } 426 SYNTAX("es:"); 427#line 192 "rl78-decode.opc" 428 DE(); SE(); 429 op ++; 430 pc ++; 431 goto start_again; 432 433 /*----------------------------------------------------------------------*/ 434 435 } 436 break; 437 case 0x12: 438 case 0x14: 439 case 0x16: 440 { 441 /** 0001 0ra0 movw %0, %1 */ 442#line 858 "rl78-decode.opc" 443 int ra AU = (op[0] >> 1) & 0x03; 444 if (trace) 445 { 446 printf ("\033[33m%s\033[0m %02x\n", 447 "/** 0001 0ra0 movw %0, %1 */", 448 op[0]); 449 printf (" ra = 0x%x\n", ra); 450 } 451 SYNTAX("movw %0, %1"); 452#line 858 "rl78-decode.opc" 453 ID(mov); W(); DRW(ra); SR(AX); 454 455 } 456 break; 457 case 0x13: 458 case 0x15: 459 case 0x17: 460 { 461 /** 0001 0ra1 movw %0, %1 */ 462#line 855 "rl78-decode.opc" 463 int ra AU = (op[0] >> 1) & 0x03; 464 if (trace) 465 { 466 printf ("\033[33m%s\033[0m %02x\n", 467 "/** 0001 0ra1 movw %0, %1 */", 468 op[0]); 469 printf (" ra = 0x%x\n", ra); 470 } 471 SYNTAX("movw %0, %1"); 472#line 855 "rl78-decode.opc" 473 ID(mov); W(); DR(AX); SRW(ra); 474 475 } 476 break; 477 case 0x18: 478 { 479 /** 0001 1000 mov %e0, %1 */ 480 if (trace) 481 { 482 printf ("\033[33m%s\033[0m %02x\n", 483 "/** 0001 1000 mov %e0, %1 */", 484 op[0]); 485 } 486 SYNTAX("mov %e0, %1"); 487#line 728 "rl78-decode.opc" 488 ID(mov); DM(B, IMMU(2)); SR(A); 489 490 } 491 break; 492 case 0x19: 493 { 494 /** 0001 1001 mov %e0, #%1 */ 495 if (trace) 496 { 497 printf ("\033[33m%s\033[0m %02x\n", 498 "/** 0001 1001 mov %e0, #%1 */", 499 op[0]); 500 } 501 SYNTAX("mov %e0, #%1"); 502#line 725 "rl78-decode.opc" 503 ID(mov); DM(B, IMMU(2)); SC(IMMU(1)); 504 505 } 506 break; 507 case 0x1a: 508 { 509 /** 0001 1010 addc %0, #%1 */ 510 if (trace) 511 { 512 printf ("\033[33m%s\033[0m %02x\n", 513 "/** 0001 1010 addc %0, #%1 */", 514 op[0]); 515 } 516 SYNTAX("addc %0, #%1"); 517#line 259 "rl78-decode.opc" 518 ID(addc); DM(None, SADDR); SC(IMMU(1)); Fzac; 519 520 /*----------------------------------------------------------------------*/ 521 522 } 523 break; 524 case 0x1b: 525 { 526 /** 0001 1011 addc %0, %1 */ 527 if (trace) 528 { 529 printf ("\033[33m%s\033[0m %02x\n", 530 "/** 0001 1011 addc %0, %1 */", 531 op[0]); 532 } 533 SYNTAX("addc %0, %1"); 534#line 256 "rl78-decode.opc" 535 ID(addc); DR(A); SM(None, SADDR); Fzac; 536 537 } 538 break; 539 case 0x1c: 540 { 541 /** 0001 1100 addc %0, #%1 */ 542 if (trace) 543 { 544 printf ("\033[33m%s\033[0m %02x\n", 545 "/** 0001 1100 addc %0, #%1 */", 546 op[0]); 547 } 548 SYNTAX("addc %0, #%1"); 549#line 247 "rl78-decode.opc" 550 ID(addc); DR(A); SC(IMMU(1)); Fzac; 551 552 } 553 break; 554 case 0x1d: 555 { 556 /** 0001 1101 addc %0, %e1 */ 557 if (trace) 558 { 559 printf ("\033[33m%s\033[0m %02x\n", 560 "/** 0001 1101 addc %0, %e1 */", 561 op[0]); 562 } 563 SYNTAX("addc %0, %e1"); 564#line 235 "rl78-decode.opc" 565 ID(addc); DR(A); SM(HL, 0); Fzac; 566 567 } 568 break; 569 case 0x1e: 570 { 571 /** 0001 1110 addc %0, %e1 */ 572 if (trace) 573 { 574 printf ("\033[33m%s\033[0m %02x\n", 575 "/** 0001 1110 addc %0, %e1 */", 576 op[0]); 577 } 578 SYNTAX("addc %0, %e1"); 579#line 244 "rl78-decode.opc" 580 ID(addc); DR(A); SM(HL, IMMU(1)); Fzac; 581 582 } 583 break; 584 case 0x1f: 585 { 586 /** 0001 1111 addc %0, %e!1 */ 587 if (trace) 588 { 589 printf ("\033[33m%s\033[0m %02x\n", 590 "/** 0001 1111 addc %0, %e!1 */", 591 op[0]); 592 } 593 SYNTAX("addc %0, %e!1"); 594#line 232 "rl78-decode.opc" 595 ID(addc); DR(A); SM(None, IMMU(2)); Fzac; 596 597 } 598 break; 599 case 0x20: 600 { 601 /** 0010 0000 subw %0, #%1 */ 602 if (trace) 603 { 604 printf ("\033[33m%s\033[0m %02x\n", 605 "/** 0010 0000 subw %0, #%1 */", 606 op[0]); 607 } 608 SYNTAX("subw %0, #%1"); 609#line 1197 "rl78-decode.opc" 610 ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac; 611 612 /*----------------------------------------------------------------------*/ 613 614 } 615 break; 616 case 0x21: 617 case 0x23: 618 case 0x25: 619 case 0x27: 620 { 621 /** 0010 0rw1 subw %0, %1 */ 622#line 1191 "rl78-decode.opc" 623 int rw AU = (op[0] >> 1) & 0x03; 624 if (trace) 625 { 626 printf ("\033[33m%s\033[0m %02x\n", 627 "/** 0010 0rw1 subw %0, %1 */", 628 op[0]); 629 printf (" rw = 0x%x\n", rw); 630 } 631 SYNTAX("subw %0, %1"); 632#line 1191 "rl78-decode.opc" 633 ID(sub); W(); DR(AX); SRW(rw); Fzac; 634 635 } 636 break; 637 case 0x22: 638 { 639 /** 0010 0010 subw %0, %e!1 */ 640 if (trace) 641 { 642 printf ("\033[33m%s\033[0m %02x\n", 643 "/** 0010 0010 subw %0, %e!1 */", 644 op[0]); 645 } 646 SYNTAX("subw %0, %e!1"); 647#line 1182 "rl78-decode.opc" 648 ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac; 649 650 } 651 break; 652 case 0x24: 653 { 654 /** 0010 0100 subw %0, #%1 */ 655 if (trace) 656 { 657 printf ("\033[33m%s\033[0m %02x\n", 658 "/** 0010 0100 subw %0, #%1 */", 659 op[0]); 660 } 661 SYNTAX("subw %0, #%1"); 662#line 1188 "rl78-decode.opc" 663 ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac; 664 665 } 666 break; 667 case 0x26: 668 { 669 /** 0010 0110 subw %0, %1 */ 670 if (trace) 671 { 672 printf ("\033[33m%s\033[0m %02x\n", 673 "/** 0010 0110 subw %0, %1 */", 674 op[0]); 675 } 676 SYNTAX("subw %0, %1"); 677#line 1194 "rl78-decode.opc" 678 ID(sub); W(); DR(AX); SM(None, SADDR); Fzac; 679 680 } 681 break; 682 case 0x28: 683 { 684 /** 0010 1000 mov %e0, %1 */ 685 if (trace) 686 { 687 printf ("\033[33m%s\033[0m %02x\n", 688 "/** 0010 1000 mov %e0, %1 */", 689 op[0]); 690 } 691 SYNTAX("mov %e0, %1"); 692#line 740 "rl78-decode.opc" 693 ID(mov); DM(C, IMMU(2)); SR(A); 694 695 } 696 break; 697 case 0x29: 698 { 699 /** 0010 1001 mov %0, %e1 */ 700 if (trace) 701 { 702 printf ("\033[33m%s\033[0m %02x\n", 703 "/** 0010 1001 mov %0, %e1 */", 704 op[0]); 705 } 706 SYNTAX("mov %0, %e1"); 707#line 683 "rl78-decode.opc" 708 ID(mov); DR(A); SM(C, IMMU(2)); 709 710 } 711 break; 712 case 0x2a: 713 { 714 /** 0010 1010 sub %0, #%1 */ 715 if (trace) 716 { 717 printf ("\033[33m%s\033[0m %02x\n", 718 "/** 0010 1010 sub %0, #%1 */", 719 op[0]); 720 } 721 SYNTAX("sub %0, #%1"); 722#line 1145 "rl78-decode.opc" 723 ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac; 724 725 /*----------------------------------------------------------------------*/ 726 727 } 728 break; 729 case 0x2b: 730 { 731 /** 0010 1011 sub %0, %1 */ 732 if (trace) 733 { 734 printf ("\033[33m%s\033[0m %02x\n", 735 "/** 0010 1011 sub %0, %1 */", 736 op[0]); 737 } 738 SYNTAX("sub %0, %1"); 739#line 1139 "rl78-decode.opc" 740 ID(sub); DR(A); SM(None, SADDR); Fzac; 741 742 } 743 break; 744 case 0x2c: 745 { 746 /** 0010 1100 sub %0, #%1 */ 747 if (trace) 748 { 749 printf ("\033[33m%s\033[0m %02x\n", 750 "/** 0010 1100 sub %0, #%1 */", 751 op[0]); 752 } 753 SYNTAX("sub %0, #%1"); 754#line 1133 "rl78-decode.opc" 755 ID(sub); DR(A); SC(IMMU(1)); Fzac; 756 757 } 758 break; 759 case 0x2d: 760 { 761 /** 0010 1101 sub %0, %e1 */ 762 if (trace) 763 { 764 printf ("\033[33m%s\033[0m %02x\n", 765 "/** 0010 1101 sub %0, %e1 */", 766 op[0]); 767 } 768 SYNTAX("sub %0, %e1"); 769#line 1121 "rl78-decode.opc" 770 ID(sub); DR(A); SM(HL, 0); Fzac; 771 772 } 773 break; 774 case 0x2e: 775 { 776 /** 0010 1110 sub %0, %e1 */ 777 if (trace) 778 { 779 printf ("\033[33m%s\033[0m %02x\n", 780 "/** 0010 1110 sub %0, %e1 */", 781 op[0]); 782 } 783 SYNTAX("sub %0, %e1"); 784#line 1127 "rl78-decode.opc" 785 ID(sub); DR(A); SM(HL, IMMU(1)); Fzac; 786 787 } 788 break; 789 case 0x2f: 790 { 791 /** 0010 1111 sub %0, %e!1 */ 792 if (trace) 793 { 794 printf ("\033[33m%s\033[0m %02x\n", 795 "/** 0010 1111 sub %0, %e!1 */", 796 op[0]); 797 } 798 SYNTAX("sub %0, %e!1"); 799#line 1118 "rl78-decode.opc" 800 ID(sub); DR(A); SM(None, IMMU(2)); Fzac; 801 802 } 803 break; 804 case 0x30: 805 case 0x32: 806 case 0x34: 807 case 0x36: 808 { 809 /** 0011 0rg0 movw %0, #%1 */ 810#line 852 "rl78-decode.opc" 811 int rg AU = (op[0] >> 1) & 0x03; 812 if (trace) 813 { 814 printf ("\033[33m%s\033[0m %02x\n", 815 "/** 0011 0rg0 movw %0, #%1 */", 816 op[0]); 817 printf (" rg = 0x%x\n", rg); 818 } 819 SYNTAX("movw %0, #%1"); 820#line 852 "rl78-decode.opc" 821 ID(mov); W(); DRW(rg); SC(IMMU(2)); 822 823 } 824 break; 825 case 0x31: 826 GETBYTE (); 827 switch (op[1] & 0x8f) 828 { 829 case 0x00: 830 { 831 /** 0011 0001 0bit 0000 btclr %s1, $%a0 */ 832#line 415 "rl78-decode.opc" 833 int bit AU = (op[1] >> 4) & 0x07; 834 if (trace) 835 { 836 printf ("\033[33m%s\033[0m %02x %02x\n", 837 "/** 0011 0001 0bit 0000 btclr %s1, $%a0 */", 838 op[0], op[1]); 839 printf (" bit = 0x%x\n", bit); 840 } 841 SYNTAX("btclr %s1, $%a0"); 842#line 415 "rl78-decode.opc" 843 ID(branch_cond_clear); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T); 844 845 /*----------------------------------------------------------------------*/ 846 847 } 848 break; 849 case 0x01: 850 { 851 /** 0011 0001 0bit 0001 btclr %1, $%a0 */ 852#line 409 "rl78-decode.opc" 853 int bit AU = (op[1] >> 4) & 0x07; 854 if (trace) 855 { 856 printf ("\033[33m%s\033[0m %02x %02x\n", 857 "/** 0011 0001 0bit 0001 btclr %1, $%a0 */", 858 op[0], op[1]); 859 printf (" bit = 0x%x\n", bit); 860 } 861 SYNTAX("btclr %1, $%a0"); 862#line 409 "rl78-decode.opc" 863 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T); 864 865 } 866 break; 867 case 0x02: 868 { 869 /** 0011 0001 0bit 0010 bt %s1, $%a0 */ 870#line 401 "rl78-decode.opc" 871 int bit AU = (op[1] >> 4) & 0x07; 872 if (trace) 873 { 874 printf ("\033[33m%s\033[0m %02x %02x\n", 875 "/** 0011 0001 0bit 0010 bt %s1, $%a0 */", 876 op[0], op[1]); 877 printf (" bit = 0x%x\n", bit); 878 } 879 SYNTAX("bt %s1, $%a0"); 880#line 401 "rl78-decode.opc" 881 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T); 882 883 /*----------------------------------------------------------------------*/ 884 885 } 886 break; 887 case 0x03: 888 { 889 /** 0011 0001 0bit 0011 bt %1, $%a0 */ 890#line 395 "rl78-decode.opc" 891 int bit AU = (op[1] >> 4) & 0x07; 892 if (trace) 893 { 894 printf ("\033[33m%s\033[0m %02x %02x\n", 895 "/** 0011 0001 0bit 0011 bt %1, $%a0 */", 896 op[0], op[1]); 897 printf (" bit = 0x%x\n", bit); 898 } 899 SYNTAX("bt %1, $%a0"); 900#line 395 "rl78-decode.opc" 901 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T); 902 903 } 904 break; 905 case 0x04: 906 { 907 /** 0011 0001 0bit 0100 bf %s1, $%a0 */ 908#line 362 "rl78-decode.opc" 909 int bit AU = (op[1] >> 4) & 0x07; 910 if (trace) 911 { 912 printf ("\033[33m%s\033[0m %02x %02x\n", 913 "/** 0011 0001 0bit 0100 bf %s1, $%a0 */", 914 op[0], op[1]); 915 printf (" bit = 0x%x\n", bit); 916 } 917 SYNTAX("bf %s1, $%a0"); 918#line 362 "rl78-decode.opc" 919 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(F); 920 921 /*----------------------------------------------------------------------*/ 922 923 } 924 break; 925 case 0x05: 926 { 927 /** 0011 0001 0bit 0101 bf %1, $%a0 */ 928#line 356 "rl78-decode.opc" 929 int bit AU = (op[1] >> 4) & 0x07; 930 if (trace) 931 { 932 printf ("\033[33m%s\033[0m %02x %02x\n", 933 "/** 0011 0001 0bit 0101 bf %1, $%a0 */", 934 op[0], op[1]); 935 printf (" bit = 0x%x\n", bit); 936 } 937 SYNTAX("bf %1, $%a0"); 938#line 356 "rl78-decode.opc" 939 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F); 940 941 } 942 break; 943 case 0x07: 944 { 945 /** 0011 0001 0cnt 0111 shl %0, %1 */ 946#line 1074 "rl78-decode.opc" 947 int cnt AU = (op[1] >> 4) & 0x07; 948 if (trace) 949 { 950 printf ("\033[33m%s\033[0m %02x %02x\n", 951 "/** 0011 0001 0cnt 0111 shl %0, %1 */", 952 op[0], op[1]); 953 printf (" cnt = 0x%x\n", cnt); 954 } 955 SYNTAX("shl %0, %1"); 956#line 1074 "rl78-decode.opc" 957 ID(shl); DR(C); SC(cnt); 958 959 } 960 break; 961 case 0x08: 962 { 963 /** 0011 0001 0cnt 1000 shl %0, %1 */ 964#line 1071 "rl78-decode.opc" 965 int cnt AU = (op[1] >> 4) & 0x07; 966 if (trace) 967 { 968 printf ("\033[33m%s\033[0m %02x %02x\n", 969 "/** 0011 0001 0cnt 1000 shl %0, %1 */", 970 op[0], op[1]); 971 printf (" cnt = 0x%x\n", cnt); 972 } 973 SYNTAX("shl %0, %1"); 974#line 1071 "rl78-decode.opc" 975 ID(shl); DR(B); SC(cnt); 976 977 } 978 break; 979 case 0x09: 980 { 981 /** 0011 0001 0cnt 1001 shl %0, %1 */ 982#line 1068 "rl78-decode.opc" 983 int cnt AU = (op[1] >> 4) & 0x07; 984 if (trace) 985 { 986 printf ("\033[33m%s\033[0m %02x %02x\n", 987 "/** 0011 0001 0cnt 1001 shl %0, %1 */", 988 op[0], op[1]); 989 printf (" cnt = 0x%x\n", cnt); 990 } 991 SYNTAX("shl %0, %1"); 992#line 1068 "rl78-decode.opc" 993 ID(shl); DR(A); SC(cnt); 994 995 } 996 break; 997 case 0x0a: 998 { 999 /** 0011 0001 0cnt 1010 shr %0, %1 */ 1000#line 1085 "rl78-decode.opc" 1001 int cnt AU = (op[1] >> 4) & 0x07; 1002 if (trace) 1003 { 1004 printf ("\033[33m%s\033[0m %02x %02x\n", 1005 "/** 0011 0001 0cnt 1010 shr %0, %1 */", 1006 op[0], op[1]); 1007 printf (" cnt = 0x%x\n", cnt); 1008 } 1009 SYNTAX("shr %0, %1"); 1010#line 1085 "rl78-decode.opc" 1011 ID(shr); DR(A); SC(cnt); 1012 1013 } 1014 break; 1015 case 0x0b: 1016 { 1017 /** 0011 0001 0cnt 1011 sar %0, %1 */ 1018#line 1032 "rl78-decode.opc" 1019 int cnt AU = (op[1] >> 4) & 0x07; 1020 if (trace) 1021 { 1022 printf ("\033[33m%s\033[0m %02x %02x\n", 1023 "/** 0011 0001 0cnt 1011 sar %0, %1 */", 1024 op[0], op[1]); 1025 printf (" cnt = 0x%x\n", cnt); 1026 } 1027 SYNTAX("sar %0, %1"); 1028#line 1032 "rl78-decode.opc" 1029 ID(sar); DR(A); SC(cnt); 1030 1031 } 1032 break; 1033 case 0x0c: 1034 case 0x8c: 1035 { 1036 /** 0011 0001 wcnt 1100 shlw %0, %1 */ 1037#line 1080 "rl78-decode.opc" 1038 int wcnt AU = (op[1] >> 4) & 0x0f; 1039 if (trace) 1040 { 1041 printf ("\033[33m%s\033[0m %02x %02x\n", 1042 "/** 0011 0001 wcnt 1100 shlw %0, %1 */", 1043 op[0], op[1]); 1044 printf (" wcnt = 0x%x\n", wcnt); 1045 } 1046 SYNTAX("shlw %0, %1"); 1047#line 1080 "rl78-decode.opc" 1048 ID(shl); W(); DR(BC); SC(wcnt); 1049 1050 /*----------------------------------------------------------------------*/ 1051 1052 } 1053 break; 1054 case 0x0d: 1055 case 0x8d: 1056 { 1057 /** 0011 0001 wcnt 1101 shlw %0, %1 */ 1058#line 1077 "rl78-decode.opc" 1059 int wcnt AU = (op[1] >> 4) & 0x0f; 1060 if (trace) 1061 { 1062 printf ("\033[33m%s\033[0m %02x %02x\n", 1063 "/** 0011 0001 wcnt 1101 shlw %0, %1 */", 1064 op[0], op[1]); 1065 printf (" wcnt = 0x%x\n", wcnt); 1066 } 1067 SYNTAX("shlw %0, %1"); 1068#line 1077 "rl78-decode.opc" 1069 ID(shl); W(); DR(AX); SC(wcnt); 1070 1071 } 1072 break; 1073 case 0x0e: 1074 case 0x8e: 1075 { 1076 /** 0011 0001 wcnt 1110 shrw %0, %1 */ 1077#line 1088 "rl78-decode.opc" 1078 int wcnt AU = (op[1] >> 4) & 0x0f; 1079 if (trace) 1080 { 1081 printf ("\033[33m%s\033[0m %02x %02x\n", 1082 "/** 0011 0001 wcnt 1110 shrw %0, %1 */", 1083 op[0], op[1]); 1084 printf (" wcnt = 0x%x\n", wcnt); 1085 } 1086 SYNTAX("shrw %0, %1"); 1087#line 1088 "rl78-decode.opc" 1088 ID(shr); W(); DR(AX); SC(wcnt); 1089 1090 /*----------------------------------------------------------------------*/ 1091 1092 } 1093 break; 1094 case 0x0f: 1095 case 0x8f: 1096 { 1097 /** 0011 0001 wcnt 1111 sarw %0, %1 */ 1098#line 1035 "rl78-decode.opc" 1099 int wcnt AU = (op[1] >> 4) & 0x0f; 1100 if (trace) 1101 { 1102 printf ("\033[33m%s\033[0m %02x %02x\n", 1103 "/** 0011 0001 wcnt 1111 sarw %0, %1 */", 1104 op[0], op[1]); 1105 printf (" wcnt = 0x%x\n", wcnt); 1106 } 1107 SYNTAX("sarw %0, %1"); 1108#line 1035 "rl78-decode.opc" 1109 ID(sar); W(); DR(AX); SC(wcnt); 1110 1111 /*----------------------------------------------------------------------*/ 1112 1113 } 1114 break; 1115 case 0x80: 1116 { 1117 /** 0011 0001 1bit 0000 btclr %s1, $%a0 */ 1118#line 412 "rl78-decode.opc" 1119 int bit AU = (op[1] >> 4) & 0x07; 1120 if (trace) 1121 { 1122 printf ("\033[33m%s\033[0m %02x %02x\n", 1123 "/** 0011 0001 1bit 0000 btclr %s1, $%a0 */", 1124 op[0], op[1]); 1125 printf (" bit = 0x%x\n", bit); 1126 } 1127 SYNTAX("btclr %s1, $%a0"); 1128#line 412 "rl78-decode.opc" 1129 ID(branch_cond_clear); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T); 1130 1131 } 1132 break; 1133 case 0x81: 1134 { 1135 /** 0011 0001 1bit 0001 btclr %e1, $%a0 */ 1136#line 406 "rl78-decode.opc" 1137 int bit AU = (op[1] >> 4) & 0x07; 1138 if (trace) 1139 { 1140 printf ("\033[33m%s\033[0m %02x %02x\n", 1141 "/** 0011 0001 1bit 0001 btclr %e1, $%a0 */", 1142 op[0], op[1]); 1143 printf (" bit = 0x%x\n", bit); 1144 } 1145 SYNTAX("btclr %e1, $%a0"); 1146#line 406 "rl78-decode.opc" 1147 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T); 1148 1149 } 1150 break; 1151 case 0x82: 1152 { 1153 /** 0011 0001 1bit 0010 bt %s1, $%a0 */ 1154#line 398 "rl78-decode.opc" 1155 int bit AU = (op[1] >> 4) & 0x07; 1156 if (trace) 1157 { 1158 printf ("\033[33m%s\033[0m %02x %02x\n", 1159 "/** 0011 0001 1bit 0010 bt %s1, $%a0 */", 1160 op[0], op[1]); 1161 printf (" bit = 0x%x\n", bit); 1162 } 1163 SYNTAX("bt %s1, $%a0"); 1164#line 398 "rl78-decode.opc" 1165 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T); 1166 1167 } 1168 break; 1169 case 0x83: 1170 { 1171 /** 0011 0001 1bit 0011 bt %e1, $%a0 */ 1172#line 392 "rl78-decode.opc" 1173 int bit AU = (op[1] >> 4) & 0x07; 1174 if (trace) 1175 { 1176 printf ("\033[33m%s\033[0m %02x %02x\n", 1177 "/** 0011 0001 1bit 0011 bt %e1, $%a0 */", 1178 op[0], op[1]); 1179 printf (" bit = 0x%x\n", bit); 1180 } 1181 SYNTAX("bt %e1, $%a0"); 1182#line 392 "rl78-decode.opc" 1183 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T); 1184 1185 } 1186 break; 1187 case 0x84: 1188 { 1189 /** 0011 0001 1bit 0100 bf %s1, $%a0 */ 1190#line 359 "rl78-decode.opc" 1191 int bit AU = (op[1] >> 4) & 0x07; 1192 if (trace) 1193 { 1194 printf ("\033[33m%s\033[0m %02x %02x\n", 1195 "/** 0011 0001 1bit 0100 bf %s1, $%a0 */", 1196 op[0], op[1]); 1197 printf (" bit = 0x%x\n", bit); 1198 } 1199 SYNTAX("bf %s1, $%a0"); 1200#line 359 "rl78-decode.opc" 1201 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(F); 1202 1203 } 1204 break; 1205 case 0x85: 1206 { 1207 /** 0011 0001 1bit 0101 bf %e1, $%a0 */ 1208#line 353 "rl78-decode.opc" 1209 int bit AU = (op[1] >> 4) & 0x07; 1210 if (trace) 1211 { 1212 printf ("\033[33m%s\033[0m %02x %02x\n", 1213 "/** 0011 0001 1bit 0101 bf %e1, $%a0 */", 1214 op[0], op[1]); 1215 printf (" bit = 0x%x\n", bit); 1216 } 1217 SYNTAX("bf %e1, $%a0"); 1218#line 353 "rl78-decode.opc" 1219 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(F); 1220 1221 } 1222 break; 1223 default: UNSUPPORTED(); break; 1224 } 1225 break; 1226 case 0x33: 1227 case 0x35: 1228 case 0x37: 1229 { 1230 /** 0011 0ra1 xchw %0, %1 */ 1231#line 1238 "rl78-decode.opc" 1232 int ra AU = (op[0] >> 1) & 0x03; 1233 if (trace) 1234 { 1235 printf ("\033[33m%s\033[0m %02x\n", 1236 "/** 0011 0ra1 xchw %0, %1 */", 1237 op[0]); 1238 printf (" ra = 0x%x\n", ra); 1239 } 1240 SYNTAX("xchw %0, %1"); 1241#line 1238 "rl78-decode.opc" 1242 ID(xch); W(); DR(AX); SRW(ra); 1243 1244 /*----------------------------------------------------------------------*/ 1245 1246 } 1247 break; 1248 case 0x38: 1249 { 1250 /** 0011 1000 mov %e0, #%1 */ 1251 if (trace) 1252 { 1253 printf ("\033[33m%s\033[0m %02x\n", 1254 "/** 0011 1000 mov %e0, #%1 */", 1255 op[0]); 1256 } 1257 SYNTAX("mov %e0, #%1"); 1258#line 737 "rl78-decode.opc" 1259 ID(mov); DM(C, IMMU(2)); SC(IMMU(1)); 1260 1261 } 1262 break; 1263 case 0x39: 1264 { 1265 /** 0011 1001 mov %e0, #%1 */ 1266 if (trace) 1267 { 1268 printf ("\033[33m%s\033[0m %02x\n", 1269 "/** 0011 1001 mov %e0, #%1 */", 1270 op[0]); 1271 } 1272 SYNTAX("mov %e0, #%1"); 1273#line 731 "rl78-decode.opc" 1274 ID(mov); DM(BC, IMMU(2)); SC(IMMU(1)); 1275 1276 } 1277 break; 1278 case 0x3a: 1279 { 1280 /** 0011 1010 subc %0, #%1 */ 1281 if (trace) 1282 { 1283 printf ("\033[33m%s\033[0m %02x\n", 1284 "/** 0011 1010 subc %0, #%1 */", 1285 op[0]); 1286 } 1287 SYNTAX("subc %0, #%1"); 1288#line 1177 "rl78-decode.opc" 1289 ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac; 1290 1291 /*----------------------------------------------------------------------*/ 1292 1293 } 1294 break; 1295 case 0x3b: 1296 { 1297 /** 0011 1011 subc %0, %1 */ 1298 if (trace) 1299 { 1300 printf ("\033[33m%s\033[0m %02x\n", 1301 "/** 0011 1011 subc %0, %1 */", 1302 op[0]); 1303 } 1304 SYNTAX("subc %0, %1"); 1305#line 1174 "rl78-decode.opc" 1306 ID(subc); DR(A); SM(None, SADDR); Fzac; 1307 1308 } 1309 break; 1310 case 0x3c: 1311 { 1312 /** 0011 1100 subc %0, #%1 */ 1313 if (trace) 1314 { 1315 printf ("\033[33m%s\033[0m %02x\n", 1316 "/** 0011 1100 subc %0, #%1 */", 1317 op[0]); 1318 } 1319 SYNTAX("subc %0, #%1"); 1320#line 1165 "rl78-decode.opc" 1321 ID(subc); DR(A); SC(IMMU(1)); Fzac; 1322 1323 } 1324 break; 1325 case 0x3d: 1326 { 1327 /** 0011 1101 subc %0, %e1 */ 1328 if (trace) 1329 { 1330 printf ("\033[33m%s\033[0m %02x\n", 1331 "/** 0011 1101 subc %0, %e1 */", 1332 op[0]); 1333 } 1334 SYNTAX("subc %0, %e1"); 1335#line 1153 "rl78-decode.opc" 1336 ID(subc); DR(A); SM(HL, 0); Fzac; 1337 1338 } 1339 break; 1340 case 0x3e: 1341 { 1342 /** 0011 1110 subc %0, %e1 */ 1343 if (trace) 1344 { 1345 printf ("\033[33m%s\033[0m %02x\n", 1346 "/** 0011 1110 subc %0, %e1 */", 1347 op[0]); 1348 } 1349 SYNTAX("subc %0, %e1"); 1350#line 1162 "rl78-decode.opc" 1351 ID(subc); DR(A); SM(HL, IMMU(1)); Fzac; 1352 1353 } 1354 break; 1355 case 0x3f: 1356 { 1357 /** 0011 1111 subc %0, %e!1 */ 1358 if (trace) 1359 { 1360 printf ("\033[33m%s\033[0m %02x\n", 1361 "/** 0011 1111 subc %0, %e!1 */", 1362 op[0]); 1363 } 1364 SYNTAX("subc %0, %e!1"); 1365#line 1150 "rl78-decode.opc" 1366 ID(subc); DR(A); SM(None, IMMU(2)); Fzac; 1367 1368 } 1369 break; 1370 case 0x40: 1371 { 1372 /** 0100 0000 cmp %e!0, #%1 */ 1373 if (trace) 1374 { 1375 printf ("\033[33m%s\033[0m %02x\n", 1376 "/** 0100 0000 cmp %e!0, #%1 */", 1377 op[0]); 1378 } 1379 SYNTAX("cmp %e!0, #%1"); 1380#line 479 "rl78-decode.opc" 1381 ID(cmp); DM(None, IMMU(2)); SC(IMMU(1)); Fzac; 1382 1383 } 1384 break; 1385 case 0x41: 1386 { 1387 /** 0100 0001 mov %0, #%1 */ 1388 if (trace) 1389 { 1390 printf ("\033[33m%s\033[0m %02x\n", 1391 "/** 0100 0001 mov %0, #%1 */", 1392 op[0]); 1393 } 1394 SYNTAX("mov %0, #%1"); 1395#line 716 "rl78-decode.opc" 1396 ID(mov); DR(ES); SC(IMMU(1)); 1397 1398 } 1399 break; 1400 case 0x42: 1401 { 1402 /** 0100 0010 cmpw %0, %e!1 */ 1403 if (trace) 1404 { 1405 printf ("\033[33m%s\033[0m %02x\n", 1406 "/** 0100 0010 cmpw %0, %e!1 */", 1407 op[0]); 1408 } 1409 SYNTAX("cmpw %0, %e!1"); 1410#line 530 "rl78-decode.opc" 1411 ID(cmp); W(); DR(AX); SM(None, IMMU(2)); Fzac; 1412 1413 } 1414 break; 1415 case 0x43: 1416 case 0x45: 1417 case 0x47: 1418 { 1419 /** 0100 0ra1 cmpw %0, %1 */ 1420#line 539 "rl78-decode.opc" 1421 int ra AU = (op[0] >> 1) & 0x03; 1422 if (trace) 1423 { 1424 printf ("\033[33m%s\033[0m %02x\n", 1425 "/** 0100 0ra1 cmpw %0, %1 */", 1426 op[0]); 1427 printf (" ra = 0x%x\n", ra); 1428 } 1429 SYNTAX("cmpw %0, %1"); 1430#line 539 "rl78-decode.opc" 1431 ID(cmp); W(); DR(AX); SRW(ra); Fzac; 1432 1433 } 1434 break; 1435 case 0x44: 1436 { 1437 /** 0100 0100 cmpw %0, #%1 */ 1438 if (trace) 1439 { 1440 printf ("\033[33m%s\033[0m %02x\n", 1441 "/** 0100 0100 cmpw %0, #%1 */", 1442 op[0]); 1443 } 1444 SYNTAX("cmpw %0, #%1"); 1445#line 536 "rl78-decode.opc" 1446 ID(cmp); W(); DR(AX); SC(IMMU(2)); Fzac; 1447 1448 } 1449 break; 1450 case 0x46: 1451 { 1452 /** 0100 0110 cmpw %0, %1 */ 1453 if (trace) 1454 { 1455 printf ("\033[33m%s\033[0m %02x\n", 1456 "/** 0100 0110 cmpw %0, %1 */", 1457 op[0]); 1458 } 1459 SYNTAX("cmpw %0, %1"); 1460#line 542 "rl78-decode.opc" 1461 ID(cmp); W(); DR(AX); SM(None, SADDR); Fzac; 1462 1463 /*----------------------------------------------------------------------*/ 1464 1465 } 1466 break; 1467 case 0x48: 1468 { 1469 /** 0100 1000 mov %e0, %1 */ 1470 if (trace) 1471 { 1472 printf ("\033[33m%s\033[0m %02x\n", 1473 "/** 0100 1000 mov %e0, %1 */", 1474 op[0]); 1475 } 1476 SYNTAX("mov %e0, %1"); 1477#line 734 "rl78-decode.opc" 1478 ID(mov); DM(BC, IMMU(2)); SR(A); 1479 1480 } 1481 break; 1482 case 0x49: 1483 { 1484 /** 0100 1001 mov %0, %e1 */ 1485 if (trace) 1486 { 1487 printf ("\033[33m%s\033[0m %02x\n", 1488 "/** 0100 1001 mov %0, %e1 */", 1489 op[0]); 1490 } 1491 SYNTAX("mov %0, %e1"); 1492#line 680 "rl78-decode.opc" 1493 ID(mov); DR(A); SM(BC, IMMU(2)); 1494 1495 } 1496 break; 1497 case 0x4a: 1498 { 1499 /** 0100 1010 cmp %0, #%1 */ 1500 if (trace) 1501 { 1502 printf ("\033[33m%s\033[0m %02x\n", 1503 "/** 0100 1010 cmp %0, #%1 */", 1504 op[0]); 1505 } 1506 SYNTAX("cmp %0, #%1"); 1507#line 482 "rl78-decode.opc" 1508 ID(cmp); DM(None, SADDR); SC(IMMU(1)); Fzac; 1509 1510 } 1511 break; 1512 case 0x4b: 1513 { 1514 /** 0100 1011 cmp %0, %1 */ 1515 if (trace) 1516 { 1517 printf ("\033[33m%s\033[0m %02x\n", 1518 "/** 0100 1011 cmp %0, %1 */", 1519 op[0]); 1520 } 1521 SYNTAX("cmp %0, %1"); 1522#line 509 "rl78-decode.opc" 1523 ID(cmp); DR(A); SM(None, SADDR); Fzac; 1524 1525 /*----------------------------------------------------------------------*/ 1526 1527 } 1528 break; 1529 case 0x4c: 1530 { 1531 /** 0100 1100 cmp %0, #%1 */ 1532 if (trace) 1533 { 1534 printf ("\033[33m%s\033[0m %02x\n", 1535 "/** 0100 1100 cmp %0, #%1 */", 1536 op[0]); 1537 } 1538 SYNTAX("cmp %0, #%1"); 1539#line 500 "rl78-decode.opc" 1540 ID(cmp); DR(A); SC(IMMU(1)); Fzac; 1541 1542 } 1543 break; 1544 case 0x4d: 1545 { 1546 /** 0100 1101 cmp %0, %e1 */ 1547 if (trace) 1548 { 1549 printf ("\033[33m%s\033[0m %02x\n", 1550 "/** 0100 1101 cmp %0, %e1 */", 1551 op[0]); 1552 } 1553 SYNTAX("cmp %0, %e1"); 1554#line 488 "rl78-decode.opc" 1555 ID(cmp); DR(A); SM(HL, 0); Fzac; 1556 1557 } 1558 break; 1559 case 0x4e: 1560 { 1561 /** 0100 1110 cmp %0, %e1 */ 1562 if (trace) 1563 { 1564 printf ("\033[33m%s\033[0m %02x\n", 1565 "/** 0100 1110 cmp %0, %e1 */", 1566 op[0]); 1567 } 1568 SYNTAX("cmp %0, %e1"); 1569#line 497 "rl78-decode.opc" 1570 ID(cmp); DR(A); SM(HL, IMMU(1)); Fzac; 1571 1572 } 1573 break; 1574 case 0x4f: 1575 { 1576 /** 0100 1111 cmp %0, %e!1 */ 1577 if (trace) 1578 { 1579 printf ("\033[33m%s\033[0m %02x\n", 1580 "/** 0100 1111 cmp %0, %e!1 */", 1581 op[0]); 1582 } 1583 SYNTAX("cmp %0, %e!1"); 1584#line 485 "rl78-decode.opc" 1585 ID(cmp); DR(A); SM(None, IMMU(2)); Fzac; 1586 1587 } 1588 break; 1589 case 0x50: 1590 case 0x51: 1591 case 0x52: 1592 case 0x53: 1593 case 0x54: 1594 case 0x55: 1595 case 0x56: 1596 case 0x57: 1597 { 1598 /** 0101 0reg mov %0, #%1 */ 1599#line 668 "rl78-decode.opc" 1600 int reg AU = op[0] & 0x07; 1601 if (trace) 1602 { 1603 printf ("\033[33m%s\033[0m %02x\n", 1604 "/** 0101 0reg mov %0, #%1 */", 1605 op[0]); 1606 printf (" reg = 0x%x\n", reg); 1607 } 1608 SYNTAX("mov %0, #%1"); 1609#line 668 "rl78-decode.opc" 1610 ID(mov); DRB(reg); SC(IMMU(1)); 1611 1612 } 1613 break; 1614 case 0x58: 1615 { 1616 /** 0101 1000 movw %e0, %1 */ 1617 if (trace) 1618 { 1619 printf ("\033[33m%s\033[0m %02x\n", 1620 "/** 0101 1000 movw %e0, %1 */", 1621 op[0]); 1622 } 1623 SYNTAX("movw %e0, %1"); 1624#line 870 "rl78-decode.opc" 1625 ID(mov); W(); DM(B, IMMU(2)); SR(AX); 1626 1627 } 1628 break; 1629 case 0x59: 1630 { 1631 /** 0101 1001 movw %0, %e1 */ 1632 if (trace) 1633 { 1634 printf ("\033[33m%s\033[0m %02x\n", 1635 "/** 0101 1001 movw %0, %e1 */", 1636 op[0]); 1637 } 1638 SYNTAX("movw %0, %e1"); 1639#line 861 "rl78-decode.opc" 1640 ID(mov); W(); DR(AX); SM(B, IMMU(2)); 1641 1642 } 1643 break; 1644 case 0x5a: 1645 { 1646 /** 0101 1010 and %0, #%1 */ 1647 if (trace) 1648 { 1649 printf ("\033[33m%s\033[0m %02x\n", 1650 "/** 0101 1010 and %0, #%1 */", 1651 op[0]); 1652 } 1653 SYNTAX("and %0, #%1"); 1654#line 311 "rl78-decode.opc" 1655 ID(and); DM(None, SADDR); SC(IMMU(1)); Fz; 1656 1657 /*----------------------------------------------------------------------*/ 1658 1659 } 1660 break; 1661 case 0x5b: 1662 { 1663 /** 0101 1011 and %0, %1 */ 1664 if (trace) 1665 { 1666 printf ("\033[33m%s\033[0m %02x\n", 1667 "/** 0101 1011 and %0, %1 */", 1668 op[0]); 1669 } 1670 SYNTAX("and %0, %1"); 1671#line 308 "rl78-decode.opc" 1672 ID(and); DR(A); SM(None, SADDR); Fz; 1673 1674 } 1675 break; 1676 case 0x5c: 1677 { 1678 /** 0101 1100 and %0, #%1 */ 1679 if (trace) 1680 { 1681 printf ("\033[33m%s\033[0m %02x\n", 1682 "/** 0101 1100 and %0, #%1 */", 1683 op[0]); 1684 } 1685 SYNTAX("and %0, #%1"); 1686#line 299 "rl78-decode.opc" 1687 ID(and); DR(A); SC(IMMU(1)); Fz; 1688 1689 } 1690 break; 1691 case 0x5d: 1692 { 1693 /** 0101 1101 and %0, %e1 */ 1694 if (trace) 1695 { 1696 printf ("\033[33m%s\033[0m %02x\n", 1697 "/** 0101 1101 and %0, %e1 */", 1698 op[0]); 1699 } 1700 SYNTAX("and %0, %e1"); 1701#line 287 "rl78-decode.opc" 1702 ID(and); DR(A); SM(HL, 0); Fz; 1703 1704 } 1705 break; 1706 case 0x5e: 1707 { 1708 /** 0101 1110 and %0, %e1 */ 1709 if (trace) 1710 { 1711 printf ("\033[33m%s\033[0m %02x\n", 1712 "/** 0101 1110 and %0, %e1 */", 1713 op[0]); 1714 } 1715 SYNTAX("and %0, %e1"); 1716#line 293 "rl78-decode.opc" 1717 ID(and); DR(A); SM(HL, IMMU(1)); Fz; 1718 1719 } 1720 break; 1721 case 0x5f: 1722 { 1723 /** 0101 1111 and %0, %e!1 */ 1724 if (trace) 1725 { 1726 printf ("\033[33m%s\033[0m %02x\n", 1727 "/** 0101 1111 and %0, %e!1 */", 1728 op[0]); 1729 } 1730 SYNTAX("and %0, %e!1"); 1731#line 284 "rl78-decode.opc" 1732 ID(and); DR(A); SM(None, IMMU(2)); Fz; 1733 1734 } 1735 break; 1736 case 0x60: 1737 case 0x62: 1738 case 0x63: 1739 case 0x64: 1740 case 0x65: 1741 case 0x66: 1742 case 0x67: 1743 { 1744 /** 0110 0rba mov %0, %1 */ 1745#line 671 "rl78-decode.opc" 1746 int rba AU = op[0] & 0x07; 1747 if (trace) 1748 { 1749 printf ("\033[33m%s\033[0m %02x\n", 1750 "/** 0110 0rba mov %0, %1 */", 1751 op[0]); 1752 printf (" rba = 0x%x\n", rba); 1753 } 1754 SYNTAX("mov %0, %1"); 1755#line 671 "rl78-decode.opc" 1756 ID(mov); DR(A); SRB(rba); 1757 1758 } 1759 break; 1760 case 0x61: 1761 GETBYTE (); 1762 switch (op[1] & 0xff) 1763 { 1764 case 0x00: 1765 case 0x01: 1766 case 0x02: 1767 case 0x03: 1768 case 0x04: 1769 case 0x05: 1770 case 0x06: 1771 case 0x07: 1772 { 1773 /** 0110 0001 0000 0reg add %0, %1 */ 1774#line 224 "rl78-decode.opc" 1775 int reg AU = op[1] & 0x07; 1776 if (trace) 1777 { 1778 printf ("\033[33m%s\033[0m %02x %02x\n", 1779 "/** 0110 0001 0000 0reg add %0, %1 */", 1780 op[0], op[1]); 1781 printf (" reg = 0x%x\n", reg); 1782 } 1783 SYNTAX("add %0, %1"); 1784#line 224 "rl78-decode.opc" 1785 ID(add); DRB(reg); SR(A); Fzac; 1786 1787 } 1788 break; 1789 case 0x08: 1790 case 0x0a: 1791 case 0x0b: 1792 case 0x0c: 1793 case 0x0d: 1794 case 0x0e: 1795 case 0x0f: 1796 { 1797 /** 0110 0001 0000 1rba add %0, %1 */ 1798#line 218 "rl78-decode.opc" 1799 int rba AU = op[1] & 0x07; 1800 if (trace) 1801 { 1802 printf ("\033[33m%s\033[0m %02x %02x\n", 1803 "/** 0110 0001 0000 1rba add %0, %1 */", 1804 op[0], op[1]); 1805 printf (" rba = 0x%x\n", rba); 1806 } 1807 SYNTAX("add %0, %1"); 1808#line 218 "rl78-decode.opc" 1809 ID(add); DR(A); SRB(rba); Fzac; 1810 1811 } 1812 break; 1813 case 0x09: 1814 { 1815 /** 0110 0001 0000 1001 addw %0, %e1 */ 1816 if (trace) 1817 { 1818 printf ("\033[33m%s\033[0m %02x %02x\n", 1819 "/** 0110 0001 0000 1001 addw %0, %e1 */", 1820 op[0], op[1]); 1821 } 1822 SYNTAX("addw %0, %e1"); 1823#line 267 "rl78-decode.opc" 1824 ID(add); W(); DR(AX); SM(HL, IMMU(1)); Fzac; 1825 1826 } 1827 break; 1828 case 0x10: 1829 case 0x11: 1830 case 0x12: 1831 case 0x13: 1832 case 0x14: 1833 case 0x15: 1834 case 0x16: 1835 case 0x17: 1836 { 1837 /** 0110 0001 0001 0reg addc %0, %1 */ 1838#line 253 "rl78-decode.opc" 1839 int reg AU = op[1] & 0x07; 1840 if (trace) 1841 { 1842 printf ("\033[33m%s\033[0m %02x %02x\n", 1843 "/** 0110 0001 0001 0reg addc %0, %1 */", 1844 op[0], op[1]); 1845 printf (" reg = 0x%x\n", reg); 1846 } 1847 SYNTAX("addc %0, %1"); 1848#line 253 "rl78-decode.opc" 1849 ID(addc); DRB(reg); SR(A); Fzac; 1850 1851 } 1852 break; 1853 case 0x18: 1854 case 0x1a: 1855 case 0x1b: 1856 case 0x1c: 1857 case 0x1d: 1858 case 0x1e: 1859 case 0x1f: 1860 { 1861 /** 0110 0001 0001 1rba addc %0, %1 */ 1862#line 250 "rl78-decode.opc" 1863 int rba AU = op[1] & 0x07; 1864 if (trace) 1865 { 1866 printf ("\033[33m%s\033[0m %02x %02x\n", 1867 "/** 0110 0001 0001 1rba addc %0, %1 */", 1868 op[0], op[1]); 1869 printf (" rba = 0x%x\n", rba); 1870 } 1871 SYNTAX("addc %0, %1"); 1872#line 250 "rl78-decode.opc" 1873 ID(addc); DR(A); SRB(rba); Fzac; 1874 1875 } 1876 break; 1877 case 0x20: 1878 case 0x21: 1879 case 0x22: 1880 case 0x23: 1881 case 0x24: 1882 case 0x25: 1883 case 0x26: 1884 case 0x27: 1885 { 1886 /** 0110 0001 0010 0reg sub %0, %1 */ 1887#line 1142 "rl78-decode.opc" 1888 int reg AU = op[1] & 0x07; 1889 if (trace) 1890 { 1891 printf ("\033[33m%s\033[0m %02x %02x\n", 1892 "/** 0110 0001 0010 0reg sub %0, %1 */", 1893 op[0], op[1]); 1894 printf (" reg = 0x%x\n", reg); 1895 } 1896 SYNTAX("sub %0, %1"); 1897#line 1142 "rl78-decode.opc" 1898 ID(sub); DRB(reg); SR(A); Fzac; 1899 1900 } 1901 break; 1902 case 0x28: 1903 case 0x2a: 1904 case 0x2b: 1905 case 0x2c: 1906 case 0x2d: 1907 case 0x2e: 1908 case 0x2f: 1909 { 1910 /** 0110 0001 0010 1rba sub %0, %1 */ 1911#line 1136 "rl78-decode.opc" 1912 int rba AU = op[1] & 0x07; 1913 if (trace) 1914 { 1915 printf ("\033[33m%s\033[0m %02x %02x\n", 1916 "/** 0110 0001 0010 1rba sub %0, %1 */", 1917 op[0], op[1]); 1918 printf (" rba = 0x%x\n", rba); 1919 } 1920 SYNTAX("sub %0, %1"); 1921#line 1136 "rl78-decode.opc" 1922 ID(sub); DR(A); SRB(rba); Fzac; 1923 1924 } 1925 break; 1926 case 0x29: 1927 { 1928 /** 0110 0001 0010 1001 subw %0, %e1 */ 1929 if (trace) 1930 { 1931 printf ("\033[33m%s\033[0m %02x %02x\n", 1932 "/** 0110 0001 0010 1001 subw %0, %e1 */", 1933 op[0], op[1]); 1934 } 1935 SYNTAX("subw %0, %e1"); 1936#line 1185 "rl78-decode.opc" 1937 ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac; 1938 1939 } 1940 break; 1941 case 0x30: 1942 case 0x31: 1943 case 0x32: 1944 case 0x33: 1945 case 0x34: 1946 case 0x35: 1947 case 0x36: 1948 case 0x37: 1949 { 1950 /** 0110 0001 0011 0reg subc %0, %1 */ 1951#line 1171 "rl78-decode.opc" 1952 int reg AU = op[1] & 0x07; 1953 if (trace) 1954 { 1955 printf ("\033[33m%s\033[0m %02x %02x\n", 1956 "/** 0110 0001 0011 0reg subc %0, %1 */", 1957 op[0], op[1]); 1958 printf (" reg = 0x%x\n", reg); 1959 } 1960 SYNTAX("subc %0, %1"); 1961#line 1171 "rl78-decode.opc" 1962 ID(subc); DRB(reg); SR(A); Fzac; 1963 1964 } 1965 break; 1966 case 0x38: 1967 case 0x3a: 1968 case 0x3b: 1969 case 0x3c: 1970 case 0x3d: 1971 case 0x3e: 1972 case 0x3f: 1973 { 1974 /** 0110 0001 0011 1rba subc %0, %1 */ 1975#line 1168 "rl78-decode.opc" 1976 int rba AU = op[1] & 0x07; 1977 if (trace) 1978 { 1979 printf ("\033[33m%s\033[0m %02x %02x\n", 1980 "/** 0110 0001 0011 1rba subc %0, %1 */", 1981 op[0], op[1]); 1982 printf (" rba = 0x%x\n", rba); 1983 } 1984 SYNTAX("subc %0, %1"); 1985#line 1168 "rl78-decode.opc" 1986 ID(subc); DR(A); SRB(rba); Fzac; 1987 1988 } 1989 break; 1990 case 0x40: 1991 case 0x41: 1992 case 0x42: 1993 case 0x43: 1994 case 0x44: 1995 case 0x45: 1996 case 0x46: 1997 case 0x47: 1998 { 1999 /** 0110 0001 0100 0reg cmp %0, %1 */ 2000#line 506 "rl78-decode.opc" 2001 int reg AU = op[1] & 0x07; 2002 if (trace) 2003 { 2004 printf ("\033[33m%s\033[0m %02x %02x\n", 2005 "/** 0110 0001 0100 0reg cmp %0, %1 */", 2006 op[0], op[1]); 2007 printf (" reg = 0x%x\n", reg); 2008 } 2009 SYNTAX("cmp %0, %1"); 2010#line 506 "rl78-decode.opc" 2011 ID(cmp); DRB(reg); SR(A); Fzac; 2012 2013 } 2014 break; 2015 case 0x48: 2016 case 0x4a: 2017 case 0x4b: 2018 case 0x4c: 2019 case 0x4d: 2020 case 0x4e: 2021 case 0x4f: 2022 { 2023 /** 0110 0001 0100 1rba cmp %0, %1 */ 2024#line 503 "rl78-decode.opc" 2025 int rba AU = op[1] & 0x07; 2026 if (trace) 2027 { 2028 printf ("\033[33m%s\033[0m %02x %02x\n", 2029 "/** 0110 0001 0100 1rba cmp %0, %1 */", 2030 op[0], op[1]); 2031 printf (" rba = 0x%x\n", rba); 2032 } 2033 SYNTAX("cmp %0, %1"); 2034#line 503 "rl78-decode.opc" 2035 ID(cmp); DR(A); SRB(rba); Fzac; 2036 2037 } 2038 break; 2039 case 0x49: 2040 { 2041 /** 0110 0001 0100 1001 cmpw %0, %e1 */ 2042 if (trace) 2043 { 2044 printf ("\033[33m%s\033[0m %02x %02x\n", 2045 "/** 0110 0001 0100 1001 cmpw %0, %e1 */", 2046 op[0], op[1]); 2047 } 2048 SYNTAX("cmpw %0, %e1"); 2049#line 533 "rl78-decode.opc" 2050 ID(cmp); W(); DR(AX); SM(HL, IMMU(1)); Fzac; 2051 2052 } 2053 break; 2054 case 0x50: 2055 case 0x51: 2056 case 0x52: 2057 case 0x53: 2058 case 0x54: 2059 case 0x55: 2060 case 0x56: 2061 case 0x57: 2062 { 2063 /** 0110 0001 0101 0reg and %0, %1 */ 2064#line 305 "rl78-decode.opc" 2065 int reg AU = op[1] & 0x07; 2066 if (trace) 2067 { 2068 printf ("\033[33m%s\033[0m %02x %02x\n", 2069 "/** 0110 0001 0101 0reg and %0, %1 */", 2070 op[0], op[1]); 2071 printf (" reg = 0x%x\n", reg); 2072 } 2073 SYNTAX("and %0, %1"); 2074#line 305 "rl78-decode.opc" 2075 ID(and); DRB(reg); SR(A); Fz; 2076 2077 } 2078 break; 2079 case 0x58: 2080 case 0x5a: 2081 case 0x5b: 2082 case 0x5c: 2083 case 0x5d: 2084 case 0x5e: 2085 case 0x5f: 2086 { 2087 /** 0110 0001 0101 1rba and %0, %1 */ 2088#line 302 "rl78-decode.opc" 2089 int rba AU = op[1] & 0x07; 2090 if (trace) 2091 { 2092 printf ("\033[33m%s\033[0m %02x %02x\n", 2093 "/** 0110 0001 0101 1rba and %0, %1 */", 2094 op[0], op[1]); 2095 printf (" rba = 0x%x\n", rba); 2096 } 2097 SYNTAX("and %0, %1"); 2098#line 302 "rl78-decode.opc" 2099 ID(and); DR(A); SRB(rba); Fz; 2100 2101 } 2102 break; 2103 case 0x59: 2104 { 2105 /** 0110 0001 0101 1001 inc %e0 */ 2106 if (trace) 2107 { 2108 printf ("\033[33m%s\033[0m %02x %02x\n", 2109 "/** 0110 0001 0101 1001 inc %e0 */", 2110 op[0], op[1]); 2111 } 2112 SYNTAX("inc %e0"); 2113#line 583 "rl78-decode.opc" 2114 ID(add); DM(HL, IMMU(1)); SC(1); Fza; 2115 2116 } 2117 break; 2118 case 0x60: 2119 case 0x61: 2120 case 0x62: 2121 case 0x63: 2122 case 0x64: 2123 case 0x65: 2124 case 0x66: 2125 case 0x67: 2126 { 2127 /** 0110 0001 0110 0reg or %0, %1 */ 2128#line 960 "rl78-decode.opc" 2129 int reg AU = op[1] & 0x07; 2130 if (trace) 2131 { 2132 printf ("\033[33m%s\033[0m %02x %02x\n", 2133 "/** 0110 0001 0110 0reg or %0, %1 */", 2134 op[0], op[1]); 2135 printf (" reg = 0x%x\n", reg); 2136 } 2137 SYNTAX("or %0, %1"); 2138#line 960 "rl78-decode.opc" 2139 ID(or); DRB(reg); SR(A); Fz; 2140 2141 } 2142 break; 2143 case 0x68: 2144 case 0x6a: 2145 case 0x6b: 2146 case 0x6c: 2147 case 0x6d: 2148 case 0x6e: 2149 case 0x6f: 2150 { 2151 /** 0110 0001 0110 1rba or %0, %1 */ 2152#line 957 "rl78-decode.opc" 2153 int rba AU = op[1] & 0x07; 2154 if (trace) 2155 { 2156 printf ("\033[33m%s\033[0m %02x %02x\n", 2157 "/** 0110 0001 0110 1rba or %0, %1 */", 2158 op[0], op[1]); 2159 printf (" rba = 0x%x\n", rba); 2160 } 2161 SYNTAX("or %0, %1"); 2162#line 957 "rl78-decode.opc" 2163 ID(or); DR(A); SRB(rba); Fz; 2164 2165 } 2166 break; 2167 case 0x69: 2168 { 2169 /** 0110 0001 0110 1001 dec %e0 */ 2170 if (trace) 2171 { 2172 printf ("\033[33m%s\033[0m %02x %02x\n", 2173 "/** 0110 0001 0110 1001 dec %e0 */", 2174 op[0], op[1]); 2175 } 2176 SYNTAX("dec %e0"); 2177#line 550 "rl78-decode.opc" 2178 ID(sub); DM(HL, IMMU(1)); SC(1); Fza; 2179 2180 } 2181 break; 2182 case 0x70: 2183 case 0x71: 2184 case 0x72: 2185 case 0x73: 2186 case 0x74: 2187 case 0x75: 2188 case 0x76: 2189 case 0x77: 2190 { 2191 /** 0110 0001 0111 0reg xor %0, %1 */ 2192#line 1264 "rl78-decode.opc" 2193 int reg AU = op[1] & 0x07; 2194 if (trace) 2195 { 2196 printf ("\033[33m%s\033[0m %02x %02x\n", 2197 "/** 0110 0001 0111 0reg xor %0, %1 */", 2198 op[0], op[1]); 2199 printf (" reg = 0x%x\n", reg); 2200 } 2201 SYNTAX("xor %0, %1"); 2202#line 1264 "rl78-decode.opc" 2203 ID(xor); DRB(reg); SR(A); Fz; 2204 2205 } 2206 break; 2207 case 0x78: 2208 case 0x7a: 2209 case 0x7b: 2210 case 0x7c: 2211 case 0x7d: 2212 case 0x7e: 2213 case 0x7f: 2214 { 2215 /** 0110 0001 0111 1rba xor %0, %1 */ 2216#line 1261 "rl78-decode.opc" 2217 int rba AU = op[1] & 0x07; 2218 if (trace) 2219 { 2220 printf ("\033[33m%s\033[0m %02x %02x\n", 2221 "/** 0110 0001 0111 1rba xor %0, %1 */", 2222 op[0], op[1]); 2223 printf (" rba = 0x%x\n", rba); 2224 } 2225 SYNTAX("xor %0, %1"); 2226#line 1261 "rl78-decode.opc" 2227 ID(xor); DR(A); SRB(rba); Fz; 2228 2229 } 2230 break; 2231 case 0x79: 2232 { 2233 /** 0110 0001 0111 1001 incw %e0 */ 2234 if (trace) 2235 { 2236 printf ("\033[33m%s\033[0m %02x %02x\n", 2237 "/** 0110 0001 0111 1001 incw %e0 */", 2238 op[0], op[1]); 2239 } 2240 SYNTAX("incw %e0"); 2241#line 597 "rl78-decode.opc" 2242 ID(add); W(); DM(HL, IMMU(1)); SC(1); 2243 2244 } 2245 break; 2246 case 0x80: 2247 case 0x81: 2248 { 2249 /** 0110 0001 1000 000 add %0, %e1 */ 2250 if (trace) 2251 { 2252 printf ("\033[33m%s\033[0m %02x %02x\n", 2253 "/** 0110 0001 1000 000 add %0, %e1 */", 2254 op[0], op[1]); 2255 } 2256 SYNTAX("add %0, %e1"); 2257#line 206 "rl78-decode.opc" 2258 ID(add); DR(A); SM2(HL, B, 0); Fzac; 2259 2260 } 2261 break; 2262 case 0x82: 2263 { 2264 /** 0110 0001 1000 0010 add %0, %e1 */ 2265 if (trace) 2266 { 2267 printf ("\033[33m%s\033[0m %02x %02x\n", 2268 "/** 0110 0001 1000 0010 add %0, %e1 */", 2269 op[0], op[1]); 2270 } 2271 SYNTAX("add %0, %e1"); 2272#line 212 "rl78-decode.opc" 2273 ID(add); DR(A); SM2(HL, C, 0); Fzac; 2274 2275 } 2276 break; 2277 case 0x84: 2278 case 0x85: 2279 case 0x86: 2280 case 0x87: 2281 case 0x94: 2282 case 0x95: 2283 case 0x96: 2284 case 0x97: 2285 case 0xa4: 2286 case 0xa5: 2287 case 0xa6: 2288 case 0xa7: 2289 case 0xb4: 2290 case 0xb5: 2291 case 0xb6: 2292 case 0xb7: 2293 case 0xc4: 2294 case 0xc5: 2295 case 0xc6: 2296 case 0xc7: 2297 case 0xd4: 2298 case 0xd5: 2299 case 0xd6: 2300 case 0xd7: 2301 case 0xe4: 2302 case 0xe5: 2303 case 0xe6: 2304 case 0xe7: 2305 case 0xf4: 2306 case 0xf5: 2307 case 0xf6: 2308 case 0xf7: 2309 { 2310 /** 0110 0001 1nnn 01mm callt [%x0] */ 2311#line 432 "rl78-decode.opc" 2312 int nnn AU = (op[1] >> 4) & 0x07; 2313#line 432 "rl78-decode.opc" 2314 int mm AU = op[1] & 0x03; 2315 if (trace) 2316 { 2317 printf ("\033[33m%s\033[0m %02x %02x\n", 2318 "/** 0110 0001 1nnn 01mm callt [%x0] */", 2319 op[0], op[1]); 2320 printf (" nnn = 0x%x,", nnn); 2321 printf (" mm = 0x%x\n", mm); 2322 } 2323 SYNTAX("callt [%x0]"); 2324#line 432 "rl78-decode.opc" 2325 ID(call); DM(None, 0x80 + mm*16 + nnn*2); 2326 2327 /*----------------------------------------------------------------------*/ 2328 2329 } 2330 break; 2331 case 0x88: 2332 case 0x8a: 2333 case 0x8b: 2334 case 0x8c: 2335 case 0x8d: 2336 case 0x8e: 2337 case 0x8f: 2338 { 2339 /** 0110 0001 1000 1reg xch %0, %1 */ 2340#line 1223 "rl78-decode.opc" 2341 int reg AU = op[1] & 0x07; 2342 if (trace) 2343 { 2344 printf ("\033[33m%s\033[0m %02x %02x\n", 2345 "/** 0110 0001 1000 1reg xch %0, %1 */", 2346 op[0], op[1]); 2347 printf (" reg = 0x%x\n", reg); 2348 } 2349 SYNTAX("xch %0, %1"); 2350#line 1223 "rl78-decode.opc" 2351 /* Note: DECW uses reg == X, so this must follow DECW */ 2352 ID(xch); DR(A); SRB(reg); 2353 2354 } 2355 break; 2356 case 0x89: 2357 { 2358 /** 0110 0001 1000 1001 decw %e0 */ 2359 if (trace) 2360 { 2361 printf ("\033[33m%s\033[0m %02x %02x\n", 2362 "/** 0110 0001 1000 1001 decw %e0 */", 2363 op[0], op[1]); 2364 } 2365 SYNTAX("decw %e0"); 2366#line 564 "rl78-decode.opc" 2367 ID(sub); W(); DM(HL, IMMU(1)); SC(1); 2368 2369 } 2370 break; 2371 case 0x90: 2372 { 2373 /** 0110 0001 1001 0000 addc %0, %e1 */ 2374 if (trace) 2375 { 2376 printf ("\033[33m%s\033[0m %02x %02x\n", 2377 "/** 0110 0001 1001 0000 addc %0, %e1 */", 2378 op[0], op[1]); 2379 } 2380 SYNTAX("addc %0, %e1"); 2381#line 238 "rl78-decode.opc" 2382 ID(addc); DR(A); SM2(HL, B, 0); Fzac; 2383 2384 } 2385 break; 2386 case 0x92: 2387 { 2388 /** 0110 0001 1001 0010 addc %0, %e1 */ 2389 if (trace) 2390 { 2391 printf ("\033[33m%s\033[0m %02x %02x\n", 2392 "/** 0110 0001 1001 0010 addc %0, %e1 */", 2393 op[0], op[1]); 2394 } 2395 SYNTAX("addc %0, %e1"); 2396#line 241 "rl78-decode.opc" 2397 ID(addc); DR(A); SM2(HL, C, 0); Fzac; 2398 2399 } 2400 break; 2401 case 0xa0: 2402 case 0xa1: 2403 { 2404 /** 0110 0001 1010 000 sub %0, %e1 */ 2405 if (trace) 2406 { 2407 printf ("\033[33m%s\033[0m %02x %02x\n", 2408 "/** 0110 0001 1010 000 sub %0, %e1 */", 2409 op[0], op[1]); 2410 } 2411 SYNTAX("sub %0, %e1"); 2412#line 1124 "rl78-decode.opc" 2413 ID(sub); DR(A); SM2(HL, B, 0); Fzac; 2414 2415 } 2416 break; 2417 case 0xa2: 2418 { 2419 /** 0110 0001 1010 0010 sub %0, %e1 */ 2420 if (trace) 2421 { 2422 printf ("\033[33m%s\033[0m %02x %02x\n", 2423 "/** 0110 0001 1010 0010 sub %0, %e1 */", 2424 op[0], op[1]); 2425 } 2426 SYNTAX("sub %0, %e1"); 2427#line 1130 "rl78-decode.opc" 2428 ID(sub); DR(A); SM2(HL, C, 0); Fzac; 2429 2430 } 2431 break; 2432 case 0xa8: 2433 { 2434 /** 0110 0001 1010 1000 xch %0, %1 */ 2435 if (trace) 2436 { 2437 printf ("\033[33m%s\033[0m %02x %02x\n", 2438 "/** 0110 0001 1010 1000 xch %0, %1 */", 2439 op[0], op[1]); 2440 } 2441 SYNTAX("xch %0, %1"); 2442#line 1227 "rl78-decode.opc" 2443 ID(xch); DR(A); SM(None, SADDR); 2444 2445 } 2446 break; 2447 case 0xa9: 2448 { 2449 /** 0110 0001 1010 1001 xch %0, %e1 */ 2450 if (trace) 2451 { 2452 printf ("\033[33m%s\033[0m %02x %02x\n", 2453 "/** 0110 0001 1010 1001 xch %0, %e1 */", 2454 op[0], op[1]); 2455 } 2456 SYNTAX("xch %0, %e1"); 2457#line 1220 "rl78-decode.opc" 2458 ID(xch); DR(A); SM2(HL, C, 0); 2459 2460 } 2461 break; 2462 case 0xaa: 2463 { 2464 /** 0110 0001 1010 1010 xch %0, %e!1 */ 2465 if (trace) 2466 { 2467 printf ("\033[33m%s\033[0m %02x %02x\n", 2468 "/** 0110 0001 1010 1010 xch %0, %e!1 */", 2469 op[0], op[1]); 2470 } 2471 SYNTAX("xch %0, %e!1"); 2472#line 1202 "rl78-decode.opc" 2473 ID(xch); DR(A); SM(None, IMMU(2)); 2474 2475 } 2476 break; 2477 case 0xab: 2478 { 2479 /** 0110 0001 1010 1011 xch %0, %1 */ 2480 if (trace) 2481 { 2482 printf ("\033[33m%s\033[0m %02x %02x\n", 2483 "/** 0110 0001 1010 1011 xch %0, %1 */", 2484 op[0], op[1]); 2485 } 2486 SYNTAX("xch %0, %1"); 2487#line 1230 "rl78-decode.opc" 2488 ID(xch); DR(A); SM(None, SFR); 2489 2490 } 2491 break; 2492 case 0xac: 2493 { 2494 /** 0110 0001 1010 1100 xch %0, %e1 */ 2495 if (trace) 2496 { 2497 printf ("\033[33m%s\033[0m %02x %02x\n", 2498 "/** 0110 0001 1010 1100 xch %0, %e1 */", 2499 op[0], op[1]); 2500 } 2501 SYNTAX("xch %0, %e1"); 2502#line 1211 "rl78-decode.opc" 2503 ID(xch); DR(A); SM(HL, 0); 2504 2505 } 2506 break; 2507 case 0xad: 2508 { 2509 /** 0110 0001 1010 1101 xch %0, %e1 */ 2510 if (trace) 2511 { 2512 printf ("\033[33m%s\033[0m %02x %02x\n", 2513 "/** 0110 0001 1010 1101 xch %0, %e1 */", 2514 op[0], op[1]); 2515 } 2516 SYNTAX("xch %0, %e1"); 2517#line 1217 "rl78-decode.opc" 2518 ID(xch); DR(A); SM(HL, IMMU(1)); 2519 2520 } 2521 break; 2522 case 0xae: 2523 { 2524 /** 0110 0001 1010 1110 xch %0, %e1 */ 2525 if (trace) 2526 { 2527 printf ("\033[33m%s\033[0m %02x %02x\n", 2528 "/** 0110 0001 1010 1110 xch %0, %e1 */", 2529 op[0], op[1]); 2530 } 2531 SYNTAX("xch %0, %e1"); 2532#line 1205 "rl78-decode.opc" 2533 ID(xch); DR(A); SM(DE, 0); 2534 2535 } 2536 break; 2537 case 0xaf: 2538 { 2539 /** 0110 0001 1010 1111 xch %0, %e1 */ 2540 if (trace) 2541 { 2542 printf ("\033[33m%s\033[0m %02x %02x\n", 2543 "/** 0110 0001 1010 1111 xch %0, %e1 */", 2544 op[0], op[1]); 2545 } 2546 SYNTAX("xch %0, %e1"); 2547#line 1208 "rl78-decode.opc" 2548 ID(xch); DR(A); SM(DE, IMMU(1)); 2549 2550 } 2551 break; 2552 case 0xb0: 2553 { 2554 /** 0110 0001 1011 0000 subc %0, %e1 */ 2555 if (trace) 2556 { 2557 printf ("\033[33m%s\033[0m %02x %02x\n", 2558 "/** 0110 0001 1011 0000 subc %0, %e1 */", 2559 op[0], op[1]); 2560 } 2561 SYNTAX("subc %0, %e1"); 2562#line 1156 "rl78-decode.opc" 2563 ID(subc); DR(A); SM2(HL, B, 0); Fzac; 2564 2565 } 2566 break; 2567 case 0xb2: 2568 { 2569 /** 0110 0001 1011 0010 subc %0, %e1 */ 2570 if (trace) 2571 { 2572 printf ("\033[33m%s\033[0m %02x %02x\n", 2573 "/** 0110 0001 1011 0010 subc %0, %e1 */", 2574 op[0], op[1]); 2575 } 2576 SYNTAX("subc %0, %e1"); 2577#line 1159 "rl78-decode.opc" 2578 ID(subc); DR(A); SM2(HL, C, 0); Fzac; 2579 2580 } 2581 break; 2582 case 0xb8: 2583 { 2584 /** 0110 0001 1011 1000 mov %0, %1 */ 2585 if (trace) 2586 { 2587 printf ("\033[33m%s\033[0m %02x %02x\n", 2588 "/** 0110 0001 1011 1000 mov %0, %1 */", 2589 op[0], op[1]); 2590 } 2591 SYNTAX("mov %0, %1"); 2592#line 722 "rl78-decode.opc" 2593 ID(mov); DR(ES); SM(None, SADDR); 2594 2595 } 2596 break; 2597 case 0xb9: 2598 { 2599 /** 0110 0001 1011 1001 xch %0, %e1 */ 2600 if (trace) 2601 { 2602 printf ("\033[33m%s\033[0m %02x %02x\n", 2603 "/** 0110 0001 1011 1001 xch %0, %e1 */", 2604 op[0], op[1]); 2605 } 2606 SYNTAX("xch %0, %e1"); 2607#line 1214 "rl78-decode.opc" 2608 ID(xch); DR(A); SM2(HL, B, 0); 2609 2610 } 2611 break; 2612 case 0xc0: 2613 { 2614 /** 0110 0001 1100 0000 cmp %0, %e1 */ 2615 if (trace) 2616 { 2617 printf ("\033[33m%s\033[0m %02x %02x\n", 2618 "/** 0110 0001 1100 0000 cmp %0, %e1 */", 2619 op[0], op[1]); 2620 } 2621 SYNTAX("cmp %0, %e1"); 2622#line 491 "rl78-decode.opc" 2623 ID(cmp); DR(A); SM2(HL, B, 0); Fzac; 2624 2625 } 2626 break; 2627 case 0xc2: 2628 { 2629 /** 0110 0001 1100 0010 cmp %0, %e1 */ 2630 if (trace) 2631 { 2632 printf ("\033[33m%s\033[0m %02x %02x\n", 2633 "/** 0110 0001 1100 0010 cmp %0, %e1 */", 2634 op[0], op[1]); 2635 } 2636 SYNTAX("cmp %0, %e1"); 2637#line 494 "rl78-decode.opc" 2638 ID(cmp); DR(A); SM2(HL, C, 0); Fzac; 2639 2640 } 2641 break; 2642 case 0xc3: 2643 { 2644 /** 0110 0001 1100 0011 bh $%a0 */ 2645 if (trace) 2646 { 2647 printf ("\033[33m%s\033[0m %02x %02x\n", 2648 "/** 0110 0001 1100 0011 bh $%a0 */", 2649 op[0], op[1]); 2650 } 2651 SYNTAX("bh $%a0"); 2652#line 339 "rl78-decode.opc" 2653 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(H); 2654 2655 } 2656 break; 2657 case 0xc8: 2658 { 2659 /** 0110 0001 1100 1000 sk%c1 */ 2660 if (trace) 2661 { 2662 printf ("\033[33m%s\033[0m %02x %02x\n", 2663 "/** 0110 0001 1100 1000 sk%c1 */", 2664 op[0], op[1]); 2665 } 2666 SYNTAX("sk%c1"); 2667#line 1093 "rl78-decode.opc" 2668 ID(skip); COND(C); 2669 2670 } 2671 break; 2672 case 0xc9: 2673 { 2674 /** 0110 0001 1100 1001 mov %0, %e1 */ 2675 if (trace) 2676 { 2677 printf ("\033[33m%s\033[0m %02x %02x\n", 2678 "/** 0110 0001 1100 1001 mov %0, %e1 */", 2679 op[0], op[1]); 2680 } 2681 SYNTAX("mov %0, %e1"); 2682#line 659 "rl78-decode.opc" 2683 ID(mov); DR(A); SM2(HL, B, 0); 2684 2685 } 2686 break; 2687 case 0xca: 2688 case 0xda: 2689 case 0xea: 2690 case 0xfa: 2691 { 2692 /** 0110 0001 11rg 1010 call %0 */ 2693#line 429 "rl78-decode.opc" 2694 int rg AU = (op[1] >> 4) & 0x03; 2695 if (trace) 2696 { 2697 printf ("\033[33m%s\033[0m %02x %02x\n", 2698 "/** 0110 0001 11rg 1010 call %0 */", 2699 op[0], op[1]); 2700 printf (" rg = 0x%x\n", rg); 2701 } 2702 SYNTAX("call %0"); 2703#line 429 "rl78-decode.opc" 2704 ID(call); DRW(rg); 2705 2706 } 2707 break; 2708 case 0xcb: 2709 { 2710 /** 0110 0001 1100 1011 br ax */ 2711 if (trace) 2712 { 2713 printf ("\033[33m%s\033[0m %02x %02x\n", 2714 "/** 0110 0001 1100 1011 br ax */", 2715 op[0], op[1]); 2716 } 2717 SYNTAX("br ax"); 2718#line 379 "rl78-decode.opc" 2719 ID(branch); DR(AX); 2720 2721 /*----------------------------------------------------------------------*/ 2722 2723 } 2724 break; 2725 case 0xcc: 2726 { 2727 /** 0110 0001 1100 1100 brk */ 2728 if (trace) 2729 { 2730 printf ("\033[33m%s\033[0m %02x %02x\n", 2731 "/** 0110 0001 1100 1100 brk */", 2732 op[0], op[1]); 2733 } 2734 SYNTAX("brk"); 2735#line 387 "rl78-decode.opc" 2736 ID(break); 2737 2738 /*----------------------------------------------------------------------*/ 2739 2740 } 2741 break; 2742 case 0xcd: 2743 { 2744 /** 0110 0001 1100 1101 pop %s0 */ 2745 if (trace) 2746 { 2747 printf ("\033[33m%s\033[0m %02x %02x\n", 2748 "/** 0110 0001 1100 1101 pop %s0 */", 2749 op[0], op[1]); 2750 } 2751 SYNTAX("pop %s0"); 2752#line 988 "rl78-decode.opc" 2753 ID(mov); W(); DR(PSW); SPOP(); 2754 2755 /*----------------------------------------------------------------------*/ 2756 2757 } 2758 break; 2759 case 0xce: 2760 { 2761 /** 0110 0001 1100 1110 movs %e0, %1 */ 2762 if (trace) 2763 { 2764 printf ("\033[33m%s\033[0m %02x %02x\n", 2765 "/** 0110 0001 1100 1110 movs %e0, %1 */", 2766 op[0], op[1]); 2767 } 2768 SYNTAX("movs %e0, %1"); 2769#line 810 "rl78-decode.opc" 2770 ID(mov); DM(HL, IMMU(1)); SR(X); Fzc; 2771 2772 /*----------------------------------------------------------------------*/ 2773 2774 } 2775 break; 2776 case 0xcf: 2777 case 0xdf: 2778 case 0xef: 2779 case 0xff: 2780 { 2781 /** 0110 0001 11rb 1111 sel rb%1 */ 2782#line 1040 "rl78-decode.opc" 2783 int rb AU = (op[1] >> 4) & 0x03; 2784 if (trace) 2785 { 2786 printf ("\033[33m%s\033[0m %02x %02x\n", 2787 "/** 0110 0001 11rb 1111 sel rb%1 */", 2788 op[0], op[1]); 2789 printf (" rb = 0x%x\n", rb); 2790 } 2791 SYNTAX("sel rb%1"); 2792#line 1040 "rl78-decode.opc" 2793 ID(sel); SC(rb); 2794 2795 /*----------------------------------------------------------------------*/ 2796 2797 } 2798 break; 2799 case 0xd0: 2800 { 2801 /** 0110 0001 1101 0000 and %0, %e1 */ 2802 if (trace) 2803 { 2804 printf ("\033[33m%s\033[0m %02x %02x\n", 2805 "/** 0110 0001 1101 0000 and %0, %e1 */", 2806 op[0], op[1]); 2807 } 2808 SYNTAX("and %0, %e1"); 2809#line 290 "rl78-decode.opc" 2810 ID(and); DR(A); SM2(HL, B, 0); Fz; 2811 2812 } 2813 break; 2814 case 0xd2: 2815 { 2816 /** 0110 0001 1101 0010 and %0, %e1 */ 2817 if (trace) 2818 { 2819 printf ("\033[33m%s\033[0m %02x %02x\n", 2820 "/** 0110 0001 1101 0010 and %0, %e1 */", 2821 op[0], op[1]); 2822 } 2823 SYNTAX("and %0, %e1"); 2824#line 296 "rl78-decode.opc" 2825 ID(and); DR(A); SM2(HL, C, 0); Fz; 2826 2827 } 2828 break; 2829 case 0xd3: 2830 { 2831 /** 0110 0001 1101 0011 bnh $%a0 */ 2832 if (trace) 2833 { 2834 printf ("\033[33m%s\033[0m %02x %02x\n", 2835 "/** 0110 0001 1101 0011 bnh $%a0 */", 2836 op[0], op[1]); 2837 } 2838 SYNTAX("bnh $%a0"); 2839#line 342 "rl78-decode.opc" 2840 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(NH); 2841 2842 } 2843 break; 2844 case 0xd8: 2845 { 2846 /** 0110 0001 1101 1000 sk%c1 */ 2847 if (trace) 2848 { 2849 printf ("\033[33m%s\033[0m %02x %02x\n", 2850 "/** 0110 0001 1101 1000 sk%c1 */", 2851 op[0], op[1]); 2852 } 2853 SYNTAX("sk%c1"); 2854#line 1099 "rl78-decode.opc" 2855 ID(skip); COND(NC); 2856 2857 } 2858 break; 2859 case 0xd9: 2860 { 2861 /** 0110 0001 1101 1001 mov %e0, %1 */ 2862 if (trace) 2863 { 2864 printf ("\033[33m%s\033[0m %02x %02x\n", 2865 "/** 0110 0001 1101 1001 mov %e0, %1 */", 2866 op[0], op[1]); 2867 } 2868 SYNTAX("mov %e0, %1"); 2869#line 626 "rl78-decode.opc" 2870 ID(mov); DM2(HL, B, 0); SR(A); 2871 2872 } 2873 break; 2874 case 0xdb: 2875 { 2876 /** 0110 0001 1101 1011 ror %0, %1 */ 2877 if (trace) 2878 { 2879 printf ("\033[33m%s\033[0m %02x %02x\n", 2880 "/** 0110 0001 1101 1011 ror %0, %1 */", 2881 op[0], op[1]); 2882 } 2883 SYNTAX("ror %0, %1"); 2884#line 1021 "rl78-decode.opc" 2885 ID(ror); DR(A); SC(1); 2886 2887 } 2888 break; 2889 case 0xdc: 2890 { 2891 /** 0110 0001 1101 1100 rolc %0, %1 */ 2892 if (trace) 2893 { 2894 printf ("\033[33m%s\033[0m %02x %02x\n", 2895 "/** 0110 0001 1101 1100 rolc %0, %1 */", 2896 op[0], op[1]); 2897 } 2898 SYNTAX("rolc %0, %1"); 2899#line 1015 "rl78-decode.opc" 2900 ID(rolc); DR(A); SC(1); 2901 2902 } 2903 break; 2904 case 0xdd: 2905 { 2906 /** 0110 0001 1101 1101 push %s1 */ 2907 if (trace) 2908 { 2909 printf ("\033[33m%s\033[0m %02x %02x\n", 2910 "/** 0110 0001 1101 1101 push %s1 */", 2911 op[0], op[1]); 2912 } 2913 SYNTAX("push %s1"); 2914#line 996 "rl78-decode.opc" 2915 ID(mov); W(); DPUSH(); SR(PSW); 2916 2917 /*----------------------------------------------------------------------*/ 2918 2919 } 2920 break; 2921 case 0xde: 2922 { 2923 /** 0110 0001 1101 1110 cmps %0, %e1 */ 2924 if (trace) 2925 { 2926 printf ("\033[33m%s\033[0m %02x %02x\n", 2927 "/** 0110 0001 1101 1110 cmps %0, %e1 */", 2928 op[0], op[1]); 2929 } 2930 SYNTAX("cmps %0, %e1"); 2931#line 525 "rl78-decode.opc" 2932 ID(cmp); DR(X); SM(HL, IMMU(1)); Fzac; 2933 2934 /*----------------------------------------------------------------------*/ 2935 2936 } 2937 break; 2938 case 0xe0: 2939 { 2940 /** 0110 0001 1110 0000 or %0, %e1 */ 2941 if (trace) 2942 { 2943 printf ("\033[33m%s\033[0m %02x %02x\n", 2944 "/** 0110 0001 1110 0000 or %0, %e1 */", 2945 op[0], op[1]); 2946 } 2947 SYNTAX("or %0, %e1"); 2948#line 945 "rl78-decode.opc" 2949 ID(or); DR(A); SM2(HL, B, 0); Fz; 2950 2951 } 2952 break; 2953 case 0xe2: 2954 { 2955 /** 0110 0001 1110 0010 or %0, %e1 */ 2956 if (trace) 2957 { 2958 printf ("\033[33m%s\033[0m %02x %02x\n", 2959 "/** 0110 0001 1110 0010 or %0, %e1 */", 2960 op[0], op[1]); 2961 } 2962 SYNTAX("or %0, %e1"); 2963#line 951 "rl78-decode.opc" 2964 ID(or); DR(A); SM2(HL, C, 0); Fz; 2965 2966 } 2967 break; 2968 case 0xe3: 2969 { 2970 /** 0110 0001 1110 0011 sk%c1 */ 2971 if (trace) 2972 { 2973 printf ("\033[33m%s\033[0m %02x %02x\n", 2974 "/** 0110 0001 1110 0011 sk%c1 */", 2975 op[0], op[1]); 2976 } 2977 SYNTAX("sk%c1"); 2978#line 1096 "rl78-decode.opc" 2979 ID(skip); COND(H); 2980 2981 } 2982 break; 2983 case 0xe8: 2984 { 2985 /** 0110 0001 1110 1000 sk%c1 */ 2986 if (trace) 2987 { 2988 printf ("\033[33m%s\033[0m %02x %02x\n", 2989 "/** 0110 0001 1110 1000 sk%c1 */", 2990 op[0], op[1]); 2991 } 2992 SYNTAX("sk%c1"); 2993#line 1108 "rl78-decode.opc" 2994 ID(skip); COND(Z); 2995 2996 /*----------------------------------------------------------------------*/ 2997 2998 } 2999 break; 3000 case 0xe9: 3001 { 3002 /** 0110 0001 1110 1001 mov %0, %e1 */ 3003 if (trace) 3004 { 3005 printf ("\033[33m%s\033[0m %02x %02x\n", 3006 "/** 0110 0001 1110 1001 mov %0, %e1 */", 3007 op[0], op[1]); 3008 } 3009 SYNTAX("mov %0, %e1"); 3010#line 662 "rl78-decode.opc" 3011 ID(mov); DR(A); SM2(HL, C, 0); 3012 3013 } 3014 break; 3015 case 0xeb: 3016 { 3017 /** 0110 0001 1110 1011 rol %0, %1 */ 3018 if (trace) 3019 { 3020 printf ("\033[33m%s\033[0m %02x %02x\n", 3021 "/** 0110 0001 1110 1011 rol %0, %1 */", 3022 op[0], op[1]); 3023 } 3024 SYNTAX("rol %0, %1"); 3025#line 1012 "rl78-decode.opc" 3026 ID(rol); DR(A); SC(1); 3027 3028 } 3029 break; 3030 case 0xec: 3031 { 3032 /** 0110 0001 1110 1100 retb */ 3033 if (trace) 3034 { 3035 printf ("\033[33m%s\033[0m %02x %02x\n", 3036 "/** 0110 0001 1110 1100 retb */", 3037 op[0], op[1]); 3038 } 3039 SYNTAX("retb"); 3040#line 1007 "rl78-decode.opc" 3041 ID(reti); 3042 3043 /*----------------------------------------------------------------------*/ 3044 3045 } 3046 break; 3047 case 0xed: 3048 { 3049 /** 0110 0001 1110 1101 halt */ 3050 if (trace) 3051 { 3052 printf ("\033[33m%s\033[0m %02x %02x\n", 3053 "/** 0110 0001 1110 1101 halt */", 3054 op[0], op[1]); 3055 } 3056 SYNTAX("halt"); 3057#line 575 "rl78-decode.opc" 3058 ID(halt); 3059 3060 /*----------------------------------------------------------------------*/ 3061 3062 } 3063 break; 3064 case 0xee: 3065 case 0xfe: 3066 { 3067 /** 0110 0001 111r 1110 rolwc %0, %1 */ 3068#line 1018 "rl78-decode.opc" 3069 int r AU = (op[1] >> 4) & 0x01; 3070 if (trace) 3071 { 3072 printf ("\033[33m%s\033[0m %02x %02x\n", 3073 "/** 0110 0001 111r 1110 rolwc %0, %1 */", 3074 op[0], op[1]); 3075 printf (" r = 0x%x\n", r); 3076 } 3077 SYNTAX("rolwc %0, %1"); 3078#line 1018 "rl78-decode.opc" 3079 ID(rolc); W(); DRW(r); SC(1); 3080 3081 } 3082 break; 3083 case 0xf0: 3084 { 3085 /** 0110 0001 1111 0000 xor %0, %e1 */ 3086 if (trace) 3087 { 3088 printf ("\033[33m%s\033[0m %02x %02x\n", 3089 "/** 0110 0001 1111 0000 xor %0, %e1 */", 3090 op[0], op[1]); 3091 } 3092 SYNTAX("xor %0, %e1"); 3093#line 1249 "rl78-decode.opc" 3094 ID(xor); DR(A); SM2(HL, B, 0); Fz; 3095 3096 } 3097 break; 3098 case 0xf2: 3099 { 3100 /** 0110 0001 1111 0010 xor %0, %e1 */ 3101 if (trace) 3102 { 3103 printf ("\033[33m%s\033[0m %02x %02x\n", 3104 "/** 0110 0001 1111 0010 xor %0, %e1 */", 3105 op[0], op[1]); 3106 } 3107 SYNTAX("xor %0, %e1"); 3108#line 1255 "rl78-decode.opc" 3109 ID(xor); DR(A); SM2(HL, C, 0); Fz; 3110 3111 } 3112 break; 3113 case 0xf3: 3114 { 3115 /** 0110 0001 1111 0011 sk%c1 */ 3116 if (trace) 3117 { 3118 printf ("\033[33m%s\033[0m %02x %02x\n", 3119 "/** 0110 0001 1111 0011 sk%c1 */", 3120 op[0], op[1]); 3121 } 3122 SYNTAX("sk%c1"); 3123#line 1102 "rl78-decode.opc" 3124 ID(skip); COND(NH); 3125 3126 } 3127 break; 3128 case 0xf8: 3129 { 3130 /** 0110 0001 1111 1000 sk%c1 */ 3131 if (trace) 3132 { 3133 printf ("\033[33m%s\033[0m %02x %02x\n", 3134 "/** 0110 0001 1111 1000 sk%c1 */", 3135 op[0], op[1]); 3136 } 3137 SYNTAX("sk%c1"); 3138#line 1105 "rl78-decode.opc" 3139 ID(skip); COND(NZ); 3140 3141 } 3142 break; 3143 case 0xf9: 3144 { 3145 /** 0110 0001 1111 1001 mov %e0, %1 */ 3146 if (trace) 3147 { 3148 printf ("\033[33m%s\033[0m %02x %02x\n", 3149 "/** 0110 0001 1111 1001 mov %e0, %1 */", 3150 op[0], op[1]); 3151 } 3152 SYNTAX("mov %e0, %1"); 3153#line 635 "rl78-decode.opc" 3154 ID(mov); DM2(HL, C, 0); SR(A); 3155 3156 } 3157 break; 3158 case 0xfb: 3159 { 3160 /** 0110 0001 1111 1011 rorc %0, %1 */ 3161 if (trace) 3162 { 3163 printf ("\033[33m%s\033[0m %02x %02x\n", 3164 "/** 0110 0001 1111 1011 rorc %0, %1 */", 3165 op[0], op[1]); 3166 } 3167 SYNTAX("rorc %0, %1"); 3168#line 1024 "rl78-decode.opc" 3169 ID(rorc); DR(A); SC(1); 3170 3171 /*----------------------------------------------------------------------*/ 3172 3173 /* Note that the branch insns need to be listed before the shift 3174 ones, as "shift count of zero" means "branch insn" */ 3175 3176 } 3177 break; 3178 case 0xfc: 3179 { 3180 /** 0110 0001 1111 1100 reti */ 3181 if (trace) 3182 { 3183 printf ("\033[33m%s\033[0m %02x %02x\n", 3184 "/** 0110 0001 1111 1100 reti */", 3185 op[0], op[1]); 3186 } 3187 SYNTAX("reti"); 3188#line 1004 "rl78-decode.opc" 3189 ID(reti); 3190 3191 } 3192 break; 3193 case 0xfd: 3194 { 3195 /** 0110 0001 1111 1101 stop */ 3196 if (trace) 3197 { 3198 printf ("\033[33m%s\033[0m %02x %02x\n", 3199 "/** 0110 0001 1111 1101 stop */", 3200 op[0], op[1]); 3201 } 3202 SYNTAX("stop"); 3203#line 1113 "rl78-decode.opc" 3204 ID(stop); 3205 3206 /*----------------------------------------------------------------------*/ 3207 3208 } 3209 break; 3210 default: UNSUPPORTED(); break; 3211 } 3212 break; 3213 case 0x68: 3214 { 3215 /** 0110 1000 movw %e0, %1 */ 3216 if (trace) 3217 { 3218 printf ("\033[33m%s\033[0m %02x\n", 3219 "/** 0110 1000 movw %e0, %1 */", 3220 op[0]); 3221 } 3222 SYNTAX("movw %e0, %1"); 3223#line 873 "rl78-decode.opc" 3224 ID(mov); W(); DM(C, IMMU(2)); SR(AX); 3225 3226 } 3227 break; 3228 case 0x69: 3229 { 3230 /** 0110 1001 movw %0, %e1 */ 3231 if (trace) 3232 { 3233 printf ("\033[33m%s\033[0m %02x\n", 3234 "/** 0110 1001 movw %0, %e1 */", 3235 op[0]); 3236 } 3237 SYNTAX("movw %0, %e1"); 3238#line 864 "rl78-decode.opc" 3239 ID(mov); W(); DR(AX); SM(C, IMMU(2)); 3240 3241 } 3242 break; 3243 case 0x6a: 3244 { 3245 /** 0110 1010 or %0, #%1 */ 3246 if (trace) 3247 { 3248 printf ("\033[33m%s\033[0m %02x\n", 3249 "/** 0110 1010 or %0, #%1 */", 3250 op[0]); 3251 } 3252 SYNTAX("or %0, #%1"); 3253#line 966 "rl78-decode.opc" 3254 ID(or); DM(None, SADDR); SC(IMMU(1)); Fz; 3255 3256 /*----------------------------------------------------------------------*/ 3257 3258 } 3259 break; 3260 case 0x6b: 3261 { 3262 /** 0110 1011 or %0, %1 */ 3263 if (trace) 3264 { 3265 printf ("\033[33m%s\033[0m %02x\n", 3266 "/** 0110 1011 or %0, %1 */", 3267 op[0]); 3268 } 3269 SYNTAX("or %0, %1"); 3270#line 963 "rl78-decode.opc" 3271 ID(or); DR(A); SM(None, SADDR); Fz; 3272 3273 } 3274 break; 3275 case 0x6c: 3276 { 3277 /** 0110 1100 or %0, #%1 */ 3278 if (trace) 3279 { 3280 printf ("\033[33m%s\033[0m %02x\n", 3281 "/** 0110 1100 or %0, #%1 */", 3282 op[0]); 3283 } 3284 SYNTAX("or %0, #%1"); 3285#line 954 "rl78-decode.opc" 3286 ID(or); DR(A); SC(IMMU(1)); Fz; 3287 3288 } 3289 break; 3290 case 0x6d: 3291 { 3292 /** 0110 1101 or %0, %e1 */ 3293 if (trace) 3294 { 3295 printf ("\033[33m%s\033[0m %02x\n", 3296 "/** 0110 1101 or %0, %e1 */", 3297 op[0]); 3298 } 3299 SYNTAX("or %0, %e1"); 3300#line 942 "rl78-decode.opc" 3301 ID(or); DR(A); SM(HL, 0); Fz; 3302 3303 } 3304 break; 3305 case 0x6e: 3306 { 3307 /** 0110 1110 or %0, %e1 */ 3308 if (trace) 3309 { 3310 printf ("\033[33m%s\033[0m %02x\n", 3311 "/** 0110 1110 or %0, %e1 */", 3312 op[0]); 3313 } 3314 SYNTAX("or %0, %e1"); 3315#line 948 "rl78-decode.opc" 3316 ID(or); DR(A); SM(HL, IMMU(1)); Fz; 3317 3318 } 3319 break; 3320 case 0x6f: 3321 { 3322 /** 0110 1111 or %0, %e!1 */ 3323 if (trace) 3324 { 3325 printf ("\033[33m%s\033[0m %02x\n", 3326 "/** 0110 1111 or %0, %e!1 */", 3327 op[0]); 3328 } 3329 SYNTAX("or %0, %e!1"); 3330#line 939 "rl78-decode.opc" 3331 ID(or); DR(A); SM(None, IMMU(2)); Fz; 3332 3333 } 3334 break; 3335 case 0x70: 3336 case 0x72: 3337 case 0x73: 3338 case 0x74: 3339 case 0x75: 3340 case 0x76: 3341 case 0x77: 3342 { 3343 /** 0111 0rba mov %0, %1 */ 3344#line 695 "rl78-decode.opc" 3345 int rba AU = op[0] & 0x07; 3346 if (trace) 3347 { 3348 printf ("\033[33m%s\033[0m %02x\n", 3349 "/** 0111 0rba mov %0, %1 */", 3350 op[0]); 3351 printf (" rba = 0x%x\n", rba); 3352 } 3353 SYNTAX("mov %0, %1"); 3354#line 695 "rl78-decode.opc" 3355 ID(mov); DRB(rba); SR(A); 3356 3357 } 3358 break; 3359 case 0x71: 3360 GETBYTE (); 3361 switch (op[1] & 0xff) 3362 { 3363 case 0x00: 3364 case 0x10: 3365 case 0x20: 3366 case 0x30: 3367 case 0x40: 3368 case 0x50: 3369 case 0x60: 3370 case 0x70: 3371 { 3372 /** 0111 0001 0bit 0000 set1 %e!0 */ 3373#line 1045 "rl78-decode.opc" 3374 int bit AU = (op[1] >> 4) & 0x07; 3375 if (trace) 3376 { 3377 printf ("\033[33m%s\033[0m %02x %02x\n", 3378 "/** 0111 0001 0bit 0000 set1 %e!0 */", 3379 op[0], op[1]); 3380 printf (" bit = 0x%x\n", bit); 3381 } 3382 SYNTAX("set1 %e!0"); 3383#line 1045 "rl78-decode.opc" 3384 ID(mov); DM(None, IMMU(2)); DB(bit); SC(1); 3385 3386 } 3387 break; 3388 case 0x01: 3389 case 0x11: 3390 case 0x21: 3391 case 0x31: 3392 case 0x41: 3393 case 0x51: 3394 case 0x61: 3395 case 0x71: 3396 { 3397 /** 0111 0001 0bit 0001 mov1 %0, cy */ 3398#line 802 "rl78-decode.opc" 3399 int bit AU = (op[1] >> 4) & 0x07; 3400 if (trace) 3401 { 3402 printf ("\033[33m%s\033[0m %02x %02x\n", 3403 "/** 0111 0001 0bit 0001 mov1 %0, cy */", 3404 op[0], op[1]); 3405 printf (" bit = 0x%x\n", bit); 3406 } 3407 SYNTAX("mov1 %0, cy"); 3408#line 802 "rl78-decode.opc" 3409 ID(mov); DM(None, SADDR); DB(bit); SCY(); 3410 3411 } 3412 break; 3413 case 0x02: 3414 case 0x12: 3415 case 0x22: 3416 case 0x32: 3417 case 0x42: 3418 case 0x52: 3419 case 0x62: 3420 case 0x72: 3421 { 3422 /** 0111 0001 0bit 0010 set1 %0 */ 3423#line 1063 "rl78-decode.opc" 3424 int bit AU = (op[1] >> 4) & 0x07; 3425 if (trace) 3426 { 3427 printf ("\033[33m%s\033[0m %02x %02x\n", 3428 "/** 0111 0001 0bit 0010 set1 %0 */", 3429 op[0], op[1]); 3430 printf (" bit = 0x%x\n", bit); 3431 } 3432 SYNTAX("set1 %0"); 3433#line 1063 "rl78-decode.opc" 3434 ID(mov); DM(None, SADDR); DB(bit); SC(1); 3435 3436 /*----------------------------------------------------------------------*/ 3437 3438 } 3439 break; 3440 case 0x03: 3441 case 0x13: 3442 case 0x23: 3443 case 0x33: 3444 case 0x43: 3445 case 0x53: 3446 case 0x63: 3447 case 0x73: 3448 { 3449 /** 0111 0001 0bit 0011 clr1 %0 */ 3450#line 455 "rl78-decode.opc" 3451 int bit AU = (op[1] >> 4) & 0x07; 3452 if (trace) 3453 { 3454 printf ("\033[33m%s\033[0m %02x %02x\n", 3455 "/** 0111 0001 0bit 0011 clr1 %0 */", 3456 op[0], op[1]); 3457 printf (" bit = 0x%x\n", bit); 3458 } 3459 SYNTAX("clr1 %0"); 3460#line 455 "rl78-decode.opc" 3461 ID(mov); DM(None, SADDR); DB(bit); SC(0); 3462 3463 /*----------------------------------------------------------------------*/ 3464 3465 } 3466 break; 3467 case 0x04: 3468 case 0x14: 3469 case 0x24: 3470 case 0x34: 3471 case 0x44: 3472 case 0x54: 3473 case 0x64: 3474 case 0x74: 3475 { 3476 /** 0111 0001 0bit 0100 mov1 cy, %1 */ 3477#line 796 "rl78-decode.opc" 3478 int bit AU = (op[1] >> 4) & 0x07; 3479 if (trace) 3480 { 3481 printf ("\033[33m%s\033[0m %02x %02x\n", 3482 "/** 0111 0001 0bit 0100 mov1 cy, %1 */", 3483 op[0], op[1]); 3484 printf (" bit = 0x%x\n", bit); 3485 } 3486 SYNTAX("mov1 cy, %1"); 3487#line 796 "rl78-decode.opc" 3488 ID(mov); DCY(); SM(None, SADDR); SB(bit); 3489 3490 } 3491 break; 3492 case 0x05: 3493 case 0x15: 3494 case 0x25: 3495 case 0x35: 3496 case 0x45: 3497 case 0x55: 3498 case 0x65: 3499 case 0x75: 3500 { 3501 /** 0111 0001 0bit 0101 and1 cy, %s1 */ 3502#line 325 "rl78-decode.opc" 3503 int bit AU = (op[1] >> 4) & 0x07; 3504 if (trace) 3505 { 3506 printf ("\033[33m%s\033[0m %02x %02x\n", 3507 "/** 0111 0001 0bit 0101 and1 cy, %s1 */", 3508 op[0], op[1]); 3509 printf (" bit = 0x%x\n", bit); 3510 } 3511 SYNTAX("and1 cy, %s1"); 3512#line 325 "rl78-decode.opc" 3513 ID(and); DCY(); SM(None, SADDR); SB(bit); 3514 3515 /*----------------------------------------------------------------------*/ 3516 3517 /* Note that the branch insns need to be listed before the shift 3518 ones, as "shift count of zero" means "branch insn" */ 3519 3520 } 3521 break; 3522 case 0x06: 3523 case 0x16: 3524 case 0x26: 3525 case 0x36: 3526 case 0x46: 3527 case 0x56: 3528 case 0x66: 3529 case 0x76: 3530 { 3531 /** 0111 0001 0bit 0110 or1 cy, %s1 */ 3532#line 980 "rl78-decode.opc" 3533 int bit AU = (op[1] >> 4) & 0x07; 3534 if (trace) 3535 { 3536 printf ("\033[33m%s\033[0m %02x %02x\n", 3537 "/** 0111 0001 0bit 0110 or1 cy, %s1 */", 3538 op[0], op[1]); 3539 printf (" bit = 0x%x\n", bit); 3540 } 3541 SYNTAX("or1 cy, %s1"); 3542#line 980 "rl78-decode.opc" 3543 ID(or); DCY(); SM(None, SADDR); SB(bit); 3544 3545 /*----------------------------------------------------------------------*/ 3546 3547 } 3548 break; 3549 case 0x07: 3550 case 0x17: 3551 case 0x27: 3552 case 0x37: 3553 case 0x47: 3554 case 0x57: 3555 case 0x67: 3556 case 0x77: 3557 { 3558 /** 0111 0001 0bit 0111 xor1 cy, %s1 */ 3559#line 1284 "rl78-decode.opc" 3560 int bit AU = (op[1] >> 4) & 0x07; 3561 if (trace) 3562 { 3563 printf ("\033[33m%s\033[0m %02x %02x\n", 3564 "/** 0111 0001 0bit 0111 xor1 cy, %s1 */", 3565 op[0], op[1]); 3566 printf (" bit = 0x%x\n", bit); 3567 } 3568 SYNTAX("xor1 cy, %s1"); 3569#line 1284 "rl78-decode.opc" 3570 ID(xor); DCY(); SM(None, SADDR); SB(bit); 3571 3572 /*----------------------------------------------------------------------*/ 3573 3574 } 3575 break; 3576 case 0x08: 3577 case 0x18: 3578 case 0x28: 3579 case 0x38: 3580 case 0x48: 3581 case 0x58: 3582 case 0x68: 3583 case 0x78: 3584 { 3585 /** 0111 0001 0bit 1000 clr1 %e!0 */ 3586#line 437 "rl78-decode.opc" 3587 int bit AU = (op[1] >> 4) & 0x07; 3588 if (trace) 3589 { 3590 printf ("\033[33m%s\033[0m %02x %02x\n", 3591 "/** 0111 0001 0bit 1000 clr1 %e!0 */", 3592 op[0], op[1]); 3593 printf (" bit = 0x%x\n", bit); 3594 } 3595 SYNTAX("clr1 %e!0"); 3596#line 437 "rl78-decode.opc" 3597 ID(mov); DM(None, IMMU(2)); DB(bit); SC(0); 3598 3599 } 3600 break; 3601 case 0x09: 3602 case 0x19: 3603 case 0x29: 3604 case 0x39: 3605 case 0x49: 3606 case 0x59: 3607 case 0x69: 3608 case 0x79: 3609 { 3610 /** 0111 0001 0bit 1001 mov1 %s0, cy */ 3611#line 805 "rl78-decode.opc" 3612 int bit AU = (op[1] >> 4) & 0x07; 3613 if (trace) 3614 { 3615 printf ("\033[33m%s\033[0m %02x %02x\n", 3616 "/** 0111 0001 0bit 1001 mov1 %s0, cy */", 3617 op[0], op[1]); 3618 printf (" bit = 0x%x\n", bit); 3619 } 3620 SYNTAX("mov1 %s0, cy"); 3621#line 805 "rl78-decode.opc" 3622 ID(mov); DM(None, SFR); DB(bit); SCY(); 3623 3624 /*----------------------------------------------------------------------*/ 3625 3626 } 3627 break; 3628 case 0x0a: 3629 case 0x1a: 3630 case 0x2a: 3631 case 0x3a: 3632 case 0x4a: 3633 case 0x5a: 3634 case 0x6a: 3635 case 0x7a: 3636 { 3637 /** 0111 0001 0bit 1010 set1 %s0 */ 3638#line 1057 "rl78-decode.opc" 3639 int bit AU = (op[1] >> 4) & 0x07; 3640 if (trace) 3641 { 3642 printf ("\033[33m%s\033[0m %02x %02x\n", 3643 "/** 0111 0001 0bit 1010 set1 %s0 */", 3644 op[0], op[1]); 3645 printf (" bit = 0x%x\n", bit); 3646 } 3647 SYNTAX("set1 %s0"); 3648#line 1057 "rl78-decode.opc" 3649 op0 = SFR; 3650 ID(mov); DM(None, op0); DB(bit); SC(1); 3651 if (op0 == RL78_SFR_PSW && bit == 7) 3652 rl78->syntax = "ei"; 3653 3654 } 3655 break; 3656 case 0x0b: 3657 case 0x1b: 3658 case 0x2b: 3659 case 0x3b: 3660 case 0x4b: 3661 case 0x5b: 3662 case 0x6b: 3663 case 0x7b: 3664 { 3665 /** 0111 0001 0bit 1011 clr1 %s0 */ 3666#line 449 "rl78-decode.opc" 3667 int bit AU = (op[1] >> 4) & 0x07; 3668 if (trace) 3669 { 3670 printf ("\033[33m%s\033[0m %02x %02x\n", 3671 "/** 0111 0001 0bit 1011 clr1 %s0 */", 3672 op[0], op[1]); 3673 printf (" bit = 0x%x\n", bit); 3674 } 3675 SYNTAX("clr1 %s0"); 3676#line 449 "rl78-decode.opc" 3677 op0 = SFR; 3678 ID(mov); DM(None, op0); DB(bit); SC(0); 3679 if (op0 == RL78_SFR_PSW && bit == 7) 3680 rl78->syntax = "di"; 3681 3682 } 3683 break; 3684 case 0x0c: 3685 case 0x1c: 3686 case 0x2c: 3687 case 0x3c: 3688 case 0x4c: 3689 case 0x5c: 3690 case 0x6c: 3691 case 0x7c: 3692 { 3693 /** 0111 0001 0bit 1100 mov1 cy, %s1 */ 3694#line 799 "rl78-decode.opc" 3695 int bit AU = (op[1] >> 4) & 0x07; 3696 if (trace) 3697 { 3698 printf ("\033[33m%s\033[0m %02x %02x\n", 3699 "/** 0111 0001 0bit 1100 mov1 cy, %s1 */", 3700 op[0], op[1]); 3701 printf (" bit = 0x%x\n", bit); 3702 } 3703 SYNTAX("mov1 cy, %s1"); 3704#line 799 "rl78-decode.opc" 3705 ID(mov); DCY(); SM(None, SFR); SB(bit); 3706 3707 } 3708 break; 3709 case 0x0d: 3710 case 0x1d: 3711 case 0x2d: 3712 case 0x3d: 3713 case 0x4d: 3714 case 0x5d: 3715 case 0x6d: 3716 case 0x7d: 3717 { 3718 /** 0111 0001 0bit 1101 and1 cy, %s1 */ 3719#line 322 "rl78-decode.opc" 3720 int bit AU = (op[1] >> 4) & 0x07; 3721 if (trace) 3722 { 3723 printf ("\033[33m%s\033[0m %02x %02x\n", 3724 "/** 0111 0001 0bit 1101 and1 cy, %s1 */", 3725 op[0], op[1]); 3726 printf (" bit = 0x%x\n", bit); 3727 } 3728 SYNTAX("and1 cy, %s1"); 3729#line 322 "rl78-decode.opc" 3730 ID(and); DCY(); SM(None, SFR); SB(bit); 3731 3732 } 3733 break; 3734 case 0x0e: 3735 case 0x1e: 3736 case 0x2e: 3737 case 0x3e: 3738 case 0x4e: 3739 case 0x5e: 3740 case 0x6e: 3741 case 0x7e: 3742 { 3743 /** 0111 0001 0bit 1110 or1 cy, %s1 */ 3744#line 977 "rl78-decode.opc" 3745 int bit AU = (op[1] >> 4) & 0x07; 3746 if (trace) 3747 { 3748 printf ("\033[33m%s\033[0m %02x %02x\n", 3749 "/** 0111 0001 0bit 1110 or1 cy, %s1 */", 3750 op[0], op[1]); 3751 printf (" bit = 0x%x\n", bit); 3752 } 3753 SYNTAX("or1 cy, %s1"); 3754#line 977 "rl78-decode.opc" 3755 ID(or); DCY(); SM(None, SFR); SB(bit); 3756 3757 } 3758 break; 3759 case 0x0f: 3760 case 0x1f: 3761 case 0x2f: 3762 case 0x3f: 3763 case 0x4f: 3764 case 0x5f: 3765 case 0x6f: 3766 case 0x7f: 3767 { 3768 /** 0111 0001 0bit 1111 xor1 cy, %s1 */ 3769#line 1281 "rl78-decode.opc" 3770 int bit AU = (op[1] >> 4) & 0x07; 3771 if (trace) 3772 { 3773 printf ("\033[33m%s\033[0m %02x %02x\n", 3774 "/** 0111 0001 0bit 1111 xor1 cy, %s1 */", 3775 op[0], op[1]); 3776 printf (" bit = 0x%x\n", bit); 3777 } 3778 SYNTAX("xor1 cy, %s1"); 3779#line 1281 "rl78-decode.opc" 3780 ID(xor); DCY(); SM(None, SFR); SB(bit); 3781 3782 } 3783 break; 3784 case 0x80: 3785 { 3786 /** 0111 0001 1000 0000 set1 cy */ 3787 if (trace) 3788 { 3789 printf ("\033[33m%s\033[0m %02x %02x\n", 3790 "/** 0111 0001 1000 0000 set1 cy */", 3791 op[0], op[1]); 3792 } 3793 SYNTAX("set1 cy"); 3794#line 1054 "rl78-decode.opc" 3795 ID(mov); DCY(); SC(1); 3796 3797 } 3798 break; 3799 case 0x81: 3800 case 0x91: 3801 case 0xa1: 3802 case 0xb1: 3803 case 0xc1: 3804 case 0xd1: 3805 case 0xe1: 3806 case 0xf1: 3807 { 3808 /** 0111 0001 1bit 0001 mov1 %e0, cy */ 3809#line 784 "rl78-decode.opc" 3810 int bit AU = (op[1] >> 4) & 0x07; 3811 if (trace) 3812 { 3813 printf ("\033[33m%s\033[0m %02x %02x\n", 3814 "/** 0111 0001 1bit 0001 mov1 %e0, cy */", 3815 op[0], op[1]); 3816 printf (" bit = 0x%x\n", bit); 3817 } 3818 SYNTAX("mov1 %e0, cy"); 3819#line 784 "rl78-decode.opc" 3820 ID(mov); DM(HL, 0); DB(bit); SCY(); 3821 3822 } 3823 break; 3824 case 0x82: 3825 case 0x92: 3826 case 0xa2: 3827 case 0xb2: 3828 case 0xc2: 3829 case 0xd2: 3830 case 0xe2: 3831 case 0xf2: 3832 { 3833 /** 0111 0001 1bit 0010 set1 %e0 */ 3834#line 1048 "rl78-decode.opc" 3835 int bit AU = (op[1] >> 4) & 0x07; 3836 if (trace) 3837 { 3838 printf ("\033[33m%s\033[0m %02x %02x\n", 3839 "/** 0111 0001 1bit 0010 set1 %e0 */", 3840 op[0], op[1]); 3841 printf (" bit = 0x%x\n", bit); 3842 } 3843 SYNTAX("set1 %e0"); 3844#line 1048 "rl78-decode.opc" 3845 ID(mov); DM(HL, 0); DB(bit); SC(1); 3846 3847 } 3848 break; 3849 case 0x83: 3850 case 0x93: 3851 case 0xa3: 3852 case 0xb3: 3853 case 0xc3: 3854 case 0xd3: 3855 case 0xe3: 3856 case 0xf3: 3857 { 3858 /** 0111 0001 1bit 0011 clr1 %e0 */ 3859#line 440 "rl78-decode.opc" 3860 int bit AU = (op[1] >> 4) & 0x07; 3861 if (trace) 3862 { 3863 printf ("\033[33m%s\033[0m %02x %02x\n", 3864 "/** 0111 0001 1bit 0011 clr1 %e0 */", 3865 op[0], op[1]); 3866 printf (" bit = 0x%x\n", bit); 3867 } 3868 SYNTAX("clr1 %e0"); 3869#line 440 "rl78-decode.opc" 3870 ID(mov); DM(HL, 0); DB(bit); SC(0); 3871 3872 } 3873 break; 3874 case 0x84: 3875 case 0x94: 3876 case 0xa4: 3877 case 0xb4: 3878 case 0xc4: 3879 case 0xd4: 3880 case 0xe4: 3881 case 0xf4: 3882 { 3883 /** 0111 0001 1bit 0100 mov1 cy, %e1 */ 3884#line 790 "rl78-decode.opc" 3885 int bit AU = (op[1] >> 4) & 0x07; 3886 if (trace) 3887 { 3888 printf ("\033[33m%s\033[0m %02x %02x\n", 3889 "/** 0111 0001 1bit 0100 mov1 cy, %e1 */", 3890 op[0], op[1]); 3891 printf (" bit = 0x%x\n", bit); 3892 } 3893 SYNTAX("mov1 cy, %e1"); 3894#line 790 "rl78-decode.opc" 3895 ID(mov); DCY(); SM(HL, 0); SB(bit); 3896 3897 } 3898 break; 3899 case 0x85: 3900 case 0x95: 3901 case 0xa5: 3902 case 0xb5: 3903 case 0xc5: 3904 case 0xd5: 3905 case 0xe5: 3906 case 0xf5: 3907 { 3908 /** 0111 0001 1bit 0101 and1 cy, %e1 */ 3909#line 316 "rl78-decode.opc" 3910 int bit AU = (op[1] >> 4) & 0x07; 3911 if (trace) 3912 { 3913 printf ("\033[33m%s\033[0m %02x %02x\n", 3914 "/** 0111 0001 1bit 0101 and1 cy, %e1 */", 3915 op[0], op[1]); 3916 printf (" bit = 0x%x\n", bit); 3917 } 3918 SYNTAX("and1 cy, %e1"); 3919#line 316 "rl78-decode.opc" 3920 ID(and); DCY(); SM(HL, 0); SB(bit); 3921 3922 } 3923 break; 3924 case 0x86: 3925 case 0x96: 3926 case 0xa6: 3927 case 0xb6: 3928 case 0xc6: 3929 case 0xd6: 3930 case 0xe6: 3931 case 0xf6: 3932 { 3933 /** 0111 0001 1bit 0110 or1 cy, %e1 */ 3934#line 971 "rl78-decode.opc" 3935 int bit AU = (op[1] >> 4) & 0x07; 3936 if (trace) 3937 { 3938 printf ("\033[33m%s\033[0m %02x %02x\n", 3939 "/** 0111 0001 1bit 0110 or1 cy, %e1 */", 3940 op[0], op[1]); 3941 printf (" bit = 0x%x\n", bit); 3942 } 3943 SYNTAX("or1 cy, %e1"); 3944#line 971 "rl78-decode.opc" 3945 ID(or); DCY(); SM(HL, 0); SB(bit); 3946 3947 } 3948 break; 3949 case 0x87: 3950 case 0x97: 3951 case 0xa7: 3952 case 0xb7: 3953 case 0xc7: 3954 case 0xd7: 3955 case 0xe7: 3956 case 0xf7: 3957 { 3958 /** 0111 0001 1bit 0111 xor1 cy, %e1 */ 3959#line 1275 "rl78-decode.opc" 3960 int bit AU = (op[1] >> 4) & 0x07; 3961 if (trace) 3962 { 3963 printf ("\033[33m%s\033[0m %02x %02x\n", 3964 "/** 0111 0001 1bit 0111 xor1 cy, %e1 */", 3965 op[0], op[1]); 3966 printf (" bit = 0x%x\n", bit); 3967 } 3968 SYNTAX("xor1 cy, %e1"); 3969#line 1275 "rl78-decode.opc" 3970 ID(xor); DCY(); SM(HL, 0); SB(bit); 3971 3972 } 3973 break; 3974 case 0x88: 3975 { 3976 /** 0111 0001 1000 1000 clr1 cy */ 3977 if (trace) 3978 { 3979 printf ("\033[33m%s\033[0m %02x %02x\n", 3980 "/** 0111 0001 1000 1000 clr1 cy */", 3981 op[0], op[1]); 3982 } 3983 SYNTAX("clr1 cy"); 3984#line 446 "rl78-decode.opc" 3985 ID(mov); DCY(); SC(0); 3986 3987 } 3988 break; 3989 case 0x89: 3990 case 0x99: 3991 case 0xa9: 3992 case 0xb9: 3993 case 0xc9: 3994 case 0xd9: 3995 case 0xe9: 3996 case 0xf9: 3997 { 3998 /** 0111 0001 1bit 1001 mov1 %e0, cy */ 3999#line 787 "rl78-decode.opc" 4000 int bit AU = (op[1] >> 4) & 0x07; 4001 if (trace) 4002 { 4003 printf ("\033[33m%s\033[0m %02x %02x\n", 4004 "/** 0111 0001 1bit 1001 mov1 %e0, cy */", 4005 op[0], op[1]); 4006 printf (" bit = 0x%x\n", bit); 4007 } 4008 SYNTAX("mov1 %e0, cy"); 4009#line 787 "rl78-decode.opc" 4010 ID(mov); DR(A); DB(bit); SCY(); 4011 4012 } 4013 break; 4014 case 0x8a: 4015 case 0x9a: 4016 case 0xaa: 4017 case 0xba: 4018 case 0xca: 4019 case 0xda: 4020 case 0xea: 4021 case 0xfa: 4022 { 4023 /** 0111 0001 1bit 1010 set1 %0 */ 4024#line 1051 "rl78-decode.opc" 4025 int bit AU = (op[1] >> 4) & 0x07; 4026 if (trace) 4027 { 4028 printf ("\033[33m%s\033[0m %02x %02x\n", 4029 "/** 0111 0001 1bit 1010 set1 %0 */", 4030 op[0], op[1]); 4031 printf (" bit = 0x%x\n", bit); 4032 } 4033 SYNTAX("set1 %0"); 4034#line 1051 "rl78-decode.opc" 4035 ID(mov); DR(A); DB(bit); SC(1); 4036 4037 } 4038 break; 4039 case 0x8b: 4040 case 0x9b: 4041 case 0xab: 4042 case 0xbb: 4043 case 0xcb: 4044 case 0xdb: 4045 case 0xeb: 4046 case 0xfb: 4047 { 4048 /** 0111 0001 1bit 1011 clr1 %0 */ 4049#line 443 "rl78-decode.opc" 4050 int bit AU = (op[1] >> 4) & 0x07; 4051 if (trace) 4052 { 4053 printf ("\033[33m%s\033[0m %02x %02x\n", 4054 "/** 0111 0001 1bit 1011 clr1 %0 */", 4055 op[0], op[1]); 4056 printf (" bit = 0x%x\n", bit); 4057 } 4058 SYNTAX("clr1 %0"); 4059#line 443 "rl78-decode.opc" 4060 ID(mov); DR(A); DB(bit); SC(0); 4061 4062 } 4063 break; 4064 case 0x8c: 4065 case 0x9c: 4066 case 0xac: 4067 case 0xbc: 4068 case 0xcc: 4069 case 0xdc: 4070 case 0xec: 4071 case 0xfc: 4072 { 4073 /** 0111 0001 1bit 1100 mov1 cy, %e1 */ 4074#line 793 "rl78-decode.opc" 4075 int bit AU = (op[1] >> 4) & 0x07; 4076 if (trace) 4077 { 4078 printf ("\033[33m%s\033[0m %02x %02x\n", 4079 "/** 0111 0001 1bit 1100 mov1 cy, %e1 */", 4080 op[0], op[1]); 4081 printf (" bit = 0x%x\n", bit); 4082 } 4083 SYNTAX("mov1 cy, %e1"); 4084#line 793 "rl78-decode.opc" 4085 ID(mov); DCY(); SR(A); SB(bit); 4086 4087 } 4088 break; 4089 case 0x8d: 4090 case 0x9d: 4091 case 0xad: 4092 case 0xbd: 4093 case 0xcd: 4094 case 0xdd: 4095 case 0xed: 4096 case 0xfd: 4097 { 4098 /** 0111 0001 1bit 1101 and1 cy, %1 */ 4099#line 319 "rl78-decode.opc" 4100 int bit AU = (op[1] >> 4) & 0x07; 4101 if (trace) 4102 { 4103 printf ("\033[33m%s\033[0m %02x %02x\n", 4104 "/** 0111 0001 1bit 1101 and1 cy, %1 */", 4105 op[0], op[1]); 4106 printf (" bit = 0x%x\n", bit); 4107 } 4108 SYNTAX("and1 cy, %1"); 4109#line 319 "rl78-decode.opc" 4110 ID(and); DCY(); SR(A); SB(bit); 4111 4112 } 4113 break; 4114 case 0x8e: 4115 case 0x9e: 4116 case 0xae: 4117 case 0xbe: 4118 case 0xce: 4119 case 0xde: 4120 case 0xee: 4121 case 0xfe: 4122 { 4123 /** 0111 0001 1bit 1110 or1 cy, %1 */ 4124#line 974 "rl78-decode.opc" 4125 int bit AU = (op[1] >> 4) & 0x07; 4126 if (trace) 4127 { 4128 printf ("\033[33m%s\033[0m %02x %02x\n", 4129 "/** 0111 0001 1bit 1110 or1 cy, %1 */", 4130 op[0], op[1]); 4131 printf (" bit = 0x%x\n", bit); 4132 } 4133 SYNTAX("or1 cy, %1"); 4134#line 974 "rl78-decode.opc" 4135 ID(or); DCY(); SR(A); SB(bit); 4136 4137 } 4138 break; 4139 case 0x8f: 4140 case 0x9f: 4141 case 0xaf: 4142 case 0xbf: 4143 case 0xcf: 4144 case 0xdf: 4145 case 0xef: 4146 case 0xff: 4147 { 4148 /** 0111 0001 1bit 1111 xor1 cy, %1 */ 4149#line 1278 "rl78-decode.opc" 4150 int bit AU = (op[1] >> 4) & 0x07; 4151 if (trace) 4152 { 4153 printf ("\033[33m%s\033[0m %02x %02x\n", 4154 "/** 0111 0001 1bit 1111 xor1 cy, %1 */", 4155 op[0], op[1]); 4156 printf (" bit = 0x%x\n", bit); 4157 } 4158 SYNTAX("xor1 cy, %1"); 4159#line 1278 "rl78-decode.opc" 4160 ID(xor); DCY(); SR(A); SB(bit); 4161 4162 } 4163 break; 4164 case 0xc0: 4165 { 4166 /** 0111 0001 1100 0000 not1 cy */ 4167 if (trace) 4168 { 4169 printf ("\033[33m%s\033[0m %02x %02x\n", 4170 "/** 0111 0001 1100 0000 not1 cy */", 4171 op[0], op[1]); 4172 } 4173 SYNTAX("not1 cy"); 4174#line 915 "rl78-decode.opc" 4175 ID(xor); DCY(); SC(1); 4176 4177 /*----------------------------------------------------------------------*/ 4178 4179 } 4180 break; 4181 default: UNSUPPORTED(); break; 4182 } 4183 break; 4184 case 0x78: 4185 { 4186 /** 0111 1000 movw %e0, %1 */ 4187 if (trace) 4188 { 4189 printf ("\033[33m%s\033[0m %02x\n", 4190 "/** 0111 1000 movw %e0, %1 */", 4191 op[0]); 4192 } 4193 SYNTAX("movw %e0, %1"); 4194#line 876 "rl78-decode.opc" 4195 ID(mov); W(); DM(BC, IMMU(2)); SR(AX); 4196 4197 } 4198 break; 4199 case 0x79: 4200 { 4201 /** 0111 1001 movw %0, %e1 */ 4202 if (trace) 4203 { 4204 printf ("\033[33m%s\033[0m %02x\n", 4205 "/** 0111 1001 movw %0, %e1 */", 4206 op[0]); 4207 } 4208 SYNTAX("movw %0, %e1"); 4209#line 867 "rl78-decode.opc" 4210 ID(mov); W(); DR(AX); SM(BC, IMMU(2)); 4211 4212 } 4213 break; 4214 case 0x7a: 4215 { 4216 /** 0111 1010 xor %0, #%1 */ 4217 if (trace) 4218 { 4219 printf ("\033[33m%s\033[0m %02x\n", 4220 "/** 0111 1010 xor %0, #%1 */", 4221 op[0]); 4222 } 4223 SYNTAX("xor %0, #%1"); 4224#line 1270 "rl78-decode.opc" 4225 ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz; 4226 4227 /*----------------------------------------------------------------------*/ 4228 4229 } 4230 break; 4231 case 0x7b: 4232 { 4233 /** 0111 1011 xor %0, %1 */ 4234 if (trace) 4235 { 4236 printf ("\033[33m%s\033[0m %02x\n", 4237 "/** 0111 1011 xor %0, %1 */", 4238 op[0]); 4239 } 4240 SYNTAX("xor %0, %1"); 4241#line 1267 "rl78-decode.opc" 4242 ID(xor); DR(A); SM(None, SADDR); Fz; 4243 4244 } 4245 break; 4246 case 0x7c: 4247 { 4248 /** 0111 1100 xor %0, #%1 */ 4249 if (trace) 4250 { 4251 printf ("\033[33m%s\033[0m %02x\n", 4252 "/** 0111 1100 xor %0, #%1 */", 4253 op[0]); 4254 } 4255 SYNTAX("xor %0, #%1"); 4256#line 1258 "rl78-decode.opc" 4257 ID(xor); DR(A); SC(IMMU(1)); Fz; 4258 4259 } 4260 break; 4261 case 0x7d: 4262 { 4263 /** 0111 1101 xor %0, %e1 */ 4264 if (trace) 4265 { 4266 printf ("\033[33m%s\033[0m %02x\n", 4267 "/** 0111 1101 xor %0, %e1 */", 4268 op[0]); 4269 } 4270 SYNTAX("xor %0, %e1"); 4271#line 1246 "rl78-decode.opc" 4272 ID(xor); DR(A); SM(HL, 0); Fz; 4273 4274 } 4275 break; 4276 case 0x7e: 4277 { 4278 /** 0111 1110 xor %0, %e1 */ 4279 if (trace) 4280 { 4281 printf ("\033[33m%s\033[0m %02x\n", 4282 "/** 0111 1110 xor %0, %e1 */", 4283 op[0]); 4284 } 4285 SYNTAX("xor %0, %e1"); 4286#line 1252 "rl78-decode.opc" 4287 ID(xor); DR(A); SM(HL, IMMU(1)); Fz; 4288 4289 } 4290 break; 4291 case 0x7f: 4292 { 4293 /** 0111 1111 xor %0, %e!1 */ 4294 if (trace) 4295 { 4296 printf ("\033[33m%s\033[0m %02x\n", 4297 "/** 0111 1111 xor %0, %e!1 */", 4298 op[0]); 4299 } 4300 SYNTAX("xor %0, %e!1"); 4301#line 1243 "rl78-decode.opc" 4302 ID(xor); DR(A); SM(None, IMMU(2)); Fz; 4303 4304 } 4305 break; 4306 case 0x80: 4307 case 0x81: 4308 case 0x82: 4309 case 0x83: 4310 case 0x84: 4311 case 0x85: 4312 case 0x86: 4313 case 0x87: 4314 { 4315 /** 1000 0reg inc %0 */ 4316#line 586 "rl78-decode.opc" 4317 int reg AU = op[0] & 0x07; 4318 if (trace) 4319 { 4320 printf ("\033[33m%s\033[0m %02x\n", 4321 "/** 1000 0reg inc %0 */", 4322 op[0]); 4323 printf (" reg = 0x%x\n", reg); 4324 } 4325 SYNTAX("inc %0"); 4326#line 586 "rl78-decode.opc" 4327 ID(add); DRB(reg); SC(1); Fza; 4328 4329 } 4330 break; 4331 case 0x88: 4332 { 4333 /** 1000 1000 mov %0, %e1 */ 4334 if (trace) 4335 { 4336 printf ("\033[33m%s\033[0m %02x\n", 4337 "/** 1000 1000 mov %0, %e1 */", 4338 op[0]); 4339 } 4340 SYNTAX("mov %0, %e1"); 4341#line 665 "rl78-decode.opc" 4342 ID(mov); DR(A); SM(SP, IMMU(1)); 4343 4344 } 4345 break; 4346 case 0x89: 4347 { 4348 /** 1000 1001 mov %0, %e1 */ 4349 if (trace) 4350 { 4351 printf ("\033[33m%s\033[0m %02x\n", 4352 "/** 1000 1001 mov %0, %e1 */", 4353 op[0]); 4354 } 4355 SYNTAX("mov %0, %e1"); 4356#line 647 "rl78-decode.opc" 4357 ID(mov); DR(A); SM(DE, 0); 4358 4359 } 4360 break; 4361 case 0x8a: 4362 { 4363 /** 1000 1010 mov %0, %e1 */ 4364 if (trace) 4365 { 4366 printf ("\033[33m%s\033[0m %02x\n", 4367 "/** 1000 1010 mov %0, %e1 */", 4368 op[0]); 4369 } 4370 SYNTAX("mov %0, %e1"); 4371#line 650 "rl78-decode.opc" 4372 ID(mov); DR(A); SM(DE, IMMU(1)); 4373 4374 } 4375 break; 4376 case 0x8b: 4377 { 4378 /** 1000 1011 mov %0, %e1 */ 4379 if (trace) 4380 { 4381 printf ("\033[33m%s\033[0m %02x\n", 4382 "/** 1000 1011 mov %0, %e1 */", 4383 op[0]); 4384 } 4385 SYNTAX("mov %0, %e1"); 4386#line 653 "rl78-decode.opc" 4387 ID(mov); DR(A); SM(HL, 0); 4388 4389 } 4390 break; 4391 case 0x8c: 4392 { 4393 /** 1000 1100 mov %0, %e1 */ 4394 if (trace) 4395 { 4396 printf ("\033[33m%s\033[0m %02x\n", 4397 "/** 1000 1100 mov %0, %e1 */", 4398 op[0]); 4399 } 4400 SYNTAX("mov %0, %e1"); 4401#line 656 "rl78-decode.opc" 4402 ID(mov); DR(A); SM(HL, IMMU(1)); 4403 4404 } 4405 break; 4406 case 0x8d: 4407 { 4408 /** 1000 1101 mov %0, %1 */ 4409 if (trace) 4410 { 4411 printf ("\033[33m%s\033[0m %02x\n", 4412 "/** 1000 1101 mov %0, %1 */", 4413 op[0]); 4414 } 4415 SYNTAX("mov %0, %1"); 4416#line 689 "rl78-decode.opc" 4417 ID(mov); DR(A); SM(None, SADDR); 4418 4419 } 4420 break; 4421 case 0x8e: 4422 { 4423 /** 1000 1110 mov %0, %s1 */ 4424 if (trace) 4425 { 4426 printf ("\033[33m%s\033[0m %02x\n", 4427 "/** 1000 1110 mov %0, %s1 */", 4428 op[0]); 4429 } 4430 SYNTAX("mov %0, %s1"); 4431#line 686 "rl78-decode.opc" 4432 ID(mov); DR(A); SM(None, SFR); 4433 4434 } 4435 break; 4436 case 0x8f: 4437 { 4438 /** 1000 1111 mov %0, %e!1 */ 4439 if (trace) 4440 { 4441 printf ("\033[33m%s\033[0m %02x\n", 4442 "/** 1000 1111 mov %0, %e!1 */", 4443 op[0]); 4444 } 4445 SYNTAX("mov %0, %e!1"); 4446#line 644 "rl78-decode.opc" 4447 ID(mov); DR(A); SM(None, IMMU(2)); 4448 4449 } 4450 break; 4451 case 0x90: 4452 case 0x91: 4453 case 0x92: 4454 case 0x93: 4455 case 0x94: 4456 case 0x95: 4457 case 0x96: 4458 case 0x97: 4459 { 4460 /** 1001 0reg dec %0 */ 4461#line 553 "rl78-decode.opc" 4462 int reg AU = op[0] & 0x07; 4463 if (trace) 4464 { 4465 printf ("\033[33m%s\033[0m %02x\n", 4466 "/** 1001 0reg dec %0 */", 4467 op[0]); 4468 printf (" reg = 0x%x\n", reg); 4469 } 4470 SYNTAX("dec %0"); 4471#line 553 "rl78-decode.opc" 4472 ID(sub); DRB(reg); SC(1); Fza; 4473 4474 } 4475 break; 4476 case 0x98: 4477 { 4478 /** 1001 1000 mov %0, %1 */ 4479 if (trace) 4480 { 4481 printf ("\033[33m%s\033[0m %02x\n", 4482 "/** 1001 1000 mov %0, %1 */", 4483 op[0]); 4484 } 4485 SYNTAX("mov %0, %1"); 4486#line 641 "rl78-decode.opc" 4487 ID(mov); DM(SP, IMMU(1)); SR(A); 4488 4489 } 4490 break; 4491 case 0x99: 4492 { 4493 /** 1001 1001 mov %e0,%1 */ 4494 if (trace) 4495 { 4496 printf ("\033[33m%s\033[0m %02x\n", 4497 "/** 1001 1001 mov %e0,%1 */", 4498 op[0]); 4499 } 4500 SYNTAX("mov %e0,%1"); 4501#line 614 "rl78-decode.opc" 4502 ID(mov); DM(DE, 0); SR(A); 4503 4504 } 4505 break; 4506 case 0x9a: 4507 { 4508 /** 1001 1010 mov %e0, %1 */ 4509 if (trace) 4510 { 4511 printf ("\033[33m%s\033[0m %02x\n", 4512 "/** 1001 1010 mov %e0, %1 */", 4513 op[0]); 4514 } 4515 SYNTAX("mov %e0, %1"); 4516#line 620 "rl78-decode.opc" 4517 ID(mov); DM(DE, IMMU(1)); SR(A); 4518 4519 } 4520 break; 4521 case 0x9b: 4522 { 4523 /** 1001 1011 mov %e0,%1 */ 4524 if (trace) 4525 { 4526 printf ("\033[33m%s\033[0m %02x\n", 4527 "/** 1001 1011 mov %e0,%1 */", 4528 op[0]); 4529 } 4530 SYNTAX("mov %e0,%1"); 4531#line 623 "rl78-decode.opc" 4532 ID(mov); DM(HL, 0); SR(A); 4533 4534 } 4535 break; 4536 case 0x9c: 4537 { 4538 /** 1001 1100 mov %e0, %1 */ 4539 if (trace) 4540 { 4541 printf ("\033[33m%s\033[0m %02x\n", 4542 "/** 1001 1100 mov %e0, %1 */", 4543 op[0]); 4544 } 4545 SYNTAX("mov %e0, %1"); 4546#line 632 "rl78-decode.opc" 4547 ID(mov); DM(HL, IMMU(1)); SR(A); 4548 4549 } 4550 break; 4551 case 0x9d: 4552 { 4553 /** 1001 1101 mov %0, %1 */ 4554 if (trace) 4555 { 4556 printf ("\033[33m%s\033[0m %02x\n", 4557 "/** 1001 1101 mov %0, %1 */", 4558 op[0]); 4559 } 4560 SYNTAX("mov %0, %1"); 4561#line 746 "rl78-decode.opc" 4562 ID(mov); DM(None, SADDR); SR(A); 4563 4564 } 4565 break; 4566 case 0x9e: 4567 { 4568 /** 1001 1110 mov %0, %1 */ 4569 if (trace) 4570 { 4571 printf ("\033[33m%s\033[0m %02x\n", 4572 "/** 1001 1110 mov %0, %1 */", 4573 op[0]); 4574 } 4575 SYNTAX("mov %0, %1"); 4576#line 779 "rl78-decode.opc" 4577 ID(mov); DM(None, SFR); SR(A); 4578 4579 /*----------------------------------------------------------------------*/ 4580 4581 } 4582 break; 4583 case 0x9f: 4584 { 4585 /** 1001 1111 mov %e!0, %1 */ 4586 if (trace) 4587 { 4588 printf ("\033[33m%s\033[0m %02x\n", 4589 "/** 1001 1111 mov %e!0, %1 */", 4590 op[0]); 4591 } 4592 SYNTAX("mov %e!0, %1"); 4593#line 611 "rl78-decode.opc" 4594 ID(mov); DM(None, IMMU(2)); SR(A); 4595 4596 } 4597 break; 4598 case 0xa0: 4599 { 4600 /** 1010 0000 inc %e!0 */ 4601 if (trace) 4602 { 4603 printf ("\033[33m%s\033[0m %02x\n", 4604 "/** 1010 0000 inc %e!0 */", 4605 op[0]); 4606 } 4607 SYNTAX("inc %e!0"); 4608#line 580 "rl78-decode.opc" 4609 ID(add); DM(None, IMMU(2)); SC(1); Fza; 4610 4611 } 4612 break; 4613 case 0xa1: 4614 case 0xa3: 4615 case 0xa5: 4616 case 0xa7: 4617 { 4618 /** 1010 0rg1 incw %0 */ 4619#line 600 "rl78-decode.opc" 4620 int rg AU = (op[0] >> 1) & 0x03; 4621 if (trace) 4622 { 4623 printf ("\033[33m%s\033[0m %02x\n", 4624 "/** 1010 0rg1 incw %0 */", 4625 op[0]); 4626 printf (" rg = 0x%x\n", rg); 4627 } 4628 SYNTAX("incw %0"); 4629#line 600 "rl78-decode.opc" 4630 ID(add); W(); DRW(rg); SC(1); 4631 4632 } 4633 break; 4634 case 0xa2: 4635 { 4636 /** 1010 0010 incw %e!0 */ 4637 if (trace) 4638 { 4639 printf ("\033[33m%s\033[0m %02x\n", 4640 "/** 1010 0010 incw %e!0 */", 4641 op[0]); 4642 } 4643 SYNTAX("incw %e!0"); 4644#line 594 "rl78-decode.opc" 4645 ID(add); W(); DM(None, IMMU(2)); SC(1); 4646 4647 } 4648 break; 4649 case 0xa4: 4650 { 4651 /** 1010 0100 inc %0 */ 4652 if (trace) 4653 { 4654 printf ("\033[33m%s\033[0m %02x\n", 4655 "/** 1010 0100 inc %0 */", 4656 op[0]); 4657 } 4658 SYNTAX("inc %0"); 4659#line 589 "rl78-decode.opc" 4660 ID(add); DM(None, SADDR); SC(1); Fza; 4661 4662 /*----------------------------------------------------------------------*/ 4663 4664 } 4665 break; 4666 case 0xa6: 4667 { 4668 /** 1010 0110 incw %0 */ 4669 if (trace) 4670 { 4671 printf ("\033[33m%s\033[0m %02x\n", 4672 "/** 1010 0110 incw %0 */", 4673 op[0]); 4674 } 4675 SYNTAX("incw %0"); 4676#line 603 "rl78-decode.opc" 4677 ID(add); W(); DM(None, SADDR); SC(1); 4678 4679 /*----------------------------------------------------------------------*/ 4680 4681 } 4682 break; 4683 case 0xa8: 4684 { 4685 /** 1010 1000 movw %0, %1 */ 4686 if (trace) 4687 { 4688 printf ("\033[33m%s\033[0m %02x\n", 4689 "/** 1010 1000 movw %0, %1 */", 4690 op[0]); 4691 } 4692 SYNTAX("movw %0, %1"); 4693#line 849 "rl78-decode.opc" 4694 ID(mov); W(); DR(AX); SM(SP, IMMU(1)); 4695 4696 } 4697 break; 4698 case 0xa9: 4699 { 4700 /** 1010 1001 movw %0, %e1 */ 4701 if (trace) 4702 { 4703 printf ("\033[33m%s\033[0m %02x\n", 4704 "/** 1010 1001 movw %0, %e1 */", 4705 op[0]); 4706 } 4707 SYNTAX("movw %0, %e1"); 4708#line 837 "rl78-decode.opc" 4709 ID(mov); W(); DR(AX); SM(DE, 0); 4710 4711 } 4712 break; 4713 case 0xaa: 4714 { 4715 /** 1010 1010 movw %0, %e1 */ 4716 if (trace) 4717 { 4718 printf ("\033[33m%s\033[0m %02x\n", 4719 "/** 1010 1010 movw %0, %e1 */", 4720 op[0]); 4721 } 4722 SYNTAX("movw %0, %e1"); 4723#line 840 "rl78-decode.opc" 4724 ID(mov); W(); DR(AX); SM(DE, IMMU(1)); 4725 4726 } 4727 break; 4728 case 0xab: 4729 { 4730 /** 1010 1011 movw %0, %e1 */ 4731 if (trace) 4732 { 4733 printf ("\033[33m%s\033[0m %02x\n", 4734 "/** 1010 1011 movw %0, %e1 */", 4735 op[0]); 4736 } 4737 SYNTAX("movw %0, %e1"); 4738#line 843 "rl78-decode.opc" 4739 ID(mov); W(); DR(AX); SM(HL, 0); 4740 4741 } 4742 break; 4743 case 0xac: 4744 { 4745 /** 1010 1100 movw %0, %e1 */ 4746 if (trace) 4747 { 4748 printf ("\033[33m%s\033[0m %02x\n", 4749 "/** 1010 1100 movw %0, %e1 */", 4750 op[0]); 4751 } 4752 SYNTAX("movw %0, %e1"); 4753#line 846 "rl78-decode.opc" 4754 ID(mov); W(); DR(AX); SM(HL, IMMU(1)); 4755 4756 } 4757 break; 4758 case 0xad: 4759 { 4760 /** 1010 1101 movw %0, %1 */ 4761 if (trace) 4762 { 4763 printf ("\033[33m%s\033[0m %02x\n", 4764 "/** 1010 1101 movw %0, %1 */", 4765 op[0]); 4766 } 4767 SYNTAX("movw %0, %1"); 4768#line 879 "rl78-decode.opc" 4769 ID(mov); W(); DR(AX); SM(None, SADDR); 4770 4771 } 4772 break; 4773 case 0xae: 4774 { 4775 /** 1010 1110 movw %0, %s1 */ 4776 if (trace) 4777 { 4778 printf ("\033[33m%s\033[0m %02x\n", 4779 "/** 1010 1110 movw %0, %s1 */", 4780 op[0]); 4781 } 4782 SYNTAX("movw %0, %s1"); 4783#line 882 "rl78-decode.opc" 4784 ID(mov); W(); DR(AX); SM(None, SFR); 4785 4786 } 4787 break; 4788 case 0xaf: 4789 { 4790 /** 1010 1111 movw %0, %e!1 */ 4791 if (trace) 4792 { 4793 printf ("\033[33m%s\033[0m %02x\n", 4794 "/** 1010 1111 movw %0, %e!1 */", 4795 op[0]); 4796 } 4797 SYNTAX("movw %0, %e!1"); 4798#line 833 "rl78-decode.opc" 4799 ID(mov); W(); DR(AX); SM(None, IMMU(2)); 4800 4801 4802 } 4803 break; 4804 case 0xb0: 4805 { 4806 /** 1011 0000 dec %e!0 */ 4807 if (trace) 4808 { 4809 printf ("\033[33m%s\033[0m %02x\n", 4810 "/** 1011 0000 dec %e!0 */", 4811 op[0]); 4812 } 4813 SYNTAX("dec %e!0"); 4814#line 547 "rl78-decode.opc" 4815 ID(sub); DM(None, IMMU(2)); SC(1); Fza; 4816 4817 } 4818 break; 4819 case 0xb1: 4820 case 0xb3: 4821 case 0xb5: 4822 case 0xb7: 4823 { 4824 /** 1011 0rg1 decw %0 */ 4825#line 567 "rl78-decode.opc" 4826 int rg AU = (op[0] >> 1) & 0x03; 4827 if (trace) 4828 { 4829 printf ("\033[33m%s\033[0m %02x\n", 4830 "/** 1011 0rg1 decw %0 */", 4831 op[0]); 4832 printf (" rg = 0x%x\n", rg); 4833 } 4834 SYNTAX("decw %0"); 4835#line 567 "rl78-decode.opc" 4836 ID(sub); W(); DRW(rg); SC(1); 4837 4838 } 4839 break; 4840 case 0xb2: 4841 { 4842 /** 1011 0010 decw %e!0 */ 4843 if (trace) 4844 { 4845 printf ("\033[33m%s\033[0m %02x\n", 4846 "/** 1011 0010 decw %e!0 */", 4847 op[0]); 4848 } 4849 SYNTAX("decw %e!0"); 4850#line 561 "rl78-decode.opc" 4851 ID(sub); W(); DM(None, IMMU(2)); SC(1); 4852 4853 } 4854 break; 4855 case 0xb4: 4856 { 4857 /** 1011 0100 dec %0 */ 4858 if (trace) 4859 { 4860 printf ("\033[33m%s\033[0m %02x\n", 4861 "/** 1011 0100 dec %0 */", 4862 op[0]); 4863 } 4864 SYNTAX("dec %0"); 4865#line 556 "rl78-decode.opc" 4866 ID(sub); DM(None, SADDR); SC(1); Fza; 4867 4868 /*----------------------------------------------------------------------*/ 4869 4870 } 4871 break; 4872 case 0xb6: 4873 { 4874 /** 1011 0110 decw %0 */ 4875 if (trace) 4876 { 4877 printf ("\033[33m%s\033[0m %02x\n", 4878 "/** 1011 0110 decw %0 */", 4879 op[0]); 4880 } 4881 SYNTAX("decw %0"); 4882#line 570 "rl78-decode.opc" 4883 ID(sub); W(); DM(None, SADDR); SC(1); 4884 4885 /*----------------------------------------------------------------------*/ 4886 4887 } 4888 break; 4889 case 0xb8: 4890 { 4891 /** 1011 1000 movw %0, %1 */ 4892 if (trace) 4893 { 4894 printf ("\033[33m%s\033[0m %02x\n", 4895 "/** 1011 1000 movw %0, %1 */", 4896 op[0]); 4897 } 4898 SYNTAX("movw %0, %1"); 4899#line 830 "rl78-decode.opc" 4900 ID(mov); W(); DM(SP, IMMU(1)); SR(AX); 4901 4902 } 4903 break; 4904 case 0xb9: 4905 { 4906 /** 1011 1001 movw %e0, %1 */ 4907 if (trace) 4908 { 4909 printf ("\033[33m%s\033[0m %02x\n", 4910 "/** 1011 1001 movw %e0, %1 */", 4911 op[0]); 4912 } 4913 SYNTAX("movw %e0, %1"); 4914#line 818 "rl78-decode.opc" 4915 ID(mov); W(); DM(DE, 0); SR(AX); 4916 4917 } 4918 break; 4919 case 0xba: 4920 { 4921 /** 1011 1010 movw %e0, %1 */ 4922 if (trace) 4923 { 4924 printf ("\033[33m%s\033[0m %02x\n", 4925 "/** 1011 1010 movw %e0, %1 */", 4926 op[0]); 4927 } 4928 SYNTAX("movw %e0, %1"); 4929#line 821 "rl78-decode.opc" 4930 ID(mov); W(); DM(DE, IMMU(1)); SR(AX); 4931 4932 } 4933 break; 4934 case 0xbb: 4935 { 4936 /** 1011 1011 movw %e0, %1 */ 4937 if (trace) 4938 { 4939 printf ("\033[33m%s\033[0m %02x\n", 4940 "/** 1011 1011 movw %e0, %1 */", 4941 op[0]); 4942 } 4943 SYNTAX("movw %e0, %1"); 4944#line 824 "rl78-decode.opc" 4945 ID(mov); W(); DM(HL, 0); SR(AX); 4946 4947 } 4948 break; 4949 case 0xbc: 4950 { 4951 /** 1011 1100 movw %e0, %1 */ 4952 if (trace) 4953 { 4954 printf ("\033[33m%s\033[0m %02x\n", 4955 "/** 1011 1100 movw %e0, %1 */", 4956 op[0]); 4957 } 4958 SYNTAX("movw %e0, %1"); 4959#line 827 "rl78-decode.opc" 4960 ID(mov); W(); DM(HL, IMMU(1)); SR(AX); 4961 4962 } 4963 break; 4964 case 0xbd: 4965 { 4966 /** 1011 1101 movw %0, %1 */ 4967 if (trace) 4968 { 4969 printf ("\033[33m%s\033[0m %02x\n", 4970 "/** 1011 1101 movw %0, %1 */", 4971 op[0]); 4972 } 4973 SYNTAX("movw %0, %1"); 4974#line 894 "rl78-decode.opc" 4975 ID(mov); W(); DM(None, SADDR); SR(AX); 4976 4977 } 4978 break; 4979 case 0xbe: 4980 { 4981 /** 1011 1110 movw %0, %1 */ 4982 if (trace) 4983 { 4984 printf ("\033[33m%s\033[0m %02x\n", 4985 "/** 1011 1110 movw %0, %1 */", 4986 op[0]); 4987 } 4988 SYNTAX("movw %0, %1"); 4989#line 900 "rl78-decode.opc" 4990 ID(mov); W(); DM(None, SFR); SR(AX); 4991 4992 /*----------------------------------------------------------------------*/ 4993 4994 } 4995 break; 4996 case 0xbf: 4997 { 4998 /** 1011 1111 movw %e!0, %1 */ 4999 if (trace) 5000 { 5001 printf ("\033[33m%s\033[0m %02x\n", 5002 "/** 1011 1111 movw %e!0, %1 */", 5003 op[0]); 5004 } 5005 SYNTAX("movw %e!0, %1"); 5006#line 815 "rl78-decode.opc" 5007 ID(mov); W(); DM(None, IMMU(2)); SR(AX); 5008 5009 } 5010 break; 5011 case 0xc0: 5012 case 0xc2: 5013 case 0xc4: 5014 case 0xc6: 5015 { 5016 /** 1100 0rg0 pop %0 */ 5017#line 985 "rl78-decode.opc" 5018 int rg AU = (op[0] >> 1) & 0x03; 5019 if (trace) 5020 { 5021 printf ("\033[33m%s\033[0m %02x\n", 5022 "/** 1100 0rg0 pop %0 */", 5023 op[0]); 5024 printf (" rg = 0x%x\n", rg); 5025 } 5026 SYNTAX("pop %0"); 5027#line 985 "rl78-decode.opc" 5028 ID(mov); W(); DRW(rg); SPOP(); 5029 5030 } 5031 break; 5032 case 0xc1: 5033 case 0xc3: 5034 case 0xc5: 5035 case 0xc7: 5036 { 5037 /** 1100 0rg1 push %1 */ 5038#line 993 "rl78-decode.opc" 5039 int rg AU = (op[0] >> 1) & 0x03; 5040 if (trace) 5041 { 5042 printf ("\033[33m%s\033[0m %02x\n", 5043 "/** 1100 0rg1 push %1 */", 5044 op[0]); 5045 printf (" rg = 0x%x\n", rg); 5046 } 5047 SYNTAX("push %1"); 5048#line 993 "rl78-decode.opc" 5049 ID(mov); W(); DPUSH(); SRW(rg); 5050 5051 } 5052 break; 5053 case 0xc8: 5054 { 5055 /** 1100 1000 mov %0, #%1 */ 5056 if (trace) 5057 { 5058 printf ("\033[33m%s\033[0m %02x\n", 5059 "/** 1100 1000 mov %0, #%1 */", 5060 op[0]); 5061 } 5062 SYNTAX("mov %0, #%1"); 5063#line 638 "rl78-decode.opc" 5064 ID(mov); DM(SP, IMMU(1)); SC(IMMU(1)); 5065 5066 } 5067 break; 5068 case 0xc9: 5069 { 5070 /** 1100 1001 movw %0, #%1 */ 5071 if (trace) 5072 { 5073 printf ("\033[33m%s\033[0m %02x\n", 5074 "/** 1100 1001 movw %0, #%1 */", 5075 op[0]); 5076 } 5077 SYNTAX("movw %0, #%1"); 5078#line 891 "rl78-decode.opc" 5079 ID(mov); W(); DM(None, SADDR); SC(IMMU(2)); 5080 5081 } 5082 break; 5083 case 0xca: 5084 { 5085 /** 1100 1010 mov %e0, #%1 */ 5086 if (trace) 5087 { 5088 printf ("\033[33m%s\033[0m %02x\n", 5089 "/** 1100 1010 mov %e0, #%1 */", 5090 op[0]); 5091 } 5092 SYNTAX("mov %e0, #%1"); 5093#line 617 "rl78-decode.opc" 5094 ID(mov); DM(DE, IMMU(1)); SC(IMMU(1)); 5095 5096 } 5097 break; 5098 case 0xcb: 5099 { 5100 /** 1100 1011 movw %0, #%1 */ 5101 if (trace) 5102 { 5103 printf ("\033[33m%s\033[0m %02x\n", 5104 "/** 1100 1011 movw %0, #%1 */", 5105 op[0]); 5106 } 5107 SYNTAX("movw %0, #%1"); 5108#line 897 "rl78-decode.opc" 5109 ID(mov); W(); DM(None, SFR); SC(IMMU(2)); 5110 5111 } 5112 break; 5113 case 0xcc: 5114 { 5115 /** 1100 1100 mov %e0, #%1 */ 5116 if (trace) 5117 { 5118 printf ("\033[33m%s\033[0m %02x\n", 5119 "/** 1100 1100 mov %e0, #%1 */", 5120 op[0]); 5121 } 5122 SYNTAX("mov %e0, #%1"); 5123#line 629 "rl78-decode.opc" 5124 ID(mov); DM(HL, IMMU(1)); SC(IMMU(1)); 5125 5126 } 5127 break; 5128 case 0xcd: 5129 { 5130 /** 1100 1101 mov %0, #%1 */ 5131 if (trace) 5132 { 5133 printf ("\033[33m%s\033[0m %02x\n", 5134 "/** 1100 1101 mov %0, #%1 */", 5135 op[0]); 5136 } 5137 SYNTAX("mov %0, #%1"); 5138#line 743 "rl78-decode.opc" 5139 ID(mov); DM(None, SADDR); SC(IMMU(1)); 5140 5141 } 5142 break; 5143 case 0xce: 5144 { 5145 /** 1100 1110 mov %s0, #%1 */ 5146 if (trace) 5147 { 5148 printf ("\033[33m%s\033[0m %02x\n", 5149 "/** 1100 1110 mov %s0, #%1 */", 5150 op[0]); 5151 } 5152 SYNTAX("mov %s0, #%1"); 5153#line 749 "rl78-decode.opc" 5154 op0 = SFR; 5155 op1 = IMMU(1); 5156 ID(mov); DM(None, op0); SC(op1); 5157 if (op0 == 0xffffb) 5158 switch (op1) 5159 { 5160 case 0x01: 5161 rl78->syntax = "mulhu"; ID(mulhu); 5162 break; 5163 case 0x02: 5164 rl78->syntax = "mulh"; ID(mulh); 5165 break; 5166 case 0x03: 5167 rl78->syntax = "divhu"; ID(divhu); 5168 break; 5169 case 0x04: 5170 rl78->syntax = "divwu <old-encoding>"; ID(divwu); 5171 break; 5172 case 0x05: 5173 rl78->syntax = "machu"; ID(machu); 5174 break; 5175 case 0x06: 5176 rl78->syntax = "mach"; ID(mach); 5177 break; 5178 case 0x0b: 5179 rl78->syntax = "divwu"; ID(divwu); 5180 break; 5181 } 5182 5183 } 5184 break; 5185 case 0xcf: 5186 { 5187 /** 1100 1111 mov %e!0, #%1 */ 5188 if (trace) 5189 { 5190 printf ("\033[33m%s\033[0m %02x\n", 5191 "/** 1100 1111 mov %e!0, #%1 */", 5192 op[0]); 5193 } 5194 SYNTAX("mov %e!0, #%1"); 5195#line 608 "rl78-decode.opc" 5196 ID(mov); DM(None, IMMU(2)); SC(IMMU(1)); 5197 5198 } 5199 break; 5200 case 0xd0: 5201 case 0xd1: 5202 case 0xd2: 5203 case 0xd3: 5204 { 5205 /** 1101 00rg cmp0 %0 */ 5206#line 517 "rl78-decode.opc" 5207 int rg AU = op[0] & 0x03; 5208 if (trace) 5209 { 5210 printf ("\033[33m%s\033[0m %02x\n", 5211 "/** 1101 00rg cmp0 %0 */", 5212 op[0]); 5213 printf (" rg = 0x%x\n", rg); 5214 } 5215 SYNTAX("cmp0 %0"); 5216#line 517 "rl78-decode.opc" 5217 ID(cmp); DRB(rg); SC(0); Fzac; 5218 5219 } 5220 break; 5221 case 0xd4: 5222 { 5223 /** 1101 0100 cmp0 %0 */ 5224 if (trace) 5225 { 5226 printf ("\033[33m%s\033[0m %02x\n", 5227 "/** 1101 0100 cmp0 %0 */", 5228 op[0]); 5229 } 5230 SYNTAX("cmp0 %0"); 5231#line 520 "rl78-decode.opc" 5232 ID(cmp); DM(None, SADDR); SC(0); Fzac; 5233 5234 /*----------------------------------------------------------------------*/ 5235 5236 } 5237 break; 5238 case 0xd5: 5239 { 5240 /** 1101 0101 cmp0 %e!0 */ 5241 if (trace) 5242 { 5243 printf ("\033[33m%s\033[0m %02x\n", 5244 "/** 1101 0101 cmp0 %e!0 */", 5245 op[0]); 5246 } 5247 SYNTAX("cmp0 %e!0"); 5248#line 514 "rl78-decode.opc" 5249 ID(cmp); DM(None, IMMU(2)); SC(0); Fzac; 5250 5251 } 5252 break; 5253 case 0xd6: 5254 { 5255 /** 1101 0110 mulu x */ 5256 if (trace) 5257 { 5258 printf ("\033[33m%s\033[0m %02x\n", 5259 "/** 1101 0110 mulu x */", 5260 op[0]); 5261 } 5262 SYNTAX("mulu x"); 5263#line 905 "rl78-decode.opc" 5264 ID(mulu); 5265 5266 /*----------------------------------------------------------------------*/ 5267 5268 } 5269 break; 5270 case 0xd7: 5271 { 5272 /** 1101 0111 ret */ 5273 if (trace) 5274 { 5275 printf ("\033[33m%s\033[0m %02x\n", 5276 "/** 1101 0111 ret */", 5277 op[0]); 5278 } 5279 SYNTAX("ret"); 5280#line 1001 "rl78-decode.opc" 5281 ID(ret); 5282 5283 } 5284 break; 5285 case 0xd8: 5286 { 5287 /** 1101 1000 mov %0, %1 */ 5288 if (trace) 5289 { 5290 printf ("\033[33m%s\033[0m %02x\n", 5291 "/** 1101 1000 mov %0, %1 */", 5292 op[0]); 5293 } 5294 SYNTAX("mov %0, %1"); 5295#line 710 "rl78-decode.opc" 5296 ID(mov); DR(X); SM(None, SADDR); 5297 5298 } 5299 break; 5300 case 0xd9: 5301 { 5302 /** 1101 1001 mov %0, %e!1 */ 5303 if (trace) 5304 { 5305 printf ("\033[33m%s\033[0m %02x\n", 5306 "/** 1101 1001 mov %0, %e!1 */", 5307 op[0]); 5308 } 5309 SYNTAX("mov %0, %e!1"); 5310#line 707 "rl78-decode.opc" 5311 ID(mov); DR(X); SM(None, IMMU(2)); 5312 5313 } 5314 break; 5315 case 0xda: 5316 case 0xea: 5317 case 0xfa: 5318 { 5319 /** 11ra 1010 movw %0, %1 */ 5320#line 888 "rl78-decode.opc" 5321 int ra AU = (op[0] >> 4) & 0x03; 5322 if (trace) 5323 { 5324 printf ("\033[33m%s\033[0m %02x\n", 5325 "/** 11ra 1010 movw %0, %1 */", 5326 op[0]); 5327 printf (" ra = 0x%x\n", ra); 5328 } 5329 SYNTAX("movw %0, %1"); 5330#line 888 "rl78-decode.opc" 5331 ID(mov); W(); DRW(ra); SM(None, SADDR); 5332 5333 } 5334 break; 5335 case 0xdb: 5336 case 0xeb: 5337 case 0xfb: 5338 { 5339 /** 11ra 1011 movw %0, %e!1 */ 5340#line 885 "rl78-decode.opc" 5341 int ra AU = (op[0] >> 4) & 0x03; 5342 if (trace) 5343 { 5344 printf ("\033[33m%s\033[0m %02x\n", 5345 "/** 11ra 1011 movw %0, %e!1 */", 5346 op[0]); 5347 printf (" ra = 0x%x\n", ra); 5348 } 5349 SYNTAX("movw %0, %e!1"); 5350#line 885 "rl78-decode.opc" 5351 ID(mov); W(); DRW(ra); SM(None, IMMU(2)); 5352 5353 } 5354 break; 5355 case 0xdc: 5356 { 5357 /** 1101 1100 bc $%a0 */ 5358 if (trace) 5359 { 5360 printf ("\033[33m%s\033[0m %02x\n", 5361 "/** 1101 1100 bc $%a0 */", 5362 op[0]); 5363 } 5364 SYNTAX("bc $%a0"); 5365#line 333 "rl78-decode.opc" 5366 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(C); 5367 5368 } 5369 break; 5370 case 0xdd: 5371 { 5372 /** 1101 1101 bz $%a0 */ 5373 if (trace) 5374 { 5375 printf ("\033[33m%s\033[0m %02x\n", 5376 "/** 1101 1101 bz $%a0 */", 5377 op[0]); 5378 } 5379 SYNTAX("bz $%a0"); 5380#line 345 "rl78-decode.opc" 5381 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(Z); 5382 5383 } 5384 break; 5385 case 0xde: 5386 { 5387 /** 1101 1110 bnc $%a0 */ 5388 if (trace) 5389 { 5390 printf ("\033[33m%s\033[0m %02x\n", 5391 "/** 1101 1110 bnc $%a0 */", 5392 op[0]); 5393 } 5394 SYNTAX("bnc $%a0"); 5395#line 336 "rl78-decode.opc" 5396 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NC); 5397 5398 } 5399 break; 5400 case 0xdf: 5401 { 5402 /** 1101 1111 bnz $%a0 */ 5403 if (trace) 5404 { 5405 printf ("\033[33m%s\033[0m %02x\n", 5406 "/** 1101 1111 bnz $%a0 */", 5407 op[0]); 5408 } 5409 SYNTAX("bnz $%a0"); 5410#line 348 "rl78-decode.opc" 5411 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NZ); 5412 5413 /*----------------------------------------------------------------------*/ 5414 5415 } 5416 break; 5417 case 0xe0: 5418 case 0xe1: 5419 case 0xe2: 5420 case 0xe3: 5421 { 5422 /** 1110 00rg oneb %0 */ 5423#line 923 "rl78-decode.opc" 5424 int rg AU = op[0] & 0x03; 5425 if (trace) 5426 { 5427 printf ("\033[33m%s\033[0m %02x\n", 5428 "/** 1110 00rg oneb %0 */", 5429 op[0]); 5430 printf (" rg = 0x%x\n", rg); 5431 } 5432 SYNTAX("oneb %0"); 5433#line 923 "rl78-decode.opc" 5434 ID(mov); DRB(rg); SC(1); 5435 5436 } 5437 break; 5438 case 0xe4: 5439 { 5440 /** 1110 0100 oneb %0 */ 5441 if (trace) 5442 { 5443 printf ("\033[33m%s\033[0m %02x\n", 5444 "/** 1110 0100 oneb %0 */", 5445 op[0]); 5446 } 5447 SYNTAX("oneb %0"); 5448#line 926 "rl78-decode.opc" 5449 ID(mov); DM(None, SADDR); SC(1); 5450 5451 /*----------------------------------------------------------------------*/ 5452 5453 } 5454 break; 5455 case 0xe5: 5456 { 5457 /** 1110 0101 oneb %e!0 */ 5458 if (trace) 5459 { 5460 printf ("\033[33m%s\033[0m %02x\n", 5461 "/** 1110 0101 oneb %e!0 */", 5462 op[0]); 5463 } 5464 SYNTAX("oneb %e!0"); 5465#line 920 "rl78-decode.opc" 5466 ID(mov); DM(None, IMMU(2)); SC(1); 5467 5468 } 5469 break; 5470 case 0xe6: 5471 { 5472 /** 1110 0110 onew %0 */ 5473 if (trace) 5474 { 5475 printf ("\033[33m%s\033[0m %02x\n", 5476 "/** 1110 0110 onew %0 */", 5477 op[0]); 5478 } 5479 SYNTAX("onew %0"); 5480#line 931 "rl78-decode.opc" 5481 ID(mov); DR(AX); SC(1); 5482 5483 } 5484 break; 5485 case 0xe7: 5486 { 5487 /** 1110 0111 onew %0 */ 5488 if (trace) 5489 { 5490 printf ("\033[33m%s\033[0m %02x\n", 5491 "/** 1110 0111 onew %0 */", 5492 op[0]); 5493 } 5494 SYNTAX("onew %0"); 5495#line 934 "rl78-decode.opc" 5496 ID(mov); DR(BC); SC(1); 5497 5498 /*----------------------------------------------------------------------*/ 5499 5500 } 5501 break; 5502 case 0xe8: 5503 { 5504 /** 1110 1000 mov %0, %1 */ 5505 if (trace) 5506 { 5507 printf ("\033[33m%s\033[0m %02x\n", 5508 "/** 1110 1000 mov %0, %1 */", 5509 op[0]); 5510 } 5511 SYNTAX("mov %0, %1"); 5512#line 698 "rl78-decode.opc" 5513 ID(mov); DR(B); SM(None, SADDR); 5514 5515 } 5516 break; 5517 case 0xe9: 5518 { 5519 /** 1110 1001 mov %0, %e!1 */ 5520 if (trace) 5521 { 5522 printf ("\033[33m%s\033[0m %02x\n", 5523 "/** 1110 1001 mov %0, %e!1 */", 5524 op[0]); 5525 } 5526 SYNTAX("mov %0, %e!1"); 5527#line 692 "rl78-decode.opc" 5528 ID(mov); DR(B); SM(None, IMMU(2)); 5529 5530 } 5531 break; 5532 case 0xec: 5533 { 5534 /** 1110 1100 br !%!a0 */ 5535 if (trace) 5536 { 5537 printf ("\033[33m%s\033[0m %02x\n", 5538 "/** 1110 1100 br !%!a0 */", 5539 op[0]); 5540 } 5541 SYNTAX("br !%!a0"); 5542#line 367 "rl78-decode.opc" 5543 ID(branch); DC(IMMU(3)); 5544 5545 } 5546 break; 5547 case 0xed: 5548 { 5549 /** 1110 1101 br %!a0 */ 5550 if (trace) 5551 { 5552 printf ("\033[33m%s\033[0m %02x\n", 5553 "/** 1110 1101 br %!a0 */", 5554 op[0]); 5555 } 5556 SYNTAX("br %!a0"); 5557#line 370 "rl78-decode.opc" 5558 ID(branch); DC(IMMU(2)); 5559 5560 } 5561 break; 5562 case 0xee: 5563 { 5564 /** 1110 1110 br $%!a0 */ 5565 if (trace) 5566 { 5567 printf ("\033[33m%s\033[0m %02x\n", 5568 "/** 1110 1110 br $%!a0 */", 5569 op[0]); 5570 } 5571 SYNTAX("br $%!a0"); 5572#line 373 "rl78-decode.opc" 5573 ID(branch); DC(pc+IMMS(2)+3); 5574 5575 } 5576 break; 5577 case 0xef: 5578 { 5579 /** 1110 1111 br $%a0 */ 5580 if (trace) 5581 { 5582 printf ("\033[33m%s\033[0m %02x\n", 5583 "/** 1110 1111 br $%a0 */", 5584 op[0]); 5585 } 5586 SYNTAX("br $%a0"); 5587#line 376 "rl78-decode.opc" 5588 ID(branch); DC(pc+IMMS(1)+2); 5589 5590 } 5591 break; 5592 case 0xf0: 5593 case 0xf1: 5594 case 0xf2: 5595 case 0xf3: 5596 { 5597 /** 1111 00rg clrb %0 */ 5598#line 463 "rl78-decode.opc" 5599 int rg AU = op[0] & 0x03; 5600 if (trace) 5601 { 5602 printf ("\033[33m%s\033[0m %02x\n", 5603 "/** 1111 00rg clrb %0 */", 5604 op[0]); 5605 printf (" rg = 0x%x\n", rg); 5606 } 5607 SYNTAX("clrb %0"); 5608#line 463 "rl78-decode.opc" 5609 ID(mov); DRB(rg); SC(0); 5610 5611 } 5612 break; 5613 case 0xf4: 5614 { 5615 /** 1111 0100 clrb %0 */ 5616 if (trace) 5617 { 5618 printf ("\033[33m%s\033[0m %02x\n", 5619 "/** 1111 0100 clrb %0 */", 5620 op[0]); 5621 } 5622 SYNTAX("clrb %0"); 5623#line 466 "rl78-decode.opc" 5624 ID(mov); DM(None, SADDR); SC(0); 5625 5626 /*----------------------------------------------------------------------*/ 5627 5628 } 5629 break; 5630 case 0xf5: 5631 { 5632 /** 1111 0101 clrb %e!0 */ 5633 if (trace) 5634 { 5635 printf ("\033[33m%s\033[0m %02x\n", 5636 "/** 1111 0101 clrb %e!0 */", 5637 op[0]); 5638 } 5639 SYNTAX("clrb %e!0"); 5640#line 460 "rl78-decode.opc" 5641 ID(mov); DM(None, IMMU(2)); SC(0); 5642 5643 } 5644 break; 5645 case 0xf6: 5646 { 5647 /** 1111 0110 clrw %0 */ 5648 if (trace) 5649 { 5650 printf ("\033[33m%s\033[0m %02x\n", 5651 "/** 1111 0110 clrw %0 */", 5652 op[0]); 5653 } 5654 SYNTAX("clrw %0"); 5655#line 471 "rl78-decode.opc" 5656 ID(mov); DR(AX); SC(0); 5657 5658 } 5659 break; 5660 case 0xf7: 5661 { 5662 /** 1111 0111 clrw %0 */ 5663 if (trace) 5664 { 5665 printf ("\033[33m%s\033[0m %02x\n", 5666 "/** 1111 0111 clrw %0 */", 5667 op[0]); 5668 } 5669 SYNTAX("clrw %0"); 5670#line 474 "rl78-decode.opc" 5671 ID(mov); DR(BC); SC(0); 5672 5673 /*----------------------------------------------------------------------*/ 5674 5675 } 5676 break; 5677 case 0xf8: 5678 { 5679 /** 1111 1000 mov %0, %1 */ 5680 if (trace) 5681 { 5682 printf ("\033[33m%s\033[0m %02x\n", 5683 "/** 1111 1000 mov %0, %1 */", 5684 op[0]); 5685 } 5686 SYNTAX("mov %0, %1"); 5687#line 704 "rl78-decode.opc" 5688 ID(mov); DR(C); SM(None, SADDR); 5689 5690 } 5691 break; 5692 case 0xf9: 5693 { 5694 /** 1111 1001 mov %0, %e!1 */ 5695 if (trace) 5696 { 5697 printf ("\033[33m%s\033[0m %02x\n", 5698 "/** 1111 1001 mov %0, %e!1 */", 5699 op[0]); 5700 } 5701 SYNTAX("mov %0, %e!1"); 5702#line 701 "rl78-decode.opc" 5703 ID(mov); DR(C); SM(None, IMMU(2)); 5704 5705 } 5706 break; 5707 case 0xfc: 5708 { 5709 /** 1111 1100 call !%!a0 */ 5710 if (trace) 5711 { 5712 printf ("\033[33m%s\033[0m %02x\n", 5713 "/** 1111 1100 call !%!a0 */", 5714 op[0]); 5715 } 5716 SYNTAX("call !%!a0"); 5717#line 420 "rl78-decode.opc" 5718 ID(call); DC(IMMU(3)); 5719 5720 } 5721 break; 5722 case 0xfd: 5723 { 5724 /** 1111 1101 call %!a0 */ 5725 if (trace) 5726 { 5727 printf ("\033[33m%s\033[0m %02x\n", 5728 "/** 1111 1101 call %!a0 */", 5729 op[0]); 5730 } 5731 SYNTAX("call %!a0"); 5732#line 423 "rl78-decode.opc" 5733 ID(call); DC(IMMU(2)); 5734 5735 } 5736 break; 5737 case 0xfe: 5738 { 5739 /** 1111 1110 call $%!a0 */ 5740 if (trace) 5741 { 5742 printf ("\033[33m%s\033[0m %02x\n", 5743 "/** 1111 1110 call $%!a0 */", 5744 op[0]); 5745 } 5746 SYNTAX("call $%!a0"); 5747#line 426 "rl78-decode.opc" 5748 ID(call); DC(pc+IMMS(2)+3); 5749 5750 } 5751 break; 5752 case 0xff: 5753 { 5754 /** 1111 1111 brk1 */ 5755 if (trace) 5756 { 5757 printf ("\033[33m%s\033[0m %02x\n", 5758 "/** 1111 1111 brk1 */", 5759 op[0]); 5760 } 5761 SYNTAX("brk1"); 5762#line 384 "rl78-decode.opc" 5763 ID(break); 5764 5765 } 5766 break; 5767 } 5768#line 1289 "rl78-decode.opc" 5769 5770 return rl78->n_bytes; 5771} 5772