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