projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
x86: eliminate ImmExt abuse
[deliverable/binutils-gdb.git] / opcodes / rl78-decode.opc
CommitLineData
99c513f6 1/* -*- c -*- */
82704155 2/* Copyright (C) 2012-2019 Free Software Foundation, Inc.
5bf135a7
NC		 3 Contributed by Red Hat.
4 Written by DJ Delorie.
5
6 This file is part of the GNU opcodes library.
7
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
12
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
df7b86aa 23#include "sysdep.h"
99c513f6
DD		 24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
030157d8 27#include "bfd.h"
a6743a54 28#include "opintl.h"
99c513f6
DD		 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
63323b5b
NC		 54
55#define OP_BUF_LEN 20
56#define GETBYTE() (ld->rl78->n_bytes < (OP_BUF_LEN - 1) ? ld->op [ld->rl78->n_bytes++] = ld->getbyte (ld->ptr): 0)
99c513f6
DD		 57#define B ((unsigned long) GETBYTE())
58
59#define SYNTAX(x) rl78->syntax = x
60
61#define UNSUPPORTED() \
62 rl78->syntax = "*unknown*"
63
64#define RB(x) ((x)+RL78_Reg_X)
65#define RW(x) ((x)+RL78_Reg_AX)
66
67#define Fz rl78->flags = RL78_PSW_Z
68#define Fza rl78->flags = RL78_PSW_Z | RL78_PSW_AC
69#define Fzc rl78->flags = RL78_PSW_Z | RL78_PSW_CY
70#define Fzac rl78->flags = RL78_PSW_Z | RL78_PSW_AC | RL78_PSW_CY
71#define Fa rl78->flags = RL78_PSW_AC
72#define Fc rl78->flags = RL78_PSW_CY
73#define Fac rl78->flags = RL78_PSW_AC | RL78_PSW_CY
74
75#define IMMU(bytes) immediate (bytes, 0, ld)
76#define IMMS(bytes) immediate (bytes, 1, ld)
77
78static int
79immediate (int bytes, int sign_extend, LocalData * ld)
80{
81 unsigned long i = 0;
82
83 switch (bytes)
84 {
85 case 1:
86 i |= B;
87 if (sign_extend && (i & 0x80))
88 i -= 0x100;
89 break;
90 case 2:
91 i |= B;
92 i |= B << 8;
93 if (sign_extend && (i & 0x8000))
94 i -= 0x10000;
95 break;
96 case 3:
97 i |= B;
98 i |= B << 8;
99 i |= B << 16;
100 if (sign_extend && (i & 0x800000))
101 i -= 0x1000000;
102 break;
103 default:
a6743a54
AM		 104 opcodes_error_handler
105 /* xgettext:c-format */
106 (_("internal error: immediate() called with invalid byte count %d"),
107 bytes);
99c513f6
DD		 108 abort();
109 }
110 return i;
111}
112
113#define DC(c) OP (0, RL78_Operand_Immediate, 0, c)
114#define DR(r) OP (0, RL78_Operand_Register, RL78_Reg_##r, 0)
115#define DRB(r) OP (0, RL78_Operand_Register, RB(r), 0)
116#define DRW(r) OP (0, RL78_Operand_Register, RW(r), 0)
117#define DM(r,a) OP (0, RL78_Operand_Indirect, RL78_Reg_##r, a)
118#define DM2(r1,r2,a) OPX (0, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
119#define DE() rl78->op[0].use_es = 1
120#define DB(b) set_bit (rl78->op, b)
121#define DCY() DR(PSW); DB(0)
122#define DPUSH() OP (0, RL78_Operand_PreDec, RL78_Reg_SP, 0);
123
124#define SC(c) OP (1, RL78_Operand_Immediate, 0, c)
125#define SR(r) OP (1, RL78_Operand_Register, RL78_Reg_##r, 0)
126#define SRB(r) OP (1, RL78_Operand_Register, RB(r), 0)
127#define SRW(r) OP (1, RL78_Operand_Register, RW(r), 0)
128#define SM(r,a) OP (1, RL78_Operand_Indirect, RL78_Reg_##r, a)
129#define SM2(r1,r2,a) OPX (1, RL78_Operand_Indirect, RL78_Reg_##r1, RL78_Reg_##r2, a)
130#define SE() rl78->op[1].use_es = 1
131#define SB(b) set_bit (rl78->op+1, b)
132#define SCY() SR(PSW); SB(0)
133#define COND(c) rl78->op[1].condition = RL78_Condition_##c
134#define SPOP() OP (1, RL78_Operand_PostInc, RL78_Reg_SP, 0);
135
136static void
137set_bit (RL78_Opcode_Operand *op, int bit)
138{
139 op->bit_number = bit;
140 switch (op->type) {
141 case RL78_Operand_Register:
142 op->type = RL78_Operand_Bit;
143 break;
144 case RL78_Operand_Indirect:
145 op->type = RL78_Operand_BitIndirect;
146 break;
147 default:
148 break;
149 }
150}
151
152static int
153saddr (int x)
154{
155 if (x < 0x20)
156 return 0xfff00 + x;
157 return 0xffe00 + x;
158}
159
160static int
161sfr (int x)
162{
163 return 0xfff00 + x;
164}
165
166#define SADDR saddr (IMMU (1))
167#define SFR sfr (IMMU (1))
168
169int
170rl78_decode_opcode (unsigned long pc AU,
171 RL78_Opcode_Decoded * rl78,
172 int (* getbyte)(void *),
0952813b
DD		 173 void * ptr,
174 RL78_Dis_Isa isa)
99c513f6
DD		 175{
176 LocalData lds, * ld = &lds;
63323b5b 177 unsigned char op_buf[OP_BUF_LEN] = {0};
99c513f6
DD		 178 unsigned char *op = op_buf;
179 int op0, op1;
180
181 lds.rl78 = rl78;
182 lds.getbyte = getbyte;
183 lds.ptr = ptr;
184 lds.op = op;
185
186 memset (rl78, 0, sizeof (*rl78));
187
188 start_again:
189
190/* Byte registers, not including A. */
191/** VARY rba 000 010 011 100 101 110 111 */
192/* Word registers, not including AX. */
193/** VARY ra 01 10 11 */
194
195/*----------------------------------------------------------------------*/
196/* ES: prefix */
197
198/** 0001 0001 es: */
199 DE(); SE();
200 op ++;
201 pc ++;
202 goto start_again;
203
204/*----------------------------------------------------------------------*/
205
3d557b4c 206/** 0000 1111 add %0, %e!1 */
99c513f6
DD		 207 ID(add); DR(A); SM(None, IMMU(2)); Fzac;
208
3d557b4c 209/** 0000 1101 add %0, %e1 */
99c513f6
DD		 210 ID(add); DR(A); SM(HL, 0); Fzac;
211
3d557b4c 212/** 0110 0001 1000 000 add %0, %e1 */
99c513f6
DD		 213 ID(add); DR(A); SM2(HL, B, 0); Fzac;
214
90092e73 215/** 0000 1110 add %0, %ea1 */
99c513f6 216 ID(add); DR(A); SM(HL, IMMU(1)); Fzac;
43e65147 217
3d557b4c 218/** 0110 0001 1000 0010 add %0, %e1 */
99c513f6
DD		 219 ID(add); DR(A); SM2(HL, C, 0); Fzac;
220
221/** 0000 1100 add %0, #%1 */
222 ID(add); DR(A); SC(IMMU(1)); Fzac;
223
224/** 0110 0001 0000 1rba add %0, %1 */
225 ID(add); DR(A); SRB(rba); Fzac;
226
227/** 0000 1011 add %0, %1 */
228 ID(add); DR(A); SM(None, SADDR); Fzac;
229
230/** 0110 0001 0000 0reg add %0, %1 */
231 ID(add); DRB(reg); SR(A); Fzac;
232
233/** 0000 1010 add %0, #%1 */
234 ID(add); DM(None, SADDR); SC(IMMU(1)); Fzac;
235
236/*----------------------------------------------------------------------*/
237
3d557b4c 238/** 0001 1111 addc %0, %e!1 */
99c513f6
DD		 239 ID(addc); DR(A); SM(None, IMMU(2)); Fzac;
240
3d557b4c 241/** 0001 1101 addc %0, %e1 */
99c513f6
DD		 242 ID(addc); DR(A); SM(HL, 0); Fzac;
243
3d557b4c 244/** 0110 0001 1001 0000 addc %0, %e1 */
99c513f6
DD		 245 ID(addc); DR(A); SM2(HL, B, 0); Fzac;
246
3d557b4c 247/** 0110 0001 1001 0010 addc %0, %e1 */
99c513f6
DD		 248 ID(addc); DR(A); SM2(HL, C, 0); Fzac;
249
90092e73 250/** 0001 1110 addc %0, %ea1 */
99c513f6
DD		 251 ID(addc); DR(A); SM(HL, IMMU(1)); Fzac;
252
253/** 0001 1100 addc %0, #%1 */
254 ID(addc); DR(A); SC(IMMU(1)); Fzac;
255
256/** 0110 0001 0001 1rba addc %0, %1 */
257 ID(addc); DR(A); SRB(rba); Fzac;
258
259/** 0110 0001 0001 0reg addc %0, %1 */
260 ID(addc); DRB(reg); SR(A); Fzac;
261
262/** 0001 1011 addc %0, %1 */
263 ID(addc); DR(A); SM(None, SADDR); Fzac;
264
265/** 0001 1010 addc %0, #%1 */
266 ID(addc); DM(None, SADDR); SC(IMMU(1)); Fzac;
267
268/*----------------------------------------------------------------------*/
269
3d557b4c 270/** 0000 0010 addw %0, %e!1 */
99c513f6
DD		 271 ID(add); W(); DR(AX); SM(None, IMMU(2)); Fzac;
272
90092e73 273/** 0110 0001 0000 1001 addw %0, %ea1 */
99c513f6
DD		 274 ID(add); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
275
276/** 0000 0100 addw %0, #%1 */
277 ID(add); W(); DR(AX); SC(IMMU(2)); Fzac;
278
279/** 0000 0rw1 addw %0, %1 */
280 ID(add); W(); DR(AX); SRW(rw); Fzac;
281
282/** 0000 0110 addw %0, %1 */
283 ID(add); W(); DR(AX); SM(None, SADDR); Fzac;
284
285/** 0001 0000 addw %0, #%1 */
286 ID(add); W(); DR(SP); SC(IMMU(1)); Fzac;
287
288/*----------------------------------------------------------------------*/
289
3d557b4c 290/** 0101 1111 and %0, %e!1 */
99c513f6
DD		 291 ID(and); DR(A); SM(None, IMMU(2)); Fz;
292
3d557b4c 293/** 0101 1101 and %0, %e1 */
99c513f6
DD		 294 ID(and); DR(A); SM(HL, 0); Fz;
295
3d557b4c 296/** 0110 0001 1101 0000 and %0, %e1 */
99c513f6
DD		 297 ID(and); DR(A); SM2(HL, B, 0); Fz;
298
90092e73 299/** 0101 1110 and %0, %ea1 */
99c513f6
DD		 300 ID(and); DR(A); SM(HL, IMMU(1)); Fz;
301
3d557b4c 302/** 0110 0001 1101 0010 and %0, %e1 */
99c513f6
DD		 303 ID(and); DR(A); SM2(HL, C, 0); Fz;
304
305/** 0101 1100 and %0, #%1 */
306 ID(and); DR(A); SC(IMMU(1)); Fz;
307
308/** 0110 0001 0101 1rba and %0, %1 */
309 ID(and); DR(A); SRB(rba); Fz;
310
311/** 0110 0001 0101 0reg and %0, %1 */
312 ID(and); DRB(reg); SR(A); Fz;
313
314/** 0101 1011 and %0, %1 */
315 ID(and); DR(A); SM(None, SADDR); Fz;
316
317/** 0101 1010 and %0, #%1 */
318 ID(and); DM(None, SADDR); SC(IMMU(1)); Fz;
319
320/*----------------------------------------------------------------------*/
321
3d557b4c 322/** 0111 0001 1bit 0101 and1 cy, %e1 */
99c513f6
DD		 323 ID(and); DCY(); SM(HL, 0); SB(bit);
324
325/** 0111 0001 1bit 1101 and1 cy, %1 */
326 ID(and); DCY(); SR(A); SB(bit);
327
328/** 0111 0001 0bit 1101 and1 cy, %s1 */
329 ID(and); DCY(); SM(None, SFR); SB(bit);
330
331/** 0111 0001 0bit 0101 and1 cy, %s1 */
332 ID(and); DCY(); SM(None, SADDR); SB(bit);
333
334/*----------------------------------------------------------------------*/
335
336/* Note that the branch insns need to be listed before the shift
337 ones, as "shift count of zero" means "branch insn" */
338
339/** 1101 1100 bc $%a0 */
340 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(C);
341
342/** 1101 1110 bnc $%a0 */
343 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NC);
344
345/** 0110 0001 1100 0011 bh $%a0 */
346 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(H);
347
348/** 0110 0001 1101 0011 bnh $%a0 */
349 ID(branch_cond); DC(pc+IMMS(1)+3); SR(None); COND(NH);
350
351/** 1101 1101 bz $%a0 */
352 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(Z);
353
354/** 1101 1111 bnz $%a0 */
355 ID(branch_cond); DC(pc+IMMS(1)+2); SR(None); COND(NZ);
356
357/*----------------------------------------------------------------------*/
358
3d557b4c 359/** 0011 0001 1bit 0101 bf %e1, $%a0 */
99c513f6
DD		 360 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(F);
361
362/** 0011 0001 0bit 0101 bf %1, $%a0 */
363 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(F);
364
365/** 0011 0001 1bit 0100 bf %s1, $%a0 */
366 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
367
368/** 0011 0001 0bit 0100 bf %s1, $%a0 */
369 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(F);
370
371/*----------------------------------------------------------------------*/
372
373/** 1110 1100 br !%!a0 */
374 ID(branch); DC(IMMU(3));
375
376/** 1110 1101 br %!a0 */
377 ID(branch); DC(IMMU(2));
378
379/** 1110 1110 br $%!a0 */
380 ID(branch); DC(pc+IMMS(2)+3);
381
382/** 1110 1111 br $%a0 */
383 ID(branch); DC(pc+IMMS(1)+2);
384
385/** 0110 0001 1100 1011 br ax */
386 ID(branch); DR(AX);
387
388/*----------------------------------------------------------------------*/
389
390/** 1111 1111 brk1 */
391 ID(break);
392
393/** 0110 0001 1100 1100 brk */
394 ID(break);
395
396/*----------------------------------------------------------------------*/
397
3d557b4c 398/** 0011 0001 1bit 0011 bt %e1, $%a0 */
99c513f6
DD		 399 ID(branch_cond); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
400
401/** 0011 0001 0bit 0011 bt %1, $%a0 */
402 ID(branch_cond); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
403
404/** 0011 0001 1bit 0010 bt %s1, $%a0 */
405 ID(branch_cond); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
406
407/** 0011 0001 0bit 0010 bt %s1, $%a0 */
408 ID(branch_cond); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
409
410/*----------------------------------------------------------------------*/
411
3d557b4c 412/** 0011 0001 1bit 0001 btclr %e1, $%a0 */
99c513f6
DD		 413 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SM(HL,0); SB(bit); COND(T);
414
415/** 0011 0001 0bit 0001 btclr %1, $%a0 */
416 ID(branch_cond_clear); DC(pc+IMMS(1)+3); SR(A); SB(bit); COND(T);
417
418/** 0011 0001 1bit 0000 btclr %s1, $%a0 */
419 ID(branch_cond_clear); SM(None, SFR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
420
421/** 0011 0001 0bit 0000 btclr %s1, $%a0 */
422 ID(branch_cond_clear); SM(None, SADDR); SB(bit); DC(pc+IMMS(1)+4); COND(T);
423
424/*----------------------------------------------------------------------*/
425
426/** 1111 1100 call !%!a0 */
427 ID(call); DC(IMMU(3));
428
429/** 1111 1101 call %!a0 */
430 ID(call); DC(IMMU(2));
431
432/** 1111 1110 call $%!a0 */
433 ID(call); DC(pc+IMMS(2)+3);
434
435/** 0110 0001 11rg 1010 call %0 */
436 ID(call); DRW(rg);
437
438/** 0110 0001 1nnn 01mm callt [%x0] */
439 ID(call); DM(None, 0x80 + mm*16 + nnn*2);
440
441/*----------------------------------------------------------------------*/
442
3d557b4c 443/** 0111 0001 0bit 1000 clr1 %e!0 */
99c513f6
DD		 444 ID(mov); DM(None, IMMU(2)); DB(bit); SC(0);
445
3d557b4c 446/** 0111 0001 1bit 0011 clr1 %e0 */
99c513f6
DD		 447 ID(mov); DM(HL, 0); DB(bit); SC(0);
448
449/** 0111 0001 1bit 1011 clr1 %0 */
450 ID(mov); DR(A); DB(bit); SC(0);
451
452/** 0111 0001 1000 1000 clr1 cy */
453 ID(mov); DCY(); SC(0);
454
455/** 0111 0001 0bit 1011 clr1 %s0 */
456 op0 = SFR;
457 ID(mov); DM(None, op0); DB(bit); SC(0);
458 if (op0 == RL78_SFR_PSW && bit == 7)
459 rl78->syntax = "di";
460
461/** 0111 0001 0bit 0011 clr1 %0 */
462 ID(mov); DM(None, SADDR); DB(bit); SC(0);
463
464/*----------------------------------------------------------------------*/
465
3d557b4c 466/** 1111 0101 clrb %e!0 */
99c513f6
DD		 467 ID(mov); DM(None, IMMU(2)); SC(0);
468
469/** 1111 00rg clrb %0 */
470 ID(mov); DRB(rg); SC(0);
471
472/** 1111 0100 clrb %0 */
473 ID(mov); DM(None, SADDR); SC(0);
474
475/*----------------------------------------------------------------------*/
476
477/** 1111 0110 clrw %0 */
478 ID(mov); DR(AX); SC(0);
479
480/** 1111 0111 clrw %0 */
481 ID(mov); DR(BC); SC(0);
482
483/*----------------------------------------------------------------------*/
484
3d557b4c 485/** 0100 0000 cmp %e!0, #%1 */
99c513f6
DD		 486 ID(cmp); DM(None, IMMU(2)); SC(IMMU(1)); Fzac;
487
488/** 0100 1010 cmp %0, #%1 */
489 ID(cmp); DM(None, SADDR); SC(IMMU(1)); Fzac;
490
3d557b4c 491/** 0100 1111 cmp %0, %e!1 */
99c513f6
DD		 492 ID(cmp); DR(A); SM(None, IMMU(2)); Fzac;
493
3d557b4c 494/** 0100 1101 cmp %0, %e1 */
99c513f6
DD		 495 ID(cmp); DR(A); SM(HL, 0); Fzac;
496
3d557b4c 497/** 0110 0001 1100 0000 cmp %0, %e1 */
99c513f6
DD		 498 ID(cmp); DR(A); SM2(HL, B, 0); Fzac;
499
3d557b4c 500/** 0110 0001 1100 0010 cmp %0, %e1 */
99c513f6
DD		 501 ID(cmp); DR(A); SM2(HL, C, 0); Fzac;
502
90092e73 503/** 0100 1110 cmp %0, %ea1 */
99c513f6
DD		 504 ID(cmp); DR(A); SM(HL, IMMU(1)); Fzac;
505
506/** 0100 1100 cmp %0, #%1 */
507 ID(cmp); DR(A); SC(IMMU(1)); Fzac;
508
509/** 0110 0001 0100 1rba cmp %0, %1 */
510 ID(cmp); DR(A); SRB(rba); Fzac;
511
512/** 0110 0001 0100 0reg cmp %0, %1 */
513 ID(cmp); DRB(reg); SR(A); Fzac;
514
515/** 0100 1011 cmp %0, %1 */
516 ID(cmp); DR(A); SM(None, SADDR); Fzac;
517
518/*----------------------------------------------------------------------*/
519
3d557b4c 520/** 1101 0101 cmp0 %e!0 */
99c513f6
DD		 521 ID(cmp); DM(None, IMMU(2)); SC(0); Fzac;
522
523/** 1101 00rg cmp0 %0 */
524 ID(cmp); DRB(rg); SC(0); Fzac;
525
526/** 1101 0100 cmp0 %0 */
527 ID(cmp); DM(None, SADDR); SC(0); Fzac;
528
529/*----------------------------------------------------------------------*/
530
90092e73 531/** 0110 0001 1101 1110 cmps %0, %ea1 */
99c513f6
DD		 532 ID(cmp); DR(X); SM(HL, IMMU(1)); Fzac;
533
534/*----------------------------------------------------------------------*/
535
3d557b4c 536/** 0100 0010 cmpw %0, %e!1 */
99c513f6
DD		 537 ID(cmp); W(); DR(AX); SM(None, IMMU(2)); Fzac;
538
90092e73 539/** 0110 0001 0100 1001 cmpw %0, %ea1 */
99c513f6
DD		 540 ID(cmp); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
541
542/** 0100 0100 cmpw %0, #%1 */
543 ID(cmp); W(); DR(AX); SC(IMMU(2)); Fzac;
544
545/** 0100 0ra1 cmpw %0, %1 */
546 ID(cmp); W(); DR(AX); SRW(ra); Fzac;
547
548/** 0100 0110 cmpw %0, %1 */
549 ID(cmp); W(); DR(AX); SM(None, SADDR); Fzac;
550
551/*----------------------------------------------------------------------*/
552
3d557b4c 553/** 1011 0000 dec %e!0 */
99c513f6
DD		 554 ID(sub); DM(None, IMMU(2)); SC(1); Fza;
555
90092e73 556/** 0110 0001 0110 1001 dec %ea0 */
99c513f6
DD		 557 ID(sub); DM(HL, IMMU(1)); SC(1); Fza;
558
559/** 1001 0reg dec %0 */
560 ID(sub); DRB(reg); SC(1); Fza;
561
562/** 1011 0100 dec %0 */
563 ID(sub); DM(None, SADDR); SC(1); Fza;
564
565/*----------------------------------------------------------------------*/
566
3d557b4c 567/** 1011 0010 decw %e!0 */
99c513f6
DD		 568 ID(sub); W(); DM(None, IMMU(2)); SC(1);
569
90092e73 570/** 0110 0001 1000 1001 decw %ea0 */
99c513f6
DD		 571 ID(sub); W(); DM(HL, IMMU(1)); SC(1);
572
573/** 1011 0rg1 decw %0 */
574 ID(sub); W(); DRW(rg); SC(1);
575
576/** 1011 0110 decw %0 */
577 ID(sub); W(); DM(None, SADDR); SC(1);
578
579/*----------------------------------------------------------------------*/
580
581/** 0110 0001 1110 1101 halt */
582 ID(halt);
583
584/*----------------------------------------------------------------------*/
585
3d557b4c 586/** 1010 0000 inc %e!0 */
99c513f6
DD		 587 ID(add); DM(None, IMMU(2)); SC(1); Fza;
588
90092e73 589/** 0110 0001 0101 1001 inc %ea0 */
99c513f6
DD		 590 ID(add); DM(HL, IMMU(1)); SC(1); Fza;
591
592/** 1000 0reg inc %0 */
593 ID(add); DRB(reg); SC(1); Fza;
594
595/** 1010 0100 inc %0 */
596 ID(add); DM(None, SADDR); SC(1); Fza;
597
598/*----------------------------------------------------------------------*/
599
3d557b4c 600/** 1010 0010 incw %e!0 */
99c513f6
DD		 601 ID(add); W(); DM(None, IMMU(2)); SC(1);
602
90092e73 603/** 0110 0001 0111 1001 incw %ea0 */
99c513f6
DD		 604 ID(add); W(); DM(HL, IMMU(1)); SC(1);
605
606/** 1010 0rg1 incw %0 */
607 ID(add); W(); DRW(rg); SC(1);
608
609/** 1010 0110 incw %0 */
610 ID(add); W(); DM(None, SADDR); SC(1);
611
612/*----------------------------------------------------------------------*/
613
3d557b4c 614/** 1100 1111 mov %e!0, #%1 */
99c513f6
DD		 615 ID(mov); DM(None, IMMU(2)); SC(IMMU(1));
616
3d557b4c 617/** 1001 1111 mov %e!0, %1 */
99c513f6
DD		 618 ID(mov); DM(None, IMMU(2)); SR(A);
619
fd63f640 620/** 1001 1001 mov %e0, %1 */
99c513f6
DD		 621 ID(mov); DM(DE, 0); SR(A);
622
c2f28758 623/** 1100 1010 mov %ea0, #%1 */
99c513f6
DD		 624 ID(mov); DM(DE, IMMU(1)); SC(IMMU(1));
625
c2f28758 626/** 1001 1010 mov %ea0, %1 */
99c513f6
DD		 627 ID(mov); DM(DE, IMMU(1)); SR(A);
628
fd63f640 629/** 1001 1011 mov %e0, %1 */
99c513f6
DD		 630 ID(mov); DM(HL, 0); SR(A);
631
3d557b4c 632/** 0110 0001 1101 1001 mov %e0, %1 */
99c513f6
DD		 633 ID(mov); DM2(HL, B, 0); SR(A);
634
90092e73 635/** 1100 1100 mov %ea0, #%1 */
99c513f6
DD		 636 ID(mov); DM(HL, IMMU(1)); SC(IMMU(1));
637
90092e73 638/** 1001 1100 mov %ea0, %1 */
99c513f6
DD		 639 ID(mov); DM(HL, IMMU(1)); SR(A);
640
3d557b4c 641/** 0110 0001 1111 1001 mov %e0, %1 */
99c513f6
DD		 642 ID(mov); DM2(HL, C, 0); SR(A);
643
02f12cd4 644/** 1100 1000 mov %a0, #%1 */
99c513f6
DD		 645 ID(mov); DM(SP, IMMU(1)); SC(IMMU(1));
646
02f12cd4 647/** 1001 1000 mov %a0, %1 */
99c513f6
DD		 648 ID(mov); DM(SP, IMMU(1)); SR(A);
649
3d557b4c 650/** 1000 1111 mov %0, %e!1 */
99c513f6
DD		 651 ID(mov); DR(A); SM(None, IMMU(2));
652
3d557b4c 653/** 1000 1001 mov %0, %e1 */
99c513f6
DD		 654 ID(mov); DR(A); SM(DE, 0);
655
c2f28758 656/** 1000 1010 mov %0, %ea1 */
99c513f6
DD		 657 ID(mov); DR(A); SM(DE, IMMU(1));
658
3d557b4c 659/** 1000 1011 mov %0, %e1 */
99c513f6
DD		 660 ID(mov); DR(A); SM(HL, 0);
661
90092e73 662/** 1000 1100 mov %0, %ea1 */
99c513f6
DD		 663 ID(mov); DR(A); SM(HL, IMMU(1));
664
3d557b4c 665/** 0110 0001 1100 1001 mov %0, %e1 */
99c513f6
DD		 666 ID(mov); DR(A); SM2(HL, B, 0);
667
3d557b4c 668/** 0110 0001 1110 1001 mov %0, %e1 */
99c513f6
DD		 669 ID(mov); DR(A); SM2(HL, C, 0);
670
02f12cd4 671/** 1000 1000 mov %0, %ea1 */
99c513f6
DD		 672 ID(mov); DR(A); SM(SP, IMMU(1));
673
674/** 0101 0reg mov %0, #%1 */
675 ID(mov); DRB(reg); SC(IMMU(1));
676
677/** 0110 0rba mov %0, %1 */
678 ID(mov); DR(A); SRB(rba);
679
680/** 1000 1110 1111 1101 mov %0, %1 */
681 ID(mov); DR(A); SR(ES);
682
3d557b4c 683/** 0000 1001 mov %0, %e1 */
99c513f6
DD		 684 ID(mov); DR(A); SM(B, IMMU(2));
685
3d557b4c 686/** 0100 1001 mov %0, %e1 */
99c513f6
DD		 687 ID(mov); DR(A); SM(BC, IMMU(2));
688
3d557b4c 689/** 0010 1001 mov %0, %e1 */
99c513f6
DD		 690 ID(mov); DR(A); SM(C, IMMU(2));
691
692/** 1000 1110 mov %0, %s1 */
693 ID(mov); DR(A); SM(None, SFR);
694
695/** 1000 1101 mov %0, %1 */
696 ID(mov); DR(A); SM(None, SADDR);
697
3d557b4c 698/** 1110 1001 mov %0, %e!1 */
99c513f6
DD		 699 ID(mov); DR(B); SM(None, IMMU(2));
700
701/** 0111 0rba mov %0, %1 */
702 ID(mov); DRB(rba); SR(A);
703
704/** 1110 1000 mov %0, %1 */
705 ID(mov); DR(B); SM(None, SADDR);
706
3d557b4c 707/** 1111 1001 mov %0, %e!1 */
99c513f6
DD		 708 ID(mov); DR(C); SM(None, IMMU(2));
709
710/** 1111 1000 mov %0, %1 */
711 ID(mov); DR(C); SM(None, SADDR);
712
3d557b4c 713/** 1101 1001 mov %0, %e!1 */
99c513f6
DD		 714 ID(mov); DR(X); SM(None, IMMU(2));
715
716/** 1101 1000 mov %0, %1 */
717 ID(mov); DR(X); SM(None, SADDR);
718
719/** 1001 1110 1111 1100 mov %0, %1 */
720 ID(mov); DR(CS); SR(A);
721
722/** 0100 0001 mov %0, #%1 */
43e65147 723 ID(mov); DR(ES); SC(IMMU(1));
99c513f6
DD		 724
725/** 1001 1110 1111 1101 mov %0, %1 */
43e65147 726 ID(mov); DR(ES); SR(A);
99c513f6
DD		 727
728/** 0110 0001 1011 1000 mov %0, %1 */
43e65147 729 ID(mov); DR(ES); SM(None, SADDR);
99c513f6 730
3d557b4c 731/** 0001 1001 mov %e0, #%1 */
43e65147 732 ID(mov); DM(B, IMMU(2)); SC(IMMU(1));
99c513f6 733
3d557b4c 734/** 0001 1000 mov %e0, %1 */
43e65147 735 ID(mov); DM(B, IMMU(2)); SR(A);
99c513f6 736
3d557b4c 737/** 0011 1001 mov %e0, #%1 */
43e65147 738 ID(mov); DM(BC, IMMU(2)); SC(IMMU(1));
99c513f6 739
3d557b4c 740/** 0100 1000 mov %e0, %1 */
43e65147 741 ID(mov); DM(BC, IMMU(2)); SR(A);
99c513f6 742
3d557b4c 743/** 0011 1000 mov %e0, #%1 */
43e65147 744 ID(mov); DM(C, IMMU(2)); SC(IMMU(1));
99c513f6 745
3d557b4c 746/** 0010 1000 mov %e0, %1 */
99c513f6
DD		 747 ID(mov); DM(C, IMMU(2)); SR(A);
748
749/** 1100 1101 mov %0, #%1 */
750 ID(mov); DM(None, SADDR); SC(IMMU(1));
751
752/** 1001 1101 mov %0, %1 */
753 ID(mov); DM(None, SADDR); SR(A);
754
755/** 1100 1110 mov %s0, #%1 */
756 op0 = SFR;
757 op1 = IMMU(1);
758 ID(mov); DM(None, op0); SC(op1);
0952813b 759 if (op0 == 0xffffb && isa == RL78_ISA_G14)
99c513f6
DD		 760 switch (op1)
761 {
762 case 0x01:
763 rl78->syntax = "mulhu"; ID(mulhu);
764 break;
765 case 0x02:
766 rl78->syntax = "mulh"; ID(mulh);
767 break;
768 case 0x03:
769 rl78->syntax = "divhu"; ID(divhu);
770 break;
771 case 0x04:
c7570fcd 772 rl78->syntax = "divwu <old-encoding>"; ID(divwu);
99c513f6
DD		 773 break;
774 case 0x05:
775 rl78->syntax = "machu"; ID(machu);
776 break;
777 case 0x06:
778 rl78->syntax = "mach"; ID(mach);
779 break;
151fa98f
NC		 780 case 0x0b:
781 rl78->syntax = "divwu"; ID(divwu);
782 break;
99c513f6
DD		 783 }
784
46662804 785/** 1001 1110 mov %s0, %1 */
99c513f6
DD		 786 ID(mov); DM(None, SFR); SR(A);
787
788/*----------------------------------------------------------------------*/
789
3d557b4c 790/** 0111 0001 1bit 0001 mov1 %e0, cy */
99c513f6
DD		 791 ID(mov); DM(HL, 0); DB(bit); SCY();
792
3d557b4c 793/** 0111 0001 1bit 1001 mov1 %e0, cy */
99c513f6
DD		 794 ID(mov); DR(A); DB(bit); SCY();
795
3d557b4c 796/** 0111 0001 1bit 0100 mov1 cy, %e1 */
99c513f6
DD		 797 ID(mov); DCY(); SM(HL, 0); SB(bit);
798
3d557b4c 799/** 0111 0001 1bit 1100 mov1 cy, %e1 */
99c513f6
DD		 800 ID(mov); DCY(); SR(A); SB(bit);
801
802/** 0111 0001 0bit 0100 mov1 cy, %1 */
803 ID(mov); DCY(); SM(None, SADDR); SB(bit);
804
805/** 0111 0001 0bit 1100 mov1 cy, %s1 */
806 ID(mov); DCY(); SM(None, SFR); SB(bit);
807
808/** 0111 0001 0bit 0001 mov1 %0, cy */
809 ID(mov); DM(None, SADDR); DB(bit); SCY();
810
811/** 0111 0001 0bit 1001 mov1 %s0, cy */
812 ID(mov); DM(None, SFR); DB(bit); SCY();
813
814/*----------------------------------------------------------------------*/
815
90092e73 816/** 0110 0001 1100 1110 movs %ea0, %1 */
99c513f6
DD		 817 ID(mov); DM(HL, IMMU(1)); SR(X); Fzc;
818
819/*----------------------------------------------------------------------*/
820
3d557b4c 821/** 1011 1111 movw %e!0, %1 */
99c513f6
DD		 822 ID(mov); W(); DM(None, IMMU(2)); SR(AX);
823
3d557b4c 824/** 1011 1001 movw %e0, %1 */
99c513f6
DD		 825 ID(mov); W(); DM(DE, 0); SR(AX);
826
c2f28758 827/** 1011 1010 movw %ea0, %1 */
99c513f6
DD		 828 ID(mov); W(); DM(DE, IMMU(1)); SR(AX);
829
3d557b4c 830/** 1011 1011 movw %e0, %1 */
99c513f6
DD		 831 ID(mov); W(); DM(HL, 0); SR(AX);
832
90092e73 833/** 1011 1100 movw %ea0, %1 */
99c513f6
DD		 834 ID(mov); W(); DM(HL, IMMU(1)); SR(AX);
835
02f12cd4 836/** 1011 1000 movw %a0, %1 */
99c513f6
DD		 837 ID(mov); W(); DM(SP, IMMU(1)); SR(AX);
838
3d557b4c 839/** 1010 1111 movw %0, %e!1 */
99c513f6
DD		 840 ID(mov); W(); DR(AX); SM(None, IMMU(2));
841
842
3d557b4c 843/** 1010 1001 movw %0, %e1 */
99c513f6
DD		 844 ID(mov); W(); DR(AX); SM(DE, 0);
845
c2f28758 846/** 1010 1010 movw %0, %ea1 */
99c513f6
DD		 847 ID(mov); W(); DR(AX); SM(DE, IMMU(1));
848
3d557b4c 849/** 1010 1011 movw %0, %e1 */
99c513f6
DD		 850 ID(mov); W(); DR(AX); SM(HL, 0);
851
90092e73 852/** 1010 1100 movw %0, %ea1 */
99c513f6
DD		 853 ID(mov); W(); DR(AX); SM(HL, IMMU(1));
854
02f12cd4 855/** 1010 1000 movw %0, %a1 */
99c513f6
DD		 856 ID(mov); W(); DR(AX); SM(SP, IMMU(1));
857
858/** 0011 0rg0 movw %0, #%1 */
859 ID(mov); W(); DRW(rg); SC(IMMU(2));
860
861/** 0001 0ra1 movw %0, %1 */
862 ID(mov); W(); DR(AX); SRW(ra);
863
864/** 0001 0ra0 movw %0, %1 */
865 ID(mov); W(); DRW(ra); SR(AX);
866
3d557b4c 867/** 0101 1001 movw %0, %e1 */
99c513f6
DD		 868 ID(mov); W(); DR(AX); SM(B, IMMU(2));
869
3d557b4c 870/** 0110 1001 movw %0, %e1 */
99c513f6
DD		 871 ID(mov); W(); DR(AX); SM(C, IMMU(2));
872
3d557b4c 873/** 0111 1001 movw %0, %e1 */
99c513f6
DD		 874 ID(mov); W(); DR(AX); SM(BC, IMMU(2));
875
3d557b4c 876/** 0101 1000 movw %e0, %1 */
99c513f6
DD		 877 ID(mov); W(); DM(B, IMMU(2)); SR(AX);
878
3d557b4c 879/** 0110 1000 movw %e0, %1 */
99c513f6
DD		 880 ID(mov); W(); DM(C, IMMU(2)); SR(AX);
881
3d557b4c 882/** 0111 1000 movw %e0, %1 */
99c513f6
DD		 883 ID(mov); W(); DM(BC, IMMU(2)); SR(AX);
884
885/** 1010 1101 movw %0, %1 */
886 ID(mov); W(); DR(AX); SM(None, SADDR);
887
888/** 1010 1110 movw %0, %s1 */
889 ID(mov); W(); DR(AX); SM(None, SFR);
890
4d82fe66 891/** 11ra 1011 movw %0, %es!1 */
99c513f6
DD		 892 ID(mov); W(); DRW(ra); SM(None, IMMU(2));
893
894/** 11ra 1010 movw %0, %1 */
895 ID(mov); W(); DRW(ra); SM(None, SADDR);
896
897/** 1100 1001 movw %0, #%1 */
898 ID(mov); W(); DM(None, SADDR); SC(IMMU(2));
899
900/** 1011 1101 movw %0, %1 */
901 ID(mov); W(); DM(None, SADDR); SR(AX);
902
46662804 903/** 1100 1011 movw %s0, #%1 */
99c513f6
DD		 904 ID(mov); W(); DM(None, SFR); SC(IMMU(2));
905
46662804 906/** 1011 1110 movw %s0, %1 */
99c513f6
DD		 907 ID(mov); W(); DM(None, SFR); SR(AX);
908
909/*----------------------------------------------------------------------*/
910
911/** 1101 0110 mulu x */
1eac08cc 912 ID(mulu);
99c513f6
DD		 913
914/*----------------------------------------------------------------------*/
915
916/** 0000 0000 nop */
917 ID(nop);
918
919/*----------------------------------------------------------------------*/
920
21abe33a
DD		 921/** 0111 0001 1100 0000 not1 cy */
922 ID(xor); DCY(); SC(1);
923
924/*----------------------------------------------------------------------*/
925
3d557b4c 926/** 1110 0101 oneb %e!0 */
99c513f6
DD		 927 ID(mov); DM(None, IMMU(2)); SC(1);
928
929/** 1110 00rg oneb %0 */
930 ID(mov); DRB(rg); SC(1);
931
932/** 1110 0100 oneb %0 */
933 ID(mov); DM(None, SADDR); SC(1);
934
935/*----------------------------------------------------------------------*/
936
937/** 1110 0110 onew %0 */
938 ID(mov); DR(AX); SC(1);
939
940/** 1110 0111 onew %0 */
941 ID(mov); DR(BC); SC(1);
942
943/*----------------------------------------------------------------------*/
944
3d557b4c 945/** 0110 1111 or %0, %e!1 */
99c513f6
DD		 946 ID(or); DR(A); SM(None, IMMU(2)); Fz;
947
3d557b4c 948/** 0110 1101 or %0, %e1 */
99c513f6
DD		 949 ID(or); DR(A); SM(HL, 0); Fz;
950
3d557b4c 951/** 0110 0001 1110 0000 or %0, %e1 */
99c513f6
DD		 952 ID(or); DR(A); SM2(HL, B, 0); Fz;
953
90092e73 954/** 0110 1110 or %0, %ea1 */
99c513f6
DD		 955 ID(or); DR(A); SM(HL, IMMU(1)); Fz;
956
3d557b4c 957/** 0110 0001 1110 0010 or %0, %e1 */
99c513f6
DD		 958 ID(or); DR(A); SM2(HL, C, 0); Fz;
959
960/** 0110 1100 or %0, #%1 */
961 ID(or); DR(A); SC(IMMU(1)); Fz;
962
963/** 0110 0001 0110 1rba or %0, %1 */
964 ID(or); DR(A); SRB(rba); Fz;
965
966/** 0110 0001 0110 0reg or %0, %1 */
967 ID(or); DRB(reg); SR(A); Fz;
968
969/** 0110 1011 or %0, %1 */
970 ID(or); DR(A); SM(None, SADDR); Fz;
971
972/** 0110 1010 or %0, #%1 */
973 ID(or); DM(None, SADDR); SC(IMMU(1)); Fz;
974
975/*----------------------------------------------------------------------*/
976
3d557b4c 977/** 0111 0001 1bit 0110 or1 cy, %e1 */
99c513f6
DD		 978 ID(or); DCY(); SM(HL, 0); SB(bit);
979
980/** 0111 0001 1bit 1110 or1 cy, %1 */
981 ID(or); DCY(); SR(A); SB(bit);
982
983/** 0111 0001 0bit 1110 or1 cy, %s1 */
984 ID(or); DCY(); SM(None, SFR); SB(bit);
985
986/** 0111 0001 0bit 0110 or1 cy, %s1 */
987 ID(or); DCY(); SM(None, SADDR); SB(bit);
988
989/*----------------------------------------------------------------------*/
990
991/** 1100 0rg0 pop %0 */
992 ID(mov); W(); DRW(rg); SPOP();
993
994/** 0110 0001 1100 1101 pop %s0 */
995 ID(mov); W(); DR(PSW); SPOP();
996
997/*----------------------------------------------------------------------*/
998
999/** 1100 0rg1 push %1 */
1000 ID(mov); W(); DPUSH(); SRW(rg);
1001
1002/** 0110 0001 1101 1101 push %s1 */
1003 ID(mov); W(); DPUSH(); SR(PSW);
1004
1005/*----------------------------------------------------------------------*/
1006
1007/** 1101 0111 ret */
1008 ID(ret);
1009
1010/** 0110 0001 1111 1100 reti */
1011 ID(reti);
1012
1013/** 0110 0001 1110 1100 retb */
1014 ID(reti);
1015
1016/*----------------------------------------------------------------------*/
1017
1018/** 0110 0001 1110 1011 rol %0, %1 */
1019 ID(rol); DR(A); SC(1);
1020
1021/** 0110 0001 1101 1100 rolc %0, %1 */
1022 ID(rolc); DR(A); SC(1);
1023
1024/** 0110 0001 111r 1110 rolwc %0, %1 */
1025 ID(rolc); W(); DRW(r); SC(1);
1026
1027/** 0110 0001 1101 1011 ror %0, %1 */
1028 ID(ror); DR(A); SC(1);
1029
1030/** 0110 0001 1111 1011 rorc %0, %1 */
1031 ID(rorc); DR(A); SC(1);
1032
1033/*----------------------------------------------------------------------*/
1034
1035/* Note that the branch insns need to be listed before the shift
1036 ones, as "shift count of zero" means "branch insn" */
1037
1038/** 0011 0001 0cnt 1011 sar %0, %1 */
1039 ID(sar); DR(A); SC(cnt);
1040
1041/** 0011 0001 wcnt 1111 sarw %0, %1 */
1042 ID(sar); W(); DR(AX); SC(wcnt);
1043
1044/*----------------------------------------------------------------------*/
1045
1046/** 0110 0001 11rb 1111 sel rb%1 */
1047 ID(sel); SC(rb);
1048
1049/*----------------------------------------------------------------------*/
1050
3d557b4c 1051/** 0111 0001 0bit 0000 set1 %e!0 */
99c513f6
DD		 1052 ID(mov); DM(None, IMMU(2)); DB(bit); SC(1);
1053
3d557b4c 1054/** 0111 0001 1bit 0010 set1 %e0 */
99c513f6
DD		 1055 ID(mov); DM(HL, 0); DB(bit); SC(1);
1056
1057/** 0111 0001 1bit 1010 set1 %0 */
1058 ID(mov); DR(A); DB(bit); SC(1);
1059
1060/** 0111 0001 1000 0000 set1 cy */
1061 ID(mov); DCY(); SC(1);
1062
1063/** 0111 0001 0bit 1010 set1 %s0 */
1064 op0 = SFR;
1065 ID(mov); DM(None, op0); DB(bit); SC(1);
1066 if (op0 == RL78_SFR_PSW && bit == 7)
1067 rl78->syntax = "ei";
1068
1069/** 0111 0001 0bit 0010 set1 %0 */
1070 ID(mov); DM(None, SADDR); DB(bit); SC(1);
1071
1072/*----------------------------------------------------------------------*/
1073
1074/** 0011 0001 0cnt 1001 shl %0, %1 */
1075 ID(shl); DR(A); SC(cnt);
1076
1077/** 0011 0001 0cnt 1000 shl %0, %1 */
1078 ID(shl); DR(B); SC(cnt);
1079
1080/** 0011 0001 0cnt 0111 shl %0, %1 */
1081 ID(shl); DR(C); SC(cnt);
1082
1083/** 0011 0001 wcnt 1101 shlw %0, %1 */
1084 ID(shl); W(); DR(AX); SC(wcnt);
1085
1086/** 0011 0001 wcnt 1100 shlw %0, %1 */
1087 ID(shl); W(); DR(BC); SC(wcnt);
1088
1089/*----------------------------------------------------------------------*/
1090
1091/** 0011 0001 0cnt 1010 shr %0, %1 */
1092 ID(shr); DR(A); SC(cnt);
1093
1094/** 0011 0001 wcnt 1110 shrw %0, %1 */
1095 ID(shr); W(); DR(AX); SC(wcnt);
1096
1097/*----------------------------------------------------------------------*/
1098
1099/** 0110 0001 1100 1000 sk%c1 */
1100 ID(skip); COND(C);
1101
1102/** 0110 0001 1110 0011 sk%c1 */
1103 ID(skip); COND(H);
1104
1105/** 0110 0001 1101 1000 sk%c1 */
1106 ID(skip); COND(NC);
1107
1108/** 0110 0001 1111 0011 sk%c1 */
1109 ID(skip); COND(NH);
1110
1111/** 0110 0001 1111 1000 sk%c1 */
1112 ID(skip); COND(NZ);
1113
1114/** 0110 0001 1110 1000 sk%c1 */
1115 ID(skip); COND(Z);
1116
1117/*----------------------------------------------------------------------*/
1118
3d557b4c 1119/** 0110 0001 1111 1101 stop */
99c513f6
DD		 1120 ID(stop);
1121
1122/*----------------------------------------------------------------------*/
1123
3d557b4c 1124/** 0010 1111 sub %0, %e!1 */
99c513f6
DD		 1125 ID(sub); DR(A); SM(None, IMMU(2)); Fzac;
1126
3d557b4c 1127/** 0010 1101 sub %0, %e1 */
99c513f6
DD		 1128 ID(sub); DR(A); SM(HL, 0); Fzac;
1129
3d557b4c 1130/** 0110 0001 1010 000 sub %0, %e1 */
99c513f6
DD		 1131 ID(sub); DR(A); SM2(HL, B, 0); Fzac;
1132
90092e73 1133/** 0010 1110 sub %0, %ea1 */
99c513f6
DD		 1134 ID(sub); DR(A); SM(HL, IMMU(1)); Fzac;
1135
3d557b4c 1136/** 0110 0001 1010 0010 sub %0, %e1 */
99c513f6
DD		 1137 ID(sub); DR(A); SM2(HL, C, 0); Fzac;
1138
1139/** 0010 1100 sub %0, #%1 */
1140 ID(sub); DR(A); SC(IMMU(1)); Fzac;
1141
1142/** 0110 0001 0010 1rba sub %0, %1 */
1143 ID(sub); DR(A); SRB(rba); Fzac;
1144
1145/** 0010 1011 sub %0, %1 */
1146 ID(sub); DR(A); SM(None, SADDR); Fzac;
1147
1148/** 0110 0001 0010 0reg sub %0, %1 */
1149 ID(sub); DRB(reg); SR(A); Fzac;
1150
1151/** 0010 1010 sub %0, #%1 */
1152 ID(sub); DM(None, SADDR); SC(IMMU(1)); Fzac;
1153
1154/*----------------------------------------------------------------------*/
1155
3d557b4c 1156/** 0011 1111 subc %0, %e!1 */
99c513f6
DD		 1157 ID(subc); DR(A); SM(None, IMMU(2)); Fzac;
1158
3d557b4c 1159/** 0011 1101 subc %0, %e1 */
99c513f6
DD		 1160 ID(subc); DR(A); SM(HL, 0); Fzac;
1161
3d557b4c 1162/** 0110 0001 1011 0000 subc %0, %e1 */
99c513f6
DD		 1163 ID(subc); DR(A); SM2(HL, B, 0); Fzac;
1164
3d557b4c 1165/** 0110 0001 1011 0010 subc %0, %e1 */
99c513f6
DD		 1166 ID(subc); DR(A); SM2(HL, C, 0); Fzac;
1167
90092e73 1168/** 0011 1110 subc %0, %ea1 */
99c513f6
DD		 1169 ID(subc); DR(A); SM(HL, IMMU(1)); Fzac;
1170
1171/** 0011 1100 subc %0, #%1 */
1172 ID(subc); DR(A); SC(IMMU(1)); Fzac;
1173
1174/** 0110 0001 0011 1rba subc %0, %1 */
1175 ID(subc); DR(A); SRB(rba); Fzac;
1176
1177/** 0110 0001 0011 0reg subc %0, %1 */
1178 ID(subc); DRB(reg); SR(A); Fzac;
1179
1180/** 0011 1011 subc %0, %1 */
1181 ID(subc); DR(A); SM(None, SADDR); Fzac;
1182
1183/** 0011 1010 subc %0, #%1 */
1184 ID(subc); DM(None, SADDR); SC(IMMU(1)); Fzac;
1185
1186/*----------------------------------------------------------------------*/
1187
3d557b4c 1188/** 0010 0010 subw %0, %e!1 */
99c513f6
DD		 1189 ID(sub); W(); DR(AX); SM(None, IMMU(2)); Fzac;
1190
90092e73 1191/** 0110 0001 0010 1001 subw %0, %ea1 */
99c513f6
DD		 1192 ID(sub); W(); DR(AX); SM(HL, IMMU(1)); Fzac;
1193
1194/** 0010 0100 subw %0, #%1 */
1195 ID(sub); W(); DR(AX); SC(IMMU(2)); Fzac;
1196
1197/** 0010 0rw1 subw %0, %1 */
1198 ID(sub); W(); DR(AX); SRW(rw); Fzac;
1199
1200/** 0010 0110 subw %0, %1 */
1201 ID(sub); W(); DR(AX); SM(None, SADDR); Fzac;
1202
1203/** 0010 0000 subw %0, #%1 */
1204 ID(sub); W(); DR(SP); SC(IMMU(1)); Fzac;
1205
1206/*----------------------------------------------------------------------*/
1207
3d557b4c 1208/** 0110 0001 1010 1010 xch %0, %e!1 */
99c513f6
DD		 1209 ID(xch); DR(A); SM(None, IMMU(2));
1210
3d557b4c 1211/** 0110 0001 1010 1110 xch %0, %e1 */
99c513f6
DD		 1212 ID(xch); DR(A); SM(DE, 0);
1213
c2f28758 1214/** 0110 0001 1010 1111 xch %0, %ea1 */
99c513f6
DD		 1215 ID(xch); DR(A); SM(DE, IMMU(1));
1216
3d557b4c 1217/** 0110 0001 1010 1100 xch %0, %e1 */
99c513f6
DD		 1218 ID(xch); DR(A); SM(HL, 0);
1219
3d557b4c 1220/** 0110 0001 1011 1001 xch %0, %e1 */
99c513f6
DD		 1221 ID(xch); DR(A); SM2(HL, B, 0);
1222
90092e73 1223/** 0110 0001 1010 1101 xch %0, %ea1 */
99c513f6
DD		 1224 ID(xch); DR(A); SM(HL, IMMU(1));
1225
3d557b4c 1226/** 0110 0001 1010 1001 xch %0, %e1 */
99c513f6
DD		 1227 ID(xch); DR(A); SM2(HL, C, 0);
1228
1229/** 0110 0001 1000 1reg xch %0, %1 */
1230 /* Note: DECW uses reg == X, so this must follow DECW */
1231 ID(xch); DR(A); SRB(reg);
1232
1233/** 0110 0001 1010 1000 xch %0, %1 */
1234 ID(xch); DR(A); SM(None, SADDR);
1235
46662804 1236/** 0110 0001 1010 1011 xch %0, %s1 */
99c513f6
DD		 1237 ID(xch); DR(A); SM(None, SFR);
1238
1239/** 0000 1000 xch a, x */
1240 ID(xch); DR(A); SR(X);
1241
1242/*----------------------------------------------------------------------*/
1243
1244/** 0011 0ra1 xchw %0, %1 */
1245 ID(xch); W(); DR(AX); SRW(ra);
1246
1247/*----------------------------------------------------------------------*/
1248
3d557b4c 1249/** 0111 1111 xor %0, %e!1 */
99c513f6
DD		 1250 ID(xor); DR(A); SM(None, IMMU(2)); Fz;
1251
3d557b4c 1252/** 0111 1101 xor %0, %e1 */
99c513f6
DD		 1253 ID(xor); DR(A); SM(HL, 0); Fz;
1254
3d557b4c 1255/** 0110 0001 1111 0000 xor %0, %e1 */
99c513f6
DD		 1256 ID(xor); DR(A); SM2(HL, B, 0); Fz;
1257
90092e73 1258/** 0111 1110 xor %0, %ea1 */
99c513f6
DD		 1259 ID(xor); DR(A); SM(HL, IMMU(1)); Fz;
1260
3d557b4c 1261/** 0110 0001 1111 0010 xor %0, %e1 */
99c513f6
DD		 1262 ID(xor); DR(A); SM2(HL, C, 0); Fz;
1263
1264/** 0111 1100 xor %0, #%1 */
1265 ID(xor); DR(A); SC(IMMU(1)); Fz;
1266
1267/** 0110 0001 0111 1rba xor %0, %1 */
1268 ID(xor); DR(A); SRB(rba); Fz;
1269
1270/** 0110 0001 0111 0reg xor %0, %1 */
1271 ID(xor); DRB(reg); SR(A); Fz;
1272
1273/** 0111 1011 xor %0, %1 */
1274 ID(xor); DR(A); SM(None, SADDR); Fz;
1275
1276/** 0111 1010 xor %0, #%1 */
1277 ID(xor); DM(None, SADDR); SC(IMMU(1)); Fz;
1278
1279/*----------------------------------------------------------------------*/
1280
3d557b4c 1281/** 0111 0001 1bit 0111 xor1 cy, %e1 */
99c513f6
DD		 1282 ID(xor); DCY(); SM(HL, 0); SB(bit);
1283
1284/** 0111 0001 1bit 1111 xor1 cy, %1 */
1285 ID(xor); DCY(); SR(A); SB(bit);
1286
1287/** 0111 0001 0bit 1111 xor1 cy, %s1 */
1288 ID(xor); DCY(); SM(None, SFR); SB(bit);
1289
1290/** 0111 0001 0bit 0111 xor1 cy, %s1 */
1291 ID(xor); DCY(); SM(None, SADDR); SB(bit);
1292
1293/*----------------------------------------------------------------------*/
1294
1295/** */
1296
1297 return rl78->n_bytes;
1298}
GDB Binutils - Deliverables
This page took 0.464853 seconds and 4 git commands to generate.