]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - opcodes/msp430-decode.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
-Wimplicit-fallthrough error fixes
[thirdparty/binutils-gdb.git] / opcodes / msp430-decode.c
1 #line 1 "msp430-decode.opc"
2 /* -*- c -*- */
3 /* Copyright (C) 2013-2016 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/msp430-decode.h"
30
31 static int trace = 0;
32
33 typedef struct
34 {
35 MSP430_Opcode_Decoded *msp430;
36 int (*getbyte)(void *);
37 void *ptr;
38 unsigned char *op;
39 int op_ptr;
40 int pc;
41 } LocalData;
42
43 #define AU ATTRIBUTE_UNUSED
44 #define GETBYTE() getbyte_swapped (ld)
45 #define B ((unsigned long) GETBYTE ())
46
47 static int
48 getbyte_swapped (LocalData *ld)
49 {
50 int b;
51
52 if (ld->op_ptr == ld->msp430->n_bytes)
53 {
54 do
55 {
56 b = ld->getbyte (ld->ptr);
57 ld->op [(ld->msp430->n_bytes++)^1] = b;
58 }
59 while (ld->msp430->n_bytes & 1);
60 }
61 return ld->op[ld->op_ptr++];
62 }
63
64 #define ID(x) msp430->id = x
65
66 #define OP(n, t, r, a) (msp430->op[n].type = t, \
67 msp430->op[n].reg = r, \
68 msp430->op[n].addend = a)
69
70 #define OPX(n, t, r1, r2, a) \
71 (msp430->op[n].type = t, \
72 msp430->op[n].reg = r1, \
73 msp430->op[n].reg2 = r2, \
74 msp430->op[n].addend = a)
75
76 #define SYNTAX(x) msp430->syntax = x
77 #define UNSUPPORTED() msp430->syntax = "*unknown*"
78
79 #define DC(c) OP (0, MSP430_Operand_Immediate, 0, c)
80 #define DR(r) OP (0, MSP430_Operand_Register, r, 0)
81 #define DM(r, a) OP (0, MSP430_Operand_Indirect, r, a)
82 #define DA(a) OP (0, MSP430_Operand_Indirect, MSR_None, a)
83 #define AD(r, ad) encode_ad (r, ad, ld, 0)
84 #define ADX(r, ad, x) encode_ad (r, ad, ld, x)
85
86 #define SC(c) OP (1, MSP430_Operand_Immediate, 0, c)
87 #define SR(r) OP (1, MSP430_Operand_Register, r, 0)
88 #define SM(r, a) OP (1, MSP430_Operand_Indirect, r, a)
89 #define SA(a) OP (1, MSP430_Operand_Indirect, MSR_None, a)
90 #define SI(r) OP (1, MSP430_Operand_Indirect_Postinc, r, 0)
91 #define AS(r, as) encode_as (r, as, ld, 0)
92 #define ASX(r, as, x) encode_as (r, as, ld, x)
93
94 #define BW(x) msp430->size = (x ? 8 : 16)
95 /* The last 20 is for SWPBX.Z and SXTX.A. */
96 #define ABW(a,x) msp430->size = (a ? ((x ? 8 : 16)) : (x ? 20 : 20))
97
98 #define IMMU(bytes) immediate (bytes, 0, ld)
99 #define IMMS(bytes) immediate (bytes, 1, ld)
100
101 /* Helper macros for known status bits settings. */
102 #define F_____ msp430->flags_1 = msp430->flags_0 = 0; msp430->flags_set = 0
103 #define F_VNZC msp430->flags_1 = msp430->flags_0 = 0; msp430->flags_set = 0x87
104 #define F_0NZC msp430->flags_1 = 0; msp430->flags_0 = 0x80; msp430->flags_set = 0x07
105
106
107 /* The chip is little-endian, but GETBYTE byte-swaps words because the
108 decoder is based on 16-bit "words" so *this* logic is big-endian. */
109
110 static int
111 immediate (int bytes, int sign_extend, LocalData *ld)
112 {
113 unsigned long i = 0;
114
115 switch (bytes)
116 {
117 case 1:
118 i |= B;
119 if (sign_extend && (i & 0x80))
120 i -= 0x100;
121 break;
122 case 2:
123 i |= B << 8;
124 i |= B;
125 if (sign_extend && (i & 0x8000))
126 i -= 0x10000;
127 break;
128 case 3:
129 i |= B << 16;
130 i |= B << 8;
131 i |= B;
132 if (sign_extend && (i & 0x800000))
133 i -= 0x1000000;
134 break;
135 case 4:
136 i |= B << 24;
137 i |= B << 16;
138 i |= B << 8;
139 i |= B;
140 if (sign_extend && (i & 0x80000000ULL))
141 i -= 0x100000000ULL;
142 break;
143 default:
144 fprintf (stderr,
145 "Programmer error: immediate() called with invalid byte count %d\n",
146 bytes);
147 abort ();
148 }
149 return i;
150 }
151
152 /*
153 PC SP SR CG
154 As
155 00 Rn - - R2 #0
156 01 X(Rn) Sym - X(abs) #1
157 10 (Rn) - - #4 #2
158 11 (Rn++) #imm - #8 #-1
159
160 Ad
161 0 Rn - - - -
162 1 X(Rn) Sym - X(abs) - */
163
164 static void
165 encode_ad (int reg, int ad, LocalData *ld, int ext)
166 {
167 MSP430_Opcode_Decoded *msp430 = ld->msp430;
168
169 if (ad)
170 {
171 int x = IMMU(2) | (ext << 16);
172 switch (reg)
173 {
174 case 0: /* (PC) -> Symbolic. */
175 DA (x + ld->pc + ld->op_ptr - 2);
176 break;
177 case 2: /* (SR) -> Absolute. */
178 DA (x);
179 break;
180 default:
181 DM (reg, x);
182 break;
183 }
184 }
185 else
186 {
187 DR (reg);
188 }
189 }
190
191 static void
192 encode_as (int reg, int as, LocalData *ld, int ext)
193 {
194 MSP430_Opcode_Decoded *msp430 = ld->msp430;
195 int x;
196
197 switch (as)
198 {
199 case 0:
200 switch (reg)
201 {
202 case 3:
203 SC (0);
204 break;
205 default:
206 SR (reg);
207 break;
208 }
209 break;
210 case 1:
211 switch (reg)
212 {
213 case 0: /* PC -> Symbolic. */
214 x = IMMU(2) | (ext << 16);
215 SA (x + ld->pc + ld->op_ptr - 2);
216 break;
217 case 2: /* SR -> Absolute. */
218 x = IMMU(2) | (ext << 16);
219 SA (x);
220 break;
221 case 3:
222 SC (1);
223 break;
224 default:
225 x = IMMU(2) | (ext << 16);
226 SM (reg, x);
227 break;
228 }
229 break;
230 case 2:
231 switch (reg)
232 {
233 case 2:
234 SC (4);
235 break;
236 case 3:
237 SC (2);
238 break;
239 case MSR_None:
240 SA (0);
241 break;
242 default:
243 SM (reg, 0);
244 break;
245 }
246 break;
247 case 3:
248 switch (reg)
249 {
250 case 0:
251 {
252 /* This fetch *is* the *PC++ that the opcode encodes :-) */
253 x = IMMU(2) | (ext << 16);
254 SC (x);
255 }
256 break;
257 case 2:
258 SC (8);
259 break;
260 case 3:
261 SC (-1);
262 break;
263 default:
264 SI (reg);
265 break;
266 }
267 break;
268 }
269 }
270
271 static void
272 encode_rep_zc (int srxt, int dsxt, LocalData *ld)
273 {
274 MSP430_Opcode_Decoded *msp430 = ld->msp430;
275
276 msp430->repeat_reg = srxt & 1;
277 msp430->repeats = dsxt;
278 msp430->zc = (srxt & 2) ? 1 : 0;
279 }
280
281 #define REPZC(s,d) encode_rep_zc (s, d, ld)
282
283 static int
284 dopc_to_id (int dopc)
285 {
286 switch (dopc)
287 {
288 case 4: return MSO_mov;
289 case 5: return MSO_add;
290 case 6: return MSO_addc;
291 case 7: return MSO_subc;
292 case 8: return MSO_sub;
293 case 9: return MSO_cmp;
294 case 10: return MSO_dadd;
295 case 11: return MSO_bit;
296 case 12: return MSO_bic;
297 case 13: return MSO_bis;
298 case 14: return MSO_xor;
299 case 15: return MSO_and;
300 default: return MSO_unknown;
301 }
302 }
303
304 static int
305 sopc_to_id (int sop, int c)
306 {
307 switch (sop * 2 + c)
308 {
309 case 0: return MSO_rrc;
310 case 1: return MSO_swpb;
311 case 2: return MSO_rra;
312 case 3: return MSO_sxt;
313 case 4: return MSO_push;
314 case 5: return MSO_call;
315 case 6: return MSO_reti;
316 default: return MSO_unknown;
317 }
318 }
319
320 int
321 msp430_decode_opcode (unsigned long pc,
322 MSP430_Opcode_Decoded *msp430,
323 int (*getbyte)(void *),
324 void *ptr)
325 {
326 LocalData lds, *ld = &lds;
327 unsigned char op_buf[20] = {0};
328 unsigned char *op = op_buf;
329 int raddr;
330 int al_bit;
331 int srxt_bits, dsxt_bits;
332
333 lds.msp430 = msp430;
334 lds.getbyte = getbyte;
335 lds.ptr = ptr;
336 lds.op = op;
337 lds.op_ptr = 0;
338 lds.pc = pc;
339
340 memset (msp430, 0, sizeof (*msp430));
341
342 /* These are overridden by an extension word. */
343 al_bit = 1;
344 srxt_bits = 0;
345 dsxt_bits = 0;
346
347 post_extension_word:
348 ;
349
350 /* 430X extention word. */
351 GETBYTE ();
352 switch (op[0] & 0xff)
353 {
354 case 0x00:
355 GETBYTE ();
356 switch (op[1] & 0xf0)
357 {
358 case 0x00:
359 op_semantics_1:
360 {
361 /** 0000 srcr 0000 dstr MOVA @%1, %0 */
362 #line 439 "msp430-decode.opc"
363 int srcr AU = op[0] & 0x0f;
364 #line 439 "msp430-decode.opc"
365 int dstr AU = op[1] & 0x0f;
366 if (trace)
367 {
368 printf ("\033[33m%s\033[0m %02x %02x\n",
369 "/** 0000 srcr 0000 dstr MOVA @%1, %0 */",
370 op[0], op[1]);
371 printf (" srcr = 0x%x,", srcr);
372 printf (" dstr = 0x%x\n", dstr);
373 }
374 SYNTAX("MOVA @%1, %0");
375 #line 439 "msp430-decode.opc"
376 ID (MSO_mov); SM (srcr, 0); DR (dstr);
377 msp430->size = 20;
378 msp430->ofs_430x = 1;
379
380 }
381 break;
382 case 0x10:
383 op_semantics_2:
384 {
385 /** 0000 srcr 0001 dstr MOVA @%1+, %0 */
386 #line 444 "msp430-decode.opc"
387 int srcr AU = op[0] & 0x0f;
388 #line 444 "msp430-decode.opc"
389 int dstr AU = op[1] & 0x0f;
390 if (trace)
391 {
392 printf ("\033[33m%s\033[0m %02x %02x\n",
393 "/** 0000 srcr 0001 dstr MOVA @%1+, %0 */",
394 op[0], op[1]);
395 printf (" srcr = 0x%x,", srcr);
396 printf (" dstr = 0x%x\n", dstr);
397 }
398 SYNTAX("MOVA @%1+, %0");
399 #line 444 "msp430-decode.opc"
400 ID (MSO_mov); SI (srcr); DR (dstr);
401 msp430->size = 20;
402 msp430->ofs_430x = 1;
403
404 }
405 break;
406 case 0x20:
407 op_semantics_3:
408 {
409 /** 0000 srcr 0010 dstr MOVA &%1, %0 */
410 #line 449 "msp430-decode.opc"
411 int srcr AU = op[0] & 0x0f;
412 #line 449 "msp430-decode.opc"
413 int dstr AU = op[1] & 0x0f;
414 if (trace)
415 {
416 printf ("\033[33m%s\033[0m %02x %02x\n",
417 "/** 0000 srcr 0010 dstr MOVA &%1, %0 */",
418 op[0], op[1]);
419 printf (" srcr = 0x%x,", srcr);
420 printf (" dstr = 0x%x\n", dstr);
421 }
422 SYNTAX("MOVA &%1, %0");
423 #line 449 "msp430-decode.opc"
424 ID (MSO_mov); SA ((srcr << 16) + IMMU(2)); DR (dstr);
425 msp430->size = 20;
426 msp430->ofs_430x = 1;
427
428 }
429 break;
430 case 0x30:
431 op_semantics_4:
432 {
433 /** 0000 srcr 0011 dstr MOVA %1, %0 */
434 #line 454 "msp430-decode.opc"
435 int srcr AU = op[0] & 0x0f;
436 #line 454 "msp430-decode.opc"
437 int dstr AU = op[1] & 0x0f;
438 if (trace)
439 {
440 printf ("\033[33m%s\033[0m %02x %02x\n",
441 "/** 0000 srcr 0011 dstr MOVA %1, %0 */",
442 op[0], op[1]);
443 printf (" srcr = 0x%x,", srcr);
444 printf (" dstr = 0x%x\n", dstr);
445 }
446 SYNTAX("MOVA %1, %0");
447 #line 454 "msp430-decode.opc"
448 ID (MSO_mov); SM (srcr, IMMS(2)); DR (dstr);
449 msp430->size = 20;
450 msp430->ofs_430x = 1;
451
452 }
453 break;
454 case 0x40:
455 case 0x50:
456 op_semantics_5:
457 {
458 /** 0000 bt00 010w dstr RRCM.A %c, %0 */
459 #line 521 "msp430-decode.opc"
460 int bt AU = (op[0] >> 2) & 0x03;
461 #line 521 "msp430-decode.opc"
462 int w AU = (op[1] >> 4) & 0x01;
463 #line 521 "msp430-decode.opc"
464 int dstr AU = op[1] & 0x0f;
465 if (trace)
466 {
467 printf ("\033[33m%s\033[0m %02x %02x\n",
468 "/** 0000 bt00 010w dstr RRCM.A %c, %0 */",
469 op[0], op[1]);
470 printf (" bt = 0x%x,", bt);
471 printf (" w = 0x%x,", w);
472 printf (" dstr = 0x%x\n", dstr);
473 }
474 SYNTAX("RRCM.A %c, %0");
475 #line 521 "msp430-decode.opc"
476 ID (MSO_rrc); DR (dstr); SR (dstr);
477 msp430->repeats = bt;
478 msp430->size = w ? 16 : 20;
479 msp430->ofs_430x = 1;
480 F_0NZC;
481
482 }
483 break;
484 case 0x60:
485 op_semantics_6:
486 {
487 /** 0000 srcr 0110 dstr MOVA %1, &%0 */
488 #line 459 "msp430-decode.opc"
489 int srcr AU = op[0] & 0x0f;
490 #line 459 "msp430-decode.opc"
491 int dstr AU = op[1] & 0x0f;
492 if (trace)
493 {
494 printf ("\033[33m%s\033[0m %02x %02x\n",
495 "/** 0000 srcr 0110 dstr MOVA %1, &%0 */",
496 op[0], op[1]);
497 printf (" srcr = 0x%x,", srcr);
498 printf (" dstr = 0x%x\n", dstr);
499 }
500 SYNTAX("MOVA %1, &%0");
501 #line 459 "msp430-decode.opc"
502 ID (MSO_mov); SR (srcr); DA ((dstr << 16) + IMMU(2));
503 msp430->size = 20;
504 msp430->ofs_430x = 1;
505
506 }
507 break;
508 case 0x70:
509 op_semantics_7:
510 {
511 /** 0000 srcr 0111 dstr MOVA %1, &%0 */
512 #line 464 "msp430-decode.opc"
513 int srcr AU = op[0] & 0x0f;
514 #line 464 "msp430-decode.opc"
515 int dstr AU = op[1] & 0x0f;
516 if (trace)
517 {
518 printf ("\033[33m%s\033[0m %02x %02x\n",
519 "/** 0000 srcr 0111 dstr MOVA %1, &%0 */",
520 op[0], op[1]);
521 printf (" srcr = 0x%x,", srcr);
522 printf (" dstr = 0x%x\n", dstr);
523 }
524 SYNTAX("MOVA %1, &%0");
525 #line 464 "msp430-decode.opc"
526 ID (MSO_mov); SR (srcr); DM (dstr, IMMS(2));
527 msp430->size = 20;
528 msp430->ofs_430x = 1;
529
530 }
531 break;
532 case 0x80:
533 op_semantics_8:
534 {
535 /** 0000 srcr 1000 dstr MOVA %1, %0 */
536 #line 469 "msp430-decode.opc"
537 int srcr AU = op[0] & 0x0f;
538 #line 469 "msp430-decode.opc"
539 int dstr AU = op[1] & 0x0f;
540 if (trace)
541 {
542 printf ("\033[33m%s\033[0m %02x %02x\n",
543 "/** 0000 srcr 1000 dstr MOVA %1, %0 */",
544 op[0], op[1]);
545 printf (" srcr = 0x%x,", srcr);
546 printf (" dstr = 0x%x\n", dstr);
547 }
548 SYNTAX("MOVA %1, %0");
549 #line 469 "msp430-decode.opc"
550 ID (MSO_mov); SC ((srcr << 16) + IMMU(2)); DR (dstr);
551 msp430->size = 20;
552 msp430->ofs_430x = 1;
553
554 }
555 break;
556 case 0x90:
557 op_semantics_9:
558 {
559 /** 0000 srcr 1001 dstr CMPA %1, %0 */
560 #line 474 "msp430-decode.opc"
561 int srcr AU = op[0] & 0x0f;
562 #line 474 "msp430-decode.opc"
563 int dstr AU = op[1] & 0x0f;
564 if (trace)
565 {
566 printf ("\033[33m%s\033[0m %02x %02x\n",
567 "/** 0000 srcr 1001 dstr CMPA %1, %0 */",
568 op[0], op[1]);
569 printf (" srcr = 0x%x,", srcr);
570 printf (" dstr = 0x%x\n", dstr);
571 }
572 SYNTAX("CMPA %1, %0");
573 #line 474 "msp430-decode.opc"
574 ID (MSO_cmp); SC ((srcr << 16) + IMMU(2)); DR (dstr);
575 msp430->size = 20;
576 msp430->ofs_430x = 1;
577 F_VNZC;
578
579 }
580 break;
581 case 0xa0:
582 op_semantics_10:
583 {
584 /** 0000 srcr 1010 dstr ADDA %1, %0 */
585 #line 480 "msp430-decode.opc"
586 int srcr AU = op[0] & 0x0f;
587 #line 480 "msp430-decode.opc"
588 int dstr AU = op[1] & 0x0f;
589 if (trace)
590 {
591 printf ("\033[33m%s\033[0m %02x %02x\n",
592 "/** 0000 srcr 1010 dstr ADDA %1, %0 */",
593 op[0], op[1]);
594 printf (" srcr = 0x%x,", srcr);
595 printf (" dstr = 0x%x\n", dstr);
596 }
597 SYNTAX("ADDA %1, %0");
598 #line 480 "msp430-decode.opc"
599 ID (MSO_add); SC ((srcr << 16) + IMMU(2)); DR (dstr);
600 msp430->size = 20;
601 msp430->ofs_430x = 1;
602 F_VNZC;
603
604 }
605 break;
606 case 0xb0:
607 op_semantics_11:
608 {
609 /** 0000 srcr 1011 dstr SUBA %1, %0 */
610 #line 486 "msp430-decode.opc"
611 int srcr AU = op[0] & 0x0f;
612 #line 486 "msp430-decode.opc"
613 int dstr AU = op[1] & 0x0f;
614 if (trace)
615 {
616 printf ("\033[33m%s\033[0m %02x %02x\n",
617 "/** 0000 srcr 1011 dstr SUBA %1, %0 */",
618 op[0], op[1]);
619 printf (" srcr = 0x%x,", srcr);
620 printf (" dstr = 0x%x\n", dstr);
621 }
622 SYNTAX("SUBA %1, %0");
623 #line 486 "msp430-decode.opc"
624 ID (MSO_sub); SC ((srcr << 16) + IMMU(2)); DR (dstr);
625 msp430->size = 20;
626 msp430->ofs_430x = 1;
627 F_VNZC;
628
629 }
630 break;
631 case 0xc0:
632 op_semantics_12:
633 {
634 /** 0000 srcr 1100 dstr MOVA %1, %0 */
635 #line 498 "msp430-decode.opc"
636 int srcr AU = op[0] & 0x0f;
637 #line 498 "msp430-decode.opc"
638 int dstr AU = op[1] & 0x0f;
639 if (trace)
640 {
641 printf ("\033[33m%s\033[0m %02x %02x\n",
642 "/** 0000 srcr 1100 dstr MOVA %1, %0 */",
643 op[0], op[1]);
644 printf (" srcr = 0x%x,", srcr);
645 printf (" dstr = 0x%x\n", dstr);
646 }
647 SYNTAX("MOVA %1, %0");
648 #line 498 "msp430-decode.opc"
649 ID (MSO_mov); SR (srcr); DR (dstr);
650 msp430->size = 20;
651 msp430->ofs_430x = 1;
652
653 }
654 break;
655 case 0xd0:
656 op_semantics_13:
657 {
658 /** 0000 srcr 1101 dstr CMPA %1, %0 */
659 #line 503 "msp430-decode.opc"
660 int srcr AU = op[0] & 0x0f;
661 #line 503 "msp430-decode.opc"
662 int dstr AU = op[1] & 0x0f;
663 if (trace)
664 {
665 printf ("\033[33m%s\033[0m %02x %02x\n",
666 "/** 0000 srcr 1101 dstr CMPA %1, %0 */",
667 op[0], op[1]);
668 printf (" srcr = 0x%x,", srcr);
669 printf (" dstr = 0x%x\n", dstr);
670 }
671 SYNTAX("CMPA %1, %0");
672 #line 503 "msp430-decode.opc"
673 ID (MSO_cmp); SR (srcr); DR (dstr);
674 msp430->size = 20;
675 msp430->ofs_430x = 1;
676 F_VNZC;
677
678 }
679 break;
680 case 0xe0:
681 op_semantics_14:
682 {
683 /** 0000 srcr 1110 dstr ADDA %1, %0 */
684 #line 509 "msp430-decode.opc"
685 int srcr AU = op[0] & 0x0f;
686 #line 509 "msp430-decode.opc"
687 int dstr AU = op[1] & 0x0f;
688 if (trace)
689 {
690 printf ("\033[33m%s\033[0m %02x %02x\n",
691 "/** 0000 srcr 1110 dstr ADDA %1, %0 */",
692 op[0], op[1]);
693 printf (" srcr = 0x%x,", srcr);
694 printf (" dstr = 0x%x\n", dstr);
695 }
696 SYNTAX("ADDA %1, %0");
697 #line 509 "msp430-decode.opc"
698 ID (MSO_add); SR (srcr); DR (dstr);
699 msp430->size = 20;
700 msp430->ofs_430x = 1;
701 F_VNZC;
702
703 }
704 break;
705 case 0xf0:
706 op_semantics_15:
707 {
708 /** 0000 srcr 1111 dstr SUBA %1, %0 */
709 #line 515 "msp430-decode.opc"
710 int srcr AU = op[0] & 0x0f;
711 #line 515 "msp430-decode.opc"
712 int dstr AU = op[1] & 0x0f;
713 if (trace)
714 {
715 printf ("\033[33m%s\033[0m %02x %02x\n",
716 "/** 0000 srcr 1111 dstr SUBA %1, %0 */",
717 op[0], op[1]);
718 printf (" srcr = 0x%x,", srcr);
719 printf (" dstr = 0x%x\n", dstr);
720 }
721 SYNTAX("SUBA %1, %0");
722 #line 515 "msp430-decode.opc"
723 ID (MSO_sub); SR (srcr); DR (dstr);
724 msp430->size = 20;
725 msp430->ofs_430x = 1;
726 F_VNZC;
727
728 }
729 break;
730 }
731 break;
732 case 0x01:
733 GETBYTE ();
734 switch (op[1] & 0xf0)
735 {
736 case 0x00:
737 goto op_semantics_1;
738 break;
739 case 0x10:
740 goto op_semantics_2;
741 break;
742 case 0x20:
743 goto op_semantics_3;
744 break;
745 case 0x30:
746 goto op_semantics_4;
747 break;
748 case 0x40:
749 case 0x50:
750 op_semantics_16:
751 {
752 /** 0000 bt01 010w dstr RRAM.A %c, %0 */
753 #line 528 "msp430-decode.opc"
754 int bt AU = (op[0] >> 2) & 0x03;
755 #line 528 "msp430-decode.opc"
756 int w AU = (op[1] >> 4) & 0x01;
757 #line 528 "msp430-decode.opc"
758 int dstr AU = op[1] & 0x0f;
759 if (trace)
760 {
761 printf ("\033[33m%s\033[0m %02x %02x\n",
762 "/** 0000 bt01 010w dstr RRAM.A %c, %0 */",
763 op[0], op[1]);
764 printf (" bt = 0x%x,", bt);
765 printf (" w = 0x%x,", w);
766 printf (" dstr = 0x%x\n", dstr);
767 }
768 SYNTAX("RRAM.A %c, %0");
769 #line 528 "msp430-decode.opc"
770 ID (MSO_rra); DR (dstr); SR (dstr);
771 msp430->repeats = bt;
772 msp430->size = w ? 16 : 20;
773 msp430->ofs_430x = 1;
774 F_0NZC;
775
776 }
777 break;
778 case 0x60:
779 goto op_semantics_6;
780 break;
781 case 0x70:
782 goto op_semantics_7;
783 break;
784 case 0x80:
785 goto op_semantics_8;
786 break;
787 case 0x90:
788 goto op_semantics_9;
789 break;
790 case 0xa0:
791 goto op_semantics_10;
792 break;
793 case 0xb0:
794 goto op_semantics_11;
795 break;
796 case 0xc0:
797 goto op_semantics_12;
798 break;
799 case 0xd0:
800 goto op_semantics_13;
801 break;
802 case 0xe0:
803 goto op_semantics_14;
804 break;
805 case 0xf0:
806 goto op_semantics_15;
807 break;
808 }
809 break;
810 case 0x02:
811 GETBYTE ();
812 switch (op[1] & 0xf0)
813 {
814 case 0x00:
815 goto op_semantics_1;
816 break;
817 case 0x10:
818 goto op_semantics_2;
819 break;
820 case 0x20:
821 goto op_semantics_3;
822 break;
823 case 0x30:
824 goto op_semantics_4;
825 break;
826 case 0x40:
827 case 0x50:
828 op_semantics_17:
829 {
830 /** 0000 bt10 010w dstr RLAM.A %c, %0 */
831 #line 535 "msp430-decode.opc"
832 int bt AU = (op[0] >> 2) & 0x03;
833 #line 535 "msp430-decode.opc"
834 int w AU = (op[1] >> 4) & 0x01;
835 #line 535 "msp430-decode.opc"
836 int dstr AU = op[1] & 0x0f;
837 if (trace)
838 {
839 printf ("\033[33m%s\033[0m %02x %02x\n",
840 "/** 0000 bt10 010w dstr RLAM.A %c, %0 */",
841 op[0], op[1]);
842 printf (" bt = 0x%x,", bt);
843 printf (" w = 0x%x,", w);
844 printf (" dstr = 0x%x\n", dstr);
845 }
846 SYNTAX("RLAM.A %c, %0");
847 #line 535 "msp430-decode.opc"
848 ID (MSO_add); DR (dstr); SR (dstr);
849 msp430->repeats = bt;
850 msp430->size = w ? 16 : 20;
851 msp430->ofs_430x = 1;
852 F_0NZC;
853
854 }
855 break;
856 case 0x60:
857 goto op_semantics_6;
858 break;
859 case 0x70:
860 goto op_semantics_7;
861 break;
862 case 0x80:
863 goto op_semantics_8;
864 break;
865 case 0x90:
866 goto op_semantics_9;
867 break;
868 case 0xa0:
869 goto op_semantics_10;
870 break;
871 case 0xb0:
872 goto op_semantics_11;
873 break;
874 case 0xc0:
875 goto op_semantics_12;
876 break;
877 case 0xd0:
878 goto op_semantics_13;
879 break;
880 case 0xe0:
881 goto op_semantics_14;
882 break;
883 case 0xf0:
884 goto op_semantics_15;
885 break;
886 }
887 break;
888 case 0x03:
889 GETBYTE ();
890 switch (op[1] & 0xf0)
891 {
892 case 0x00:
893 goto op_semantics_1;
894 break;
895 case 0x10:
896 goto op_semantics_2;
897 break;
898 case 0x20:
899 goto op_semantics_3;
900 break;
901 case 0x30:
902 goto op_semantics_4;
903 break;
904 case 0x40:
905 case 0x50:
906 op_semantics_18:
907 {
908 /** 0000 bt11 010w dstr RRUM.A %c, %0 */
909 #line 542 "msp430-decode.opc"
910 int bt AU = (op[0] >> 2) & 0x03;
911 #line 542 "msp430-decode.opc"
912 int w AU = (op[1] >> 4) & 0x01;
913 #line 542 "msp430-decode.opc"
914 int dstr AU = op[1] & 0x0f;
915 if (trace)
916 {
917 printf ("\033[33m%s\033[0m %02x %02x\n",
918 "/** 0000 bt11 010w dstr RRUM.A %c, %0 */",
919 op[0], op[1]);
920 printf (" bt = 0x%x,", bt);
921 printf (" w = 0x%x,", w);
922 printf (" dstr = 0x%x\n", dstr);
923 }
924 SYNTAX("RRUM.A %c, %0");
925 #line 542 "msp430-decode.opc"
926 ID (MSO_rru); DR (dstr); SR (dstr);
927 msp430->repeats = bt;
928 msp430->size = w ? 16 : 20;
929 msp430->ofs_430x = 1;
930 F_0NZC;
931
932 }
933 break;
934 case 0x60:
935 goto op_semantics_6;
936 break;
937 case 0x70:
938 goto op_semantics_7;
939 break;
940 case 0x80:
941 goto op_semantics_8;
942 break;
943 case 0x90:
944 goto op_semantics_9;
945 break;
946 case 0xa0:
947 goto op_semantics_10;
948 break;
949 case 0xb0:
950 goto op_semantics_11;
951 break;
952 case 0xc0:
953 goto op_semantics_12;
954 break;
955 case 0xd0:
956 goto op_semantics_13;
957 break;
958 case 0xe0:
959 goto op_semantics_14;
960 break;
961 case 0xf0:
962 goto op_semantics_15;
963 break;
964 }
965 break;
966 case 0x04:
967 GETBYTE ();
968 switch (op[1] & 0xf0)
969 {
970 case 0x00:
971 goto op_semantics_1;
972 break;
973 case 0x10:
974 goto op_semantics_2;
975 break;
976 case 0x20:
977 goto op_semantics_3;
978 break;
979 case 0x30:
980 goto op_semantics_4;
981 break;
982 case 0x40:
983 case 0x50:
984 goto op_semantics_5;
985 break;
986 case 0x60:
987 goto op_semantics_6;
988 break;
989 case 0x70:
990 goto op_semantics_7;
991 break;
992 case 0x80:
993 goto op_semantics_8;
994 break;
995 case 0x90:
996 goto op_semantics_9;
997 break;
998 case 0xa0:
999 goto op_semantics_10;
1000 break;
1001 case 0xb0:
1002 goto op_semantics_11;
1003 break;
1004 case 0xc0:
1005 goto op_semantics_12;
1006 break;
1007 case 0xd0:
1008 goto op_semantics_13;
1009 break;
1010 case 0xe0:
1011 goto op_semantics_14;
1012 break;
1013 case 0xf0:
1014 goto op_semantics_15;
1015 break;
1016 }
1017 break;
1018 case 0x05:
1019 GETBYTE ();
1020 switch (op[1] & 0xf0)
1021 {
1022 case 0x00:
1023 goto op_semantics_1;
1024 break;
1025 case 0x10:
1026 goto op_semantics_2;
1027 break;
1028 case 0x20:
1029 goto op_semantics_3;
1030 break;
1031 case 0x30:
1032 goto op_semantics_4;
1033 break;
1034 case 0x40:
1035 case 0x50:
1036 goto op_semantics_16;
1037 break;
1038 case 0x60:
1039 goto op_semantics_6;
1040 break;
1041 case 0x70:
1042 goto op_semantics_7;
1043 break;
1044 case 0x80:
1045 goto op_semantics_8;
1046 break;
1047 case 0x90:
1048 goto op_semantics_9;
1049 break;
1050 case 0xa0:
1051 goto op_semantics_10;
1052 break;
1053 case 0xb0:
1054 goto op_semantics_11;
1055 break;
1056 case 0xc0:
1057 goto op_semantics_12;
1058 break;
1059 case 0xd0:
1060 goto op_semantics_13;
1061 break;
1062 case 0xe0:
1063 goto op_semantics_14;
1064 break;
1065 case 0xf0:
1066 goto op_semantics_15;
1067 break;
1068 }
1069 break;
1070 case 0x06:
1071 GETBYTE ();
1072 switch (op[1] & 0xf0)
1073 {
1074 case 0x00:
1075 goto op_semantics_1;
1076 break;
1077 case 0x10:
1078 goto op_semantics_2;
1079 break;
1080 case 0x20:
1081 goto op_semantics_3;
1082 break;
1083 case 0x30:
1084 goto op_semantics_4;
1085 break;
1086 case 0x40:
1087 case 0x50:
1088 goto op_semantics_17;
1089 break;
1090 case 0x60:
1091 goto op_semantics_6;
1092 break;
1093 case 0x70:
1094 goto op_semantics_7;
1095 break;
1096 case 0x80:
1097 goto op_semantics_8;
1098 break;
1099 case 0x90:
1100 goto op_semantics_9;
1101 break;
1102 case 0xa0:
1103 goto op_semantics_10;
1104 break;
1105 case 0xb0:
1106 goto op_semantics_11;
1107 break;
1108 case 0xc0:
1109 goto op_semantics_12;
1110 break;
1111 case 0xd0:
1112 goto op_semantics_13;
1113 break;
1114 case 0xe0:
1115 goto op_semantics_14;
1116 break;
1117 case 0xf0:
1118 goto op_semantics_15;
1119 break;
1120 }
1121 break;
1122 case 0x07:
1123 GETBYTE ();
1124 switch (op[1] & 0xf0)
1125 {
1126 case 0x00:
1127 goto op_semantics_1;
1128 break;
1129 case 0x10:
1130 goto op_semantics_2;
1131 break;
1132 case 0x20:
1133 goto op_semantics_3;
1134 break;
1135 case 0x30:
1136 goto op_semantics_4;
1137 break;
1138 case 0x40:
1139 case 0x50:
1140 goto op_semantics_18;
1141 break;
1142 case 0x60:
1143 goto op_semantics_6;
1144 break;
1145 case 0x70:
1146 goto op_semantics_7;
1147 break;
1148 case 0x80:
1149 goto op_semantics_8;
1150 break;
1151 case 0x90:
1152 goto op_semantics_9;
1153 break;
1154 case 0xa0:
1155 goto op_semantics_10;
1156 break;
1157 case 0xb0:
1158 goto op_semantics_11;
1159 break;
1160 case 0xc0:
1161 goto op_semantics_12;
1162 break;
1163 case 0xd0:
1164 goto op_semantics_13;
1165 break;
1166 case 0xe0:
1167 goto op_semantics_14;
1168 break;
1169 case 0xf0:
1170 goto op_semantics_15;
1171 break;
1172 }
1173 break;
1174 case 0x08:
1175 GETBYTE ();
1176 switch (op[1] & 0xf0)
1177 {
1178 case 0x00:
1179 goto op_semantics_1;
1180 break;
1181 case 0x10:
1182 goto op_semantics_2;
1183 break;
1184 case 0x20:
1185 goto op_semantics_3;
1186 break;
1187 case 0x30:
1188 goto op_semantics_4;
1189 break;
1190 case 0x40:
1191 case 0x50:
1192 goto op_semantics_5;
1193 break;
1194 case 0x60:
1195 goto op_semantics_6;
1196 break;
1197 case 0x70:
1198 goto op_semantics_7;
1199 break;
1200 case 0x80:
1201 goto op_semantics_8;
1202 break;
1203 case 0x90:
1204 goto op_semantics_9;
1205 break;
1206 case 0xa0:
1207 goto op_semantics_10;
1208 break;
1209 case 0xb0:
1210 goto op_semantics_11;
1211 break;
1212 case 0xc0:
1213 goto op_semantics_12;
1214 break;
1215 case 0xd0:
1216 goto op_semantics_13;
1217 break;
1218 case 0xe0:
1219 goto op_semantics_14;
1220 break;
1221 case 0xf0:
1222 goto op_semantics_15;
1223 break;
1224 }
1225 break;
1226 case 0x09:
1227 GETBYTE ();
1228 switch (op[1] & 0xf0)
1229 {
1230 case 0x00:
1231 goto op_semantics_1;
1232 break;
1233 case 0x10:
1234 goto op_semantics_2;
1235 break;
1236 case 0x20:
1237 goto op_semantics_3;
1238 break;
1239 case 0x30:
1240 goto op_semantics_4;
1241 break;
1242 case 0x40:
1243 case 0x50:
1244 goto op_semantics_16;
1245 break;
1246 case 0x60:
1247 goto op_semantics_6;
1248 break;
1249 case 0x70:
1250 goto op_semantics_7;
1251 break;
1252 case 0x80:
1253 goto op_semantics_8;
1254 break;
1255 case 0x90:
1256 goto op_semantics_9;
1257 break;
1258 case 0xa0:
1259 goto op_semantics_10;
1260 break;
1261 case 0xb0:
1262 goto op_semantics_11;
1263 break;
1264 case 0xc0:
1265 goto op_semantics_12;
1266 break;
1267 case 0xd0:
1268 goto op_semantics_13;
1269 break;
1270 case 0xe0:
1271 goto op_semantics_14;
1272 break;
1273 case 0xf0:
1274 goto op_semantics_15;
1275 break;
1276 }
1277 break;
1278 case 0x0a:
1279 GETBYTE ();
1280 switch (op[1] & 0xf0)
1281 {
1282 case 0x00:
1283 goto op_semantics_1;
1284 break;
1285 case 0x10:
1286 goto op_semantics_2;
1287 break;
1288 case 0x20:
1289 goto op_semantics_3;
1290 break;
1291 case 0x30:
1292 goto op_semantics_4;
1293 break;
1294 case 0x40:
1295 case 0x50:
1296 goto op_semantics_17;
1297 break;
1298 case 0x60:
1299 goto op_semantics_6;
1300 break;
1301 case 0x70:
1302 goto op_semantics_7;
1303 break;
1304 case 0x80:
1305 goto op_semantics_8;
1306 break;
1307 case 0x90:
1308 goto op_semantics_9;
1309 break;
1310 case 0xa0:
1311 goto op_semantics_10;
1312 break;
1313 case 0xb0:
1314 goto op_semantics_11;
1315 break;
1316 case 0xc0:
1317 goto op_semantics_12;
1318 break;
1319 case 0xd0:
1320 goto op_semantics_13;
1321 break;
1322 case 0xe0:
1323 goto op_semantics_14;
1324 break;
1325 case 0xf0:
1326 goto op_semantics_15;
1327 break;
1328 }
1329 break;
1330 case 0x0b:
1331 GETBYTE ();
1332 switch (op[1] & 0xf0)
1333 {
1334 case 0x00:
1335 goto op_semantics_1;
1336 break;
1337 case 0x10:
1338 goto op_semantics_2;
1339 break;
1340 case 0x20:
1341 goto op_semantics_3;
1342 break;
1343 case 0x30:
1344 goto op_semantics_4;
1345 break;
1346 case 0x40:
1347 case 0x50:
1348 goto op_semantics_18;
1349 break;
1350 case 0x60:
1351 goto op_semantics_6;
1352 break;
1353 case 0x70:
1354 goto op_semantics_7;
1355 break;
1356 case 0x80:
1357 goto op_semantics_8;
1358 break;
1359 case 0x90:
1360 goto op_semantics_9;
1361 break;
1362 case 0xa0:
1363 goto op_semantics_10;
1364 break;
1365 case 0xb0:
1366 goto op_semantics_11;
1367 break;
1368 case 0xc0:
1369 goto op_semantics_12;
1370 break;
1371 case 0xd0:
1372 goto op_semantics_13;
1373 break;
1374 case 0xe0:
1375 goto op_semantics_14;
1376 break;
1377 case 0xf0:
1378 goto op_semantics_15;
1379 break;
1380 }
1381 break;
1382 case 0x0c:
1383 GETBYTE ();
1384 switch (op[1] & 0xf0)
1385 {
1386 case 0x00:
1387 goto op_semantics_1;
1388 break;
1389 case 0x10:
1390 goto op_semantics_2;
1391 break;
1392 case 0x20:
1393 goto op_semantics_3;
1394 break;
1395 case 0x30:
1396 goto op_semantics_4;
1397 break;
1398 case 0x40:
1399 case 0x50:
1400 goto op_semantics_5;
1401 break;
1402 case 0x60:
1403 goto op_semantics_6;
1404 break;
1405 case 0x70:
1406 goto op_semantics_7;
1407 break;
1408 case 0x80:
1409 goto op_semantics_8;
1410 break;
1411 case 0x90:
1412 goto op_semantics_9;
1413 break;
1414 case 0xa0:
1415 goto op_semantics_10;
1416 break;
1417 case 0xb0:
1418 goto op_semantics_11;
1419 break;
1420 case 0xc0:
1421 goto op_semantics_12;
1422 break;
1423 case 0xd0:
1424 goto op_semantics_13;
1425 break;
1426 case 0xe0:
1427 goto op_semantics_14;
1428 break;
1429 case 0xf0:
1430 goto op_semantics_15;
1431 break;
1432 }
1433 break;
1434 case 0x0d:
1435 GETBYTE ();
1436 switch (op[1] & 0xf0)
1437 {
1438 case 0x00:
1439 goto op_semantics_1;
1440 break;
1441 case 0x10:
1442 goto op_semantics_2;
1443 break;
1444 case 0x20:
1445 goto op_semantics_3;
1446 break;
1447 case 0x30:
1448 goto op_semantics_4;
1449 break;
1450 case 0x40:
1451 case 0x50:
1452 goto op_semantics_16;
1453 break;
1454 case 0x60:
1455 goto op_semantics_6;
1456 break;
1457 case 0x70:
1458 goto op_semantics_7;
1459 break;
1460 case 0x80:
1461 goto op_semantics_8;
1462 break;
1463 case 0x90:
1464 goto op_semantics_9;
1465 break;
1466 case 0xa0:
1467 goto op_semantics_10;
1468 break;
1469 case 0xb0:
1470 goto op_semantics_11;
1471 break;
1472 case 0xc0:
1473 goto op_semantics_12;
1474 break;
1475 case 0xd0:
1476 goto op_semantics_13;
1477 break;
1478 case 0xe0:
1479 goto op_semantics_14;
1480 break;
1481 case 0xf0:
1482 goto op_semantics_15;
1483 break;
1484 }
1485 break;
1486 case 0x0e:
1487 GETBYTE ();
1488 switch (op[1] & 0xf0)
1489 {
1490 case 0x00:
1491 goto op_semantics_1;
1492 break;
1493 case 0x10:
1494 goto op_semantics_2;
1495 break;
1496 case 0x20:
1497 goto op_semantics_3;
1498 break;
1499 case 0x30:
1500 goto op_semantics_4;
1501 break;
1502 case 0x40:
1503 case 0x50:
1504 goto op_semantics_17;
1505 break;
1506 case 0x60:
1507 goto op_semantics_6;
1508 break;
1509 case 0x70:
1510 goto op_semantics_7;
1511 break;
1512 case 0x80:
1513 goto op_semantics_8;
1514 break;
1515 case 0x90:
1516 goto op_semantics_9;
1517 break;
1518 case 0xa0:
1519 goto op_semantics_10;
1520 break;
1521 case 0xb0:
1522 goto op_semantics_11;
1523 break;
1524 case 0xc0:
1525 goto op_semantics_12;
1526 break;
1527 case 0xd0:
1528 goto op_semantics_13;
1529 break;
1530 case 0xe0:
1531 goto op_semantics_14;
1532 break;
1533 case 0xf0:
1534 goto op_semantics_15;
1535 break;
1536 }
1537 break;
1538 case 0x0f:
1539 GETBYTE ();
1540 switch (op[1] & 0xf0)
1541 {
1542 case 0x00:
1543 goto op_semantics_1;
1544 break;
1545 case 0x10:
1546 goto op_semantics_2;
1547 break;
1548 case 0x20:
1549 goto op_semantics_3;
1550 break;
1551 case 0x30:
1552 goto op_semantics_4;
1553 break;
1554 case 0x40:
1555 case 0x50:
1556 goto op_semantics_18;
1557 break;
1558 case 0x60:
1559 goto op_semantics_6;
1560 break;
1561 case 0x70:
1562 goto op_semantics_7;
1563 break;
1564 case 0x80:
1565 goto op_semantics_8;
1566 break;
1567 case 0x90:
1568 goto op_semantics_9;
1569 break;
1570 case 0xa0:
1571 goto op_semantics_10;
1572 break;
1573 case 0xb0:
1574 goto op_semantics_11;
1575 break;
1576 case 0xc0:
1577 goto op_semantics_12;
1578 break;
1579 case 0xd0:
1580 goto op_semantics_13;
1581 break;
1582 case 0xe0:
1583 goto op_semantics_14;
1584 break;
1585 case 0xf0:
1586 goto op_semantics_15;
1587 break;
1588 }
1589 break;
1590 case 0x10:
1591 GETBYTE ();
1592 switch (op[1] & 0x00)
1593 {
1594 case 0x00:
1595 op_semantics_19:
1596 {
1597 /** 0001 00so c b ad dreg %S%b %1 */
1598 #line 395 "msp430-decode.opc"
1599 int so AU = op[0] & 0x03;
1600 #line 395 "msp430-decode.opc"
1601 int c AU = (op[1] >> 7) & 0x01;
1602 #line 395 "msp430-decode.opc"
1603 int b AU = (op[1] >> 6) & 0x01;
1604 #line 395 "msp430-decode.opc"
1605 int ad AU = (op[1] >> 4) & 0x03;
1606 #line 395 "msp430-decode.opc"
1607 int dreg AU = op[1] & 0x0f;
1608 if (trace)
1609 {
1610 printf ("\033[33m%s\033[0m %02x %02x\n",
1611 "/** 0001 00so c b ad dreg %S%b %1 */",
1612 op[0], op[1]);
1613 printf (" so = 0x%x,", so);
1614 printf (" c = 0x%x,", c);
1615 printf (" b = 0x%x,", b);
1616 printf (" ad = 0x%x,", ad);
1617 printf (" dreg = 0x%x\n", dreg);
1618 }
1619 SYNTAX("%S%b %1");
1620 #line 395 "msp430-decode.opc"
1621
1622 ID (sopc_to_id (so,c)); ASX (dreg, ad, srxt_bits); ABW (al_bit, b);
1623
1624 if (ad == 0)
1625 REPZC (srxt_bits, dsxt_bits);
1626
1627 /* The helper functions encode for source, but it's
1628 both source and dest, with a few documented exceptions. */
1629 msp430->op[0] = msp430->op[1];
1630
1631 /* RETI ignores the operand. */
1632 if (msp430->id == MSO_reti)
1633 msp430->syntax = "%S";
1634
1635 switch (msp430->id)
1636 {
1637 case MSO_rrc: F_VNZC; break;
1638 case MSO_swpb: F_____; break;
1639 case MSO_rra: F_0NZC; break;
1640 case MSO_sxt: F_0NZC; break;
1641 case MSO_push: F_____; break;
1642 case MSO_call: F_____; break;
1643 case MSO_reti: F_VNZC; break;
1644 default: break;
1645 }
1646
1647 /* 20xx 0010 0000 ---- ----
1648 3cxx 0011 1100 ---- ----
1649 001j mp-- ---- ----. */
1650 }
1651 break;
1652 }
1653 break;
1654 case 0x11:
1655 GETBYTE ();
1656 switch (op[1] & 0x00)
1657 {
1658 case 0x00:
1659 goto op_semantics_19;
1660 break;
1661 }
1662 break;
1663 case 0x12:
1664 GETBYTE ();
1665 switch (op[1] & 0x00)
1666 {
1667 case 0x00:
1668 goto op_semantics_19;
1669 break;
1670 }
1671 break;
1672 case 0x13:
1673 GETBYTE ();
1674 switch (op[1] & 0xff)
1675 {
1676 case 0x00:
1677 {
1678 /** 0001 0011 0000 0000 RETI */
1679 if (trace)
1680 {
1681 printf ("\033[33m%s\033[0m %02x %02x\n",
1682 "/** 0001 0011 0000 0000 RETI */",
1683 op[0], op[1]);
1684 }
1685 SYNTAX("RETI");
1686 #line 549 "msp430-decode.opc"
1687 ID (MSO_reti);
1688 msp430->size = 20;
1689 msp430->ofs_430x = 1;
1690
1691 }
1692 break;
1693 case 0x01:
1694 case 0x02:
1695 case 0x03:
1696 case 0x04:
1697 case 0x05:
1698 case 0x06:
1699 case 0x07:
1700 case 0x08:
1701 case 0x09:
1702 case 0x0a:
1703 case 0x0b:
1704 case 0x0c:
1705 case 0x0d:
1706 case 0x0e:
1707 case 0x0f:
1708 case 0x10:
1709 case 0x11:
1710 case 0x12:
1711 case 0x13:
1712 case 0x14:
1713 case 0x15:
1714 case 0x16:
1715 case 0x17:
1716 case 0x18:
1717 case 0x19:
1718 case 0x1a:
1719 case 0x1b:
1720 case 0x1c:
1721 case 0x1d:
1722 case 0x1e:
1723 case 0x1f:
1724 case 0x20:
1725 case 0x21:
1726 case 0x22:
1727 case 0x23:
1728 case 0x24:
1729 case 0x25:
1730 case 0x26:
1731 case 0x27:
1732 case 0x28:
1733 case 0x29:
1734 case 0x2a:
1735 case 0x2b:
1736 case 0x2c:
1737 case 0x2d:
1738 case 0x2e:
1739 case 0x2f:
1740 case 0x30:
1741 case 0x31:
1742 case 0x32:
1743 case 0x33:
1744 case 0x34:
1745 case 0x35:
1746 case 0x36:
1747 case 0x37:
1748 case 0x38:
1749 case 0x39:
1750 case 0x3a:
1751 case 0x3b:
1752 case 0x3c:
1753 case 0x3d:
1754 case 0x3e:
1755 case 0x3f:
1756 case 0xa0:
1757 case 0xa1:
1758 case 0xa2:
1759 case 0xa3:
1760 case 0xa4:
1761 case 0xa5:
1762 case 0xa6:
1763 case 0xa7:
1764 case 0xa8:
1765 case 0xa9:
1766 case 0xaa:
1767 case 0xab:
1768 case 0xac:
1769 case 0xad:
1770 case 0xae:
1771 case 0xaf:
1772 case 0xc0:
1773 case 0xc1:
1774 case 0xc2:
1775 case 0xc3:
1776 case 0xc4:
1777 case 0xc5:
1778 case 0xc6:
1779 case 0xc7:
1780 case 0xc8:
1781 case 0xc9:
1782 case 0xca:
1783 case 0xcb:
1784 case 0xcc:
1785 case 0xcd:
1786 case 0xce:
1787 case 0xcf:
1788 case 0xd0:
1789 case 0xd1:
1790 case 0xd2:
1791 case 0xd3:
1792 case 0xd4:
1793 case 0xd5:
1794 case 0xd6:
1795 case 0xd7:
1796 case 0xd8:
1797 case 0xd9:
1798 case 0xda:
1799 case 0xdb:
1800 case 0xdc:
1801 case 0xdd:
1802 case 0xde:
1803 case 0xdf:
1804 case 0xe0:
1805 case 0xe1:
1806 case 0xe2:
1807 case 0xe3:
1808 case 0xe4:
1809 case 0xe5:
1810 case 0xe6:
1811 case 0xe7:
1812 case 0xe8:
1813 case 0xe9:
1814 case 0xea:
1815 case 0xeb:
1816 case 0xec:
1817 case 0xed:
1818 case 0xee:
1819 case 0xef:
1820 case 0xf0:
1821 case 0xf1:
1822 case 0xf2:
1823 case 0xf3:
1824 case 0xf4:
1825 case 0xf5:
1826 case 0xf6:
1827 case 0xf7:
1828 case 0xf8:
1829 case 0xf9:
1830 case 0xfa:
1831 case 0xfb:
1832 case 0xfc:
1833 case 0xfd:
1834 case 0xfe:
1835 case 0xff:
1836 goto op_semantics_19;
1837 break;
1838 case 0x40:
1839 case 0x41:
1840 case 0x42:
1841 case 0x43:
1842 case 0x44:
1843 case 0x45:
1844 case 0x46:
1845 case 0x47:
1846 case 0x48:
1847 case 0x49:
1848 case 0x4a:
1849 case 0x4b:
1850 case 0x4c:
1851 case 0x4d:
1852 case 0x4e:
1853 case 0x4f:
1854 case 0x50:
1855 case 0x51:
1856 case 0x52:
1857 case 0x53:
1858 case 0x54:
1859 case 0x55:
1860 case 0x56:
1861 case 0x57:
1862 case 0x58:
1863 case 0x59:
1864 case 0x5a:
1865 case 0x5b:
1866 case 0x5c:
1867 case 0x5d:
1868 case 0x5e:
1869 case 0x5f:
1870 case 0x60:
1871 case 0x61:
1872 case 0x62:
1873 case 0x63:
1874 case 0x64:
1875 case 0x65:
1876 case 0x66:
1877 case 0x67:
1878 case 0x68:
1879 case 0x69:
1880 case 0x6a:
1881 case 0x6b:
1882 case 0x6c:
1883 case 0x6d:
1884 case 0x6e:
1885 case 0x6f:
1886 case 0x70:
1887 case 0x71:
1888 case 0x72:
1889 case 0x73:
1890 case 0x74:
1891 case 0x75:
1892 case 0x76:
1893 case 0x77:
1894 case 0x78:
1895 case 0x79:
1896 case 0x7a:
1897 case 0x7b:
1898 case 0x7c:
1899 case 0x7d:
1900 case 0x7e:
1901 case 0x7f:
1902 {
1903 /** 0001 0011 01as dstr CALLA %0 */
1904 #line 554 "msp430-decode.opc"
1905 int as AU = (op[1] >> 4) & 0x03;
1906 #line 554 "msp430-decode.opc"
1907 int dstr AU = op[1] & 0x0f;
1908 if (trace)
1909 {
1910 printf ("\033[33m%s\033[0m %02x %02x\n",
1911 "/** 0001 0011 01as dstr CALLA %0 */",
1912 op[0], op[1]);
1913 printf (" as = 0x%x,", as);
1914 printf (" dstr = 0x%x\n", dstr);
1915 }
1916 SYNTAX("CALLA %0");
1917 #line 554 "msp430-decode.opc"
1918 ID (MSO_call); AS (dstr, as);
1919 msp430->size = 20;
1920 msp430->ofs_430x = 1;
1921
1922 }
1923 break;
1924 case 0x80:
1925 case 0x81:
1926 case 0x82:
1927 case 0x83:
1928 case 0x84:
1929 case 0x85:
1930 case 0x86:
1931 case 0x87:
1932 case 0x88:
1933 case 0x89:
1934 case 0x8a:
1935 case 0x8b:
1936 case 0x8c:
1937 case 0x8d:
1938 case 0x8e:
1939 case 0x8f:
1940 {
1941 /** 0001 0011 1000 extb CALLA %0 */
1942 #line 559 "msp430-decode.opc"
1943 int extb AU = op[1] & 0x0f;
1944 if (trace)
1945 {
1946 printf ("\033[33m%s\033[0m %02x %02x\n",
1947 "/** 0001 0011 1000 extb CALLA %0 */",
1948 op[0], op[1]);
1949 printf (" extb = 0x%x\n", extb);
1950 }
1951 SYNTAX("CALLA %0");
1952 #line 559 "msp430-decode.opc"
1953 ID (MSO_call); SA (IMMU(2) | (extb << 16));
1954 msp430->size = 20;
1955 msp430->ofs_430x = 1;
1956
1957 }
1958 break;
1959 case 0x90:
1960 case 0x91:
1961 case 0x92:
1962 case 0x93:
1963 case 0x94:
1964 case 0x95:
1965 case 0x96:
1966 case 0x97:
1967 case 0x98:
1968 case 0x99:
1969 case 0x9a:
1970 case 0x9b:
1971 case 0x9c:
1972 case 0x9d:
1973 case 0x9e:
1974 case 0x9f:
1975 {
1976 /** 0001 0011 1001 extb CALLA %0 */
1977 #line 564 "msp430-decode.opc"
1978 int extb AU = op[1] & 0x0f;
1979 if (trace)
1980 {
1981 printf ("\033[33m%s\033[0m %02x %02x\n",
1982 "/** 0001 0011 1001 extb CALLA %0 */",
1983 op[0], op[1]);
1984 printf (" extb = 0x%x\n", extb);
1985 }
1986 SYNTAX("CALLA %0");
1987 #line 564 "msp430-decode.opc"
1988 raddr = IMMU(2) | (extb << 16);
1989 if (raddr & 0x80000)
1990 raddr -= 0x100000;
1991 ID (MSO_call); SA (pc + raddr + msp430->n_bytes);
1992 msp430->size = 20;
1993 msp430->ofs_430x = 1;
1994
1995 }
1996 break;
1997 case 0xb0:
1998 case 0xb1:
1999 case 0xb2:
2000 case 0xb3:
2001 case 0xb4:
2002 case 0xb5:
2003 case 0xb6:
2004 case 0xb7:
2005 case 0xb8:
2006 case 0xb9:
2007 case 0xba:
2008 case 0xbb:
2009 case 0xbc:
2010 case 0xbd:
2011 case 0xbe:
2012 case 0xbf:
2013 {
2014 /** 0001 0011 1011 extb CALLA %0 */
2015 #line 572 "msp430-decode.opc"
2016 int extb AU = op[1] & 0x0f;
2017 if (trace)
2018 {
2019 printf ("\033[33m%s\033[0m %02x %02x\n",
2020 "/** 0001 0011 1011 extb CALLA %0 */",
2021 op[0], op[1]);
2022 printf (" extb = 0x%x\n", extb);
2023 }
2024 SYNTAX("CALLA %0");
2025 #line 572 "msp430-decode.opc"
2026 ID (MSO_call); SC (IMMU(2) | (extb << 16));
2027 msp430->size = 20;
2028 msp430->ofs_430x = 1;
2029
2030 }
2031 break;
2032 }
2033 break;
2034 case 0x14:
2035 GETBYTE ();
2036 switch (op[1] & 0x00)
2037 {
2038 case 0x00:
2039 op_semantics_20:
2040 {
2041 /** 0001 010w bits srcr PUSHM.A %0 */
2042 #line 577 "msp430-decode.opc"
2043 int w AU = op[0] & 0x01;
2044 #line 577 "msp430-decode.opc"
2045 int bits AU = (op[1] >> 4) & 0x0f;
2046 #line 577 "msp430-decode.opc"
2047 int srcr AU = op[1] & 0x0f;
2048 if (trace)
2049 {
2050 printf ("\033[33m%s\033[0m %02x %02x\n",
2051 "/** 0001 010w bits srcr PUSHM.A %0 */",
2052 op[0], op[1]);
2053 printf (" w = 0x%x,", w);
2054 printf (" bits = 0x%x,", bits);
2055 printf (" srcr = 0x%x\n", srcr);
2056 }
2057 SYNTAX("PUSHM.A %0");
2058 #line 577 "msp430-decode.opc"
2059 ID (MSO_push); SR (srcr);
2060 msp430->size = w ? 16 : 20;
2061 msp430->repeats = bits;
2062 msp430->ofs_430x = 1;
2063
2064 }
2065 break;
2066 }
2067 break;
2068 case 0x15:
2069 GETBYTE ();
2070 switch (op[1] & 0x00)
2071 {
2072 case 0x00:
2073 goto op_semantics_20;
2074 break;
2075 }
2076 break;
2077 case 0x16:
2078 GETBYTE ();
2079 switch (op[1] & 0x00)
2080 {
2081 case 0x00:
2082 op_semantics_21:
2083 {
2084 /** 0001 011w bits dstr POPM.A %0 */
2085 #line 583 "msp430-decode.opc"
2086 int w AU = op[0] & 0x01;
2087 #line 583 "msp430-decode.opc"
2088 int bits AU = (op[1] >> 4) & 0x0f;
2089 #line 583 "msp430-decode.opc"
2090 int dstr AU = op[1] & 0x0f;
2091 if (trace)
2092 {
2093 printf ("\033[33m%s\033[0m %02x %02x\n",
2094 "/** 0001 011w bits dstr POPM.A %0 */",
2095 op[0], op[1]);
2096 printf (" w = 0x%x,", w);
2097 printf (" bits = 0x%x,", bits);
2098 printf (" dstr = 0x%x\n", dstr);
2099 }
2100 SYNTAX("POPM.A %0");
2101 #line 583 "msp430-decode.opc"
2102 ID (MSO_pop); DR (dstr);
2103 msp430->size = w ? 16 : 20;
2104 msp430->repeats = bits;
2105 msp430->ofs_430x = 1;
2106
2107 }
2108 break;
2109 }
2110 break;
2111 case 0x17:
2112 GETBYTE ();
2113 switch (op[1] & 0x00)
2114 {
2115 case 0x00:
2116 goto op_semantics_21;
2117 break;
2118 }
2119 break;
2120 case 0x18:
2121 GETBYTE ();
2122 switch (op[1] & 0x30)
2123 {
2124 case 0x00:
2125 op_semantics_22:
2126 {
2127 /** 0001 1srx t l 00 dsxt 430x */
2128 #line 351 "msp430-decode.opc"
2129 int srx AU = op[0] & 0x07;
2130 #line 351 "msp430-decode.opc"
2131 int t AU = (op[1] >> 7) & 0x01;
2132 #line 351 "msp430-decode.opc"
2133 int l AU = (op[1] >> 6) & 0x01;
2134 #line 351 "msp430-decode.opc"
2135 int dsxt AU = op[1] & 0x0f;
2136 if (trace)
2137 {
2138 printf ("\033[33m%s\033[0m %02x %02x\n",
2139 "/** 0001 1srx t l 00 dsxt 430x */",
2140 op[0], op[1]);
2141 printf (" srx = 0x%x,", srx);
2142 printf (" t = 0x%x,", t);
2143 printf (" l = 0x%x,", l);
2144 printf (" dsxt = 0x%x\n", dsxt);
2145 }
2146 SYNTAX("430x");
2147 #line 351 "msp430-decode.opc"
2148
2149 al_bit = l;
2150 srxt_bits = srx * 2 + t;
2151 dsxt_bits = dsxt;
2152 op = op_buf + lds.op_ptr;
2153 msp430->ofs_430x = 1;
2154 goto post_extension_word;
2155
2156 /* double-op insns:
2157 opcode:4 sreg:4 Ad:1 BW:1 As:2 Dreg:4
2158
2159 single-op insn:
2160 opcode:9 BW:1 Ad:2 DSreg:4
2161
2162 jumps:
2163 opcode:3 Cond:3 pcrel:10. */
2164
2165 /* Double-Operand "opcode" fields. */
2166
2167 }
2168 break;
2169 default: UNSUPPORTED(); break;
2170 }
2171 break;
2172 case 0x19:
2173 GETBYTE ();
2174 switch (op[1] & 0x30)
2175 {
2176 case 0x00:
2177 goto op_semantics_22;
2178 break;
2179 default: UNSUPPORTED(); break;
2180 }
2181 break;
2182 case 0x1a:
2183 GETBYTE ();
2184 switch (op[1] & 0x30)
2185 {
2186 case 0x00:
2187 goto op_semantics_22;
2188 break;
2189 default: UNSUPPORTED(); break;
2190 }
2191 break;
2192 case 0x1b:
2193 GETBYTE ();
2194 switch (op[1] & 0x30)
2195 {
2196 case 0x00:
2197 goto op_semantics_22;
2198 break;
2199 default: UNSUPPORTED(); break;
2200 }
2201 break;
2202 case 0x1c:
2203 GETBYTE ();
2204 switch (op[1] & 0x30)
2205 {
2206 case 0x00:
2207 goto op_semantics_22;
2208 break;
2209 default: UNSUPPORTED(); break;
2210 }
2211 break;
2212 case 0x1d:
2213 GETBYTE ();
2214 switch (op[1] & 0x30)
2215 {
2216 case 0x00:
2217 goto op_semantics_22;
2218 break;
2219 default: UNSUPPORTED(); break;
2220 }
2221 break;
2222 case 0x1e:
2223 GETBYTE ();
2224 switch (op[1] & 0x30)
2225 {
2226 case 0x00:
2227 goto op_semantics_22;
2228 break;
2229 default: UNSUPPORTED(); break;
2230 }
2231 break;
2232 case 0x1f:
2233 GETBYTE ();
2234 switch (op[1] & 0x30)
2235 {
2236 case 0x00:
2237 goto op_semantics_22;
2238 break;
2239 default: UNSUPPORTED(); break;
2240 }
2241 break;
2242 case 0x20:
2243 GETBYTE ();
2244 switch (op[1] & 0x00)
2245 {
2246 case 0x00:
2247 op_semantics_23:
2248 {
2249 /** 001jmp aa addrlsbs %J %1 */
2250 #line 425 "msp430-decode.opc"
2251 int jmp AU = (op[0] >> 2) & 0x07;
2252 #line 425 "msp430-decode.opc"
2253 int aa AU = op[0] & 0x03;
2254 #line 425 "msp430-decode.opc"
2255 int addrlsbs AU = op[1];
2256 if (trace)
2257 {
2258 printf ("\033[33m%s\033[0m %02x %02x\n",
2259 "/** 001jmp aa addrlsbs %J %1 */",
2260 op[0], op[1]);
2261 printf (" jmp = 0x%x,", jmp);
2262 printf (" aa = 0x%x,", aa);
2263 printf (" addrlsbs = 0x%x\n", addrlsbs);
2264 }
2265 SYNTAX("%J %1");
2266 #line 425 "msp430-decode.opc"
2267
2268 raddr = (aa << 9) | (addrlsbs << 1);
2269 if (raddr & 0x400)
2270 raddr = raddr - 0x800;
2271 /* This is a pc-relative jump, but we don't use SM because that
2272 would load the target address from the memory at X(PC), not use
2273 PC+X *as* the address. So we use SC to use the address, not the
2274 data at that address. */
2275 ID (MSO_jmp); SC (pc + raddr + msp430->n_bytes);
2276 msp430->cond = jmp;
2277
2278 /* Extended instructions. */
2279
2280 }
2281 break;
2282 }
2283 break;
2284 case 0x21:
2285 GETBYTE ();
2286 switch (op[1] & 0x00)
2287 {
2288 case 0x00:
2289 goto op_semantics_23;
2290 break;
2291 }
2292 break;
2293 case 0x22:
2294 GETBYTE ();
2295 switch (op[1] & 0x00)
2296 {
2297 case 0x00:
2298 goto op_semantics_23;
2299 break;
2300 }
2301 break;
2302 case 0x23:
2303 GETBYTE ();
2304 switch (op[1] & 0x00)
2305 {
2306 case 0x00:
2307 goto op_semantics_23;
2308 break;
2309 }
2310 break;
2311 case 0x24:
2312 GETBYTE ();
2313 switch (op[1] & 0x00)
2314 {
2315 case 0x00:
2316 goto op_semantics_23;
2317 break;
2318 }
2319 break;
2320 case 0x25:
2321 GETBYTE ();
2322 switch (op[1] & 0x00)
2323 {
2324 case 0x00:
2325 goto op_semantics_23;
2326 break;
2327 }
2328 break;
2329 case 0x26:
2330 GETBYTE ();
2331 switch (op[1] & 0x00)
2332 {
2333 case 0x00:
2334 goto op_semantics_23;
2335 break;
2336 }
2337 break;
2338 case 0x27:
2339 GETBYTE ();
2340 switch (op[1] & 0x00)
2341 {
2342 case 0x00:
2343 goto op_semantics_23;
2344 break;
2345 }
2346 break;
2347 case 0x28:
2348 GETBYTE ();
2349 switch (op[1] & 0x00)
2350 {
2351 case 0x00:
2352 goto op_semantics_23;
2353 break;
2354 }
2355 break;
2356 case 0x29:
2357 GETBYTE ();
2358 switch (op[1] & 0x00)
2359 {
2360 case 0x00:
2361 goto op_semantics_23;
2362 break;
2363 }
2364 break;
2365 case 0x2a:
2366 GETBYTE ();
2367 switch (op[1] & 0x00)
2368 {
2369 case 0x00:
2370 goto op_semantics_23;
2371 break;
2372 }
2373 break;
2374 case 0x2b:
2375 GETBYTE ();
2376 switch (op[1] & 0x00)
2377 {
2378 case 0x00:
2379 goto op_semantics_23;
2380 break;
2381 }
2382 break;
2383 case 0x2c:
2384 GETBYTE ();
2385 switch (op[1] & 0x00)
2386 {
2387 case 0x00:
2388 goto op_semantics_23;
2389 break;
2390 }
2391 break;
2392 case 0x2d:
2393 GETBYTE ();
2394 switch (op[1] & 0x00)
2395 {
2396 case 0x00:
2397 goto op_semantics_23;
2398 break;
2399 }
2400 break;
2401 case 0x2e:
2402 GETBYTE ();
2403 switch (op[1] & 0x00)
2404 {
2405 case 0x00:
2406 goto op_semantics_23;
2407 break;
2408 }
2409 break;
2410 case 0x2f:
2411 GETBYTE ();
2412 switch (op[1] & 0x00)
2413 {
2414 case 0x00:
2415 goto op_semantics_23;
2416 break;
2417 }
2418 break;
2419 case 0x30:
2420 GETBYTE ();
2421 switch (op[1] & 0x00)
2422 {
2423 case 0x00:
2424 goto op_semantics_23;
2425 break;
2426 }
2427 break;
2428 case 0x31:
2429 GETBYTE ();
2430 switch (op[1] & 0x00)
2431 {
2432 case 0x00:
2433 goto op_semantics_23;
2434 break;
2435 }
2436 break;
2437 case 0x32:
2438 GETBYTE ();
2439 switch (op[1] & 0x00)
2440 {
2441 case 0x00:
2442 goto op_semantics_23;
2443 break;
2444 }
2445 break;
2446 case 0x33:
2447 GETBYTE ();
2448 switch (op[1] & 0x00)
2449 {
2450 case 0x00:
2451 goto op_semantics_23;
2452 break;
2453 }
2454 break;
2455 case 0x34:
2456 GETBYTE ();
2457 switch (op[1] & 0x00)
2458 {
2459 case 0x00:
2460 goto op_semantics_23;
2461 break;
2462 }
2463 break;
2464 case 0x35:
2465 GETBYTE ();
2466 switch (op[1] & 0x00)
2467 {
2468 case 0x00:
2469 goto op_semantics_23;
2470 break;
2471 }
2472 break;
2473 case 0x36:
2474 GETBYTE ();
2475 switch (op[1] & 0x00)
2476 {
2477 case 0x00:
2478 goto op_semantics_23;
2479 break;
2480 }
2481 break;
2482 case 0x37:
2483 GETBYTE ();
2484 switch (op[1] & 0x00)
2485 {
2486 case 0x00:
2487 goto op_semantics_23;
2488 break;
2489 }
2490 break;
2491 case 0x38:
2492 GETBYTE ();
2493 switch (op[1] & 0x00)
2494 {
2495 case 0x00:
2496 goto op_semantics_23;
2497 break;
2498 }
2499 break;
2500 case 0x39:
2501 GETBYTE ();
2502 switch (op[1] & 0x00)
2503 {
2504 case 0x00:
2505 goto op_semantics_23;
2506 break;
2507 }
2508 break;
2509 case 0x3a:
2510 GETBYTE ();
2511 switch (op[1] & 0x00)
2512 {
2513 case 0x00:
2514 goto op_semantics_23;
2515 break;
2516 }
2517 break;
2518 case 0x3b:
2519 GETBYTE ();
2520 switch (op[1] & 0x00)
2521 {
2522 case 0x00:
2523 goto op_semantics_23;
2524 break;
2525 }
2526 break;
2527 case 0x3c:
2528 GETBYTE ();
2529 switch (op[1] & 0x00)
2530 {
2531 case 0x00:
2532 goto op_semantics_23;
2533 break;
2534 }
2535 break;
2536 case 0x3d:
2537 GETBYTE ();
2538 switch (op[1] & 0x00)
2539 {
2540 case 0x00:
2541 goto op_semantics_23;
2542 break;
2543 }
2544 break;
2545 case 0x3e:
2546 GETBYTE ();
2547 switch (op[1] & 0x00)
2548 {
2549 case 0x00:
2550 goto op_semantics_23;
2551 break;
2552 }
2553 break;
2554 case 0x3f:
2555 GETBYTE ();
2556 switch (op[1] & 0x00)
2557 {
2558 case 0x00:
2559 goto op_semantics_23;
2560 break;
2561 }
2562 break;
2563 case 0x40:
2564 GETBYTE ();
2565 switch (op[1] & 0x00)
2566 {
2567 case 0x00:
2568 op_semantics_24:
2569 {
2570 /** dopc sreg a b as dreg %D%b %1,%0 */
2571 #line 372 "msp430-decode.opc"
2572 int dopc AU = (op[0] >> 4) & 0x0f;
2573 #line 372 "msp430-decode.opc"
2574 int sreg AU = op[0] & 0x0f;
2575 #line 372 "msp430-decode.opc"
2576 int a AU = (op[1] >> 7) & 0x01;
2577 #line 372 "msp430-decode.opc"
2578 int b AU = (op[1] >> 6) & 0x01;
2579 #line 372 "msp430-decode.opc"
2580 int as AU = (op[1] >> 4) & 0x03;
2581 #line 372 "msp430-decode.opc"
2582 int dreg AU = op[1] & 0x0f;
2583 if (trace)
2584 {
2585 printf ("\033[33m%s\033[0m %02x %02x\n",
2586 "/** dopc sreg a b as dreg %D%b %1,%0 */",
2587 op[0], op[1]);
2588 printf (" dopc = 0x%x,", dopc);
2589 printf (" sreg = 0x%x,", sreg);
2590 printf (" a = 0x%x,", a);
2591 printf (" b = 0x%x,", b);
2592 printf (" as = 0x%x,", as);
2593 printf (" dreg = 0x%x\n", dreg);
2594 }
2595 SYNTAX("%D%b %1,%0");
2596 #line 372 "msp430-decode.opc"
2597
2598 ID (dopc_to_id (dopc)); ASX (sreg, as, srxt_bits); ADX (dreg, a, dsxt_bits); ABW (al_bit, b);
2599 if (a == 0 && as == 0)
2600 REPZC (srxt_bits, dsxt_bits);
2601
2602 switch (msp430->id)
2603 {
2604 case MSO_mov: F_____; break;
2605 case MSO_add: F_VNZC; break;
2606 case MSO_addc: F_VNZC; break;
2607 case MSO_subc: F_VNZC; break;
2608 case MSO_sub: F_VNZC; break;
2609 case MSO_cmp: F_VNZC; break;
2610 case MSO_dadd: F_VNZC; break;
2611 case MSO_bit: F_0NZC; break;
2612 case MSO_bic: F_____; break;
2613 case MSO_bis: F_____; break;
2614 case MSO_xor: F_VNZC; break;
2615 case MSO_and: F_0NZC; break;
2616 default: break;
2617 }
2618
2619 }
2620 break;
2621 }
2622 break;
2623 case 0x41:
2624 GETBYTE ();
2625 switch (op[1] & 0x00)
2626 {
2627 case 0x00:
2628 goto op_semantics_24;
2629 break;
2630 }
2631 break;
2632 case 0x42:
2633 GETBYTE ();
2634 switch (op[1] & 0x00)
2635 {
2636 case 0x00:
2637 goto op_semantics_24;
2638 break;
2639 }
2640 break;
2641 case 0x43:
2642 GETBYTE ();
2643 switch (op[1] & 0x00)
2644 {
2645 case 0x00:
2646 goto op_semantics_24;
2647 break;
2648 }
2649 break;
2650 case 0x44:
2651 GETBYTE ();
2652 switch (op[1] & 0x00)
2653 {
2654 case 0x00:
2655 goto op_semantics_24;
2656 break;
2657 }
2658 break;
2659 case 0x45:
2660 GETBYTE ();
2661 switch (op[1] & 0x00)
2662 {
2663 case 0x00:
2664 goto op_semantics_24;
2665 break;
2666 }
2667 break;
2668 case 0x46:
2669 GETBYTE ();
2670 switch (op[1] & 0x00)
2671 {
2672 case 0x00:
2673 goto op_semantics_24;
2674 break;
2675 }
2676 break;
2677 case 0x47:
2678 GETBYTE ();
2679 switch (op[1] & 0x00)
2680 {
2681 case 0x00:
2682 goto op_semantics_24;
2683 break;
2684 }
2685 break;
2686 case 0x48:
2687 GETBYTE ();
2688 switch (op[1] & 0x00)
2689 {
2690 case 0x00:
2691 goto op_semantics_24;
2692 break;
2693 }
2694 break;
2695 case 0x49:
2696 GETBYTE ();
2697 switch (op[1] & 0x00)
2698 {
2699 case 0x00:
2700 goto op_semantics_24;
2701 break;
2702 }
2703 break;
2704 case 0x4a:
2705 GETBYTE ();
2706 switch (op[1] & 0x00)
2707 {
2708 case 0x00:
2709 goto op_semantics_24;
2710 break;
2711 }
2712 break;
2713 case 0x4b:
2714 GETBYTE ();
2715 switch (op[1] & 0x00)
2716 {
2717 case 0x00:
2718 goto op_semantics_24;
2719 break;
2720 }
2721 break;
2722 case 0x4c:
2723 GETBYTE ();
2724 switch (op[1] & 0x00)
2725 {
2726 case 0x00:
2727 goto op_semantics_24;
2728 break;
2729 }
2730 break;
2731 case 0x4d:
2732 GETBYTE ();
2733 switch (op[1] & 0x00)
2734 {
2735 case 0x00:
2736 goto op_semantics_24;
2737 break;
2738 }
2739 break;
2740 case 0x4e:
2741 GETBYTE ();
2742 switch (op[1] & 0x00)
2743 {
2744 case 0x00:
2745 goto op_semantics_24;
2746 break;
2747 }
2748 break;
2749 case 0x4f:
2750 GETBYTE ();
2751 switch (op[1] & 0x00)
2752 {
2753 case 0x00:
2754 goto op_semantics_24;
2755 break;
2756 }
2757 break;
2758 case 0x50:
2759 GETBYTE ();
2760 switch (op[1] & 0x00)
2761 {
2762 case 0x00:
2763 goto op_semantics_24;
2764 break;
2765 }
2766 break;
2767 case 0x51:
2768 GETBYTE ();
2769 switch (op[1] & 0x00)
2770 {
2771 case 0x00:
2772 goto op_semantics_24;
2773 break;
2774 }
2775 break;
2776 case 0x52:
2777 GETBYTE ();
2778 switch (op[1] & 0x00)
2779 {
2780 case 0x00:
2781 goto op_semantics_24;
2782 break;
2783 }
2784 break;
2785 case 0x53:
2786 GETBYTE ();
2787 switch (op[1] & 0x00)
2788 {
2789 case 0x00:
2790 goto op_semantics_24;
2791 break;
2792 }
2793 break;
2794 case 0x54:
2795 GETBYTE ();
2796 switch (op[1] & 0x00)
2797 {
2798 case 0x00:
2799 goto op_semantics_24;
2800 break;
2801 }
2802 break;
2803 case 0x55:
2804 GETBYTE ();
2805 switch (op[1] & 0x00)
2806 {
2807 case 0x00:
2808 goto op_semantics_24;
2809 break;
2810 }
2811 break;
2812 case 0x56:
2813 GETBYTE ();
2814 switch (op[1] & 0x00)
2815 {
2816 case 0x00:
2817 goto op_semantics_24;
2818 break;
2819 }
2820 break;
2821 case 0x57:
2822 GETBYTE ();
2823 switch (op[1] & 0x00)
2824 {
2825 case 0x00:
2826 goto op_semantics_24;
2827 break;
2828 }
2829 break;
2830 case 0x58:
2831 GETBYTE ();
2832 switch (op[1] & 0x00)
2833 {
2834 case 0x00:
2835 goto op_semantics_24;
2836 break;
2837 }
2838 break;
2839 case 0x59:
2840 GETBYTE ();
2841 switch (op[1] & 0x00)
2842 {
2843 case 0x00:
2844 goto op_semantics_24;
2845 break;
2846 }
2847 break;
2848 case 0x5a:
2849 GETBYTE ();
2850 switch (op[1] & 0x00)
2851 {
2852 case 0x00:
2853 goto op_semantics_24;
2854 break;
2855 }
2856 break;
2857 case 0x5b:
2858 GETBYTE ();
2859 switch (op[1] & 0x00)
2860 {
2861 case 0x00:
2862 goto op_semantics_24;
2863 break;
2864 }
2865 break;
2866 case 0x5c:
2867 GETBYTE ();
2868 switch (op[1] & 0x00)
2869 {
2870 case 0x00:
2871 goto op_semantics_24;
2872 break;
2873 }
2874 break;
2875 case 0x5d:
2876 GETBYTE ();
2877 switch (op[1] & 0x00)
2878 {
2879 case 0x00:
2880 goto op_semantics_24;
2881 break;
2882 }
2883 break;
2884 case 0x5e:
2885 GETBYTE ();
2886 switch (op[1] & 0x00)
2887 {
2888 case 0x00:
2889 goto op_semantics_24;
2890 break;
2891 }
2892 break;
2893 case 0x5f:
2894 GETBYTE ();
2895 switch (op[1] & 0x00)
2896 {
2897 case 0x00:
2898 goto op_semantics_24;
2899 break;
2900 }
2901 break;
2902 case 0x60:
2903 GETBYTE ();
2904 switch (op[1] & 0x00)
2905 {
2906 case 0x00:
2907 goto op_semantics_24;
2908 break;
2909 }
2910 break;
2911 case 0x61:
2912 GETBYTE ();
2913 switch (op[1] & 0x00)
2914 {
2915 case 0x00:
2916 goto op_semantics_24;
2917 break;
2918 }
2919 break;
2920 case 0x62:
2921 GETBYTE ();
2922 switch (op[1] & 0x00)
2923 {
2924 case 0x00:
2925 goto op_semantics_24;
2926 break;
2927 }
2928 break;
2929 case 0x63:
2930 GETBYTE ();
2931 switch (op[1] & 0x00)
2932 {
2933 case 0x00:
2934 goto op_semantics_24;
2935 break;
2936 }
2937 break;
2938 case 0x64:
2939 GETBYTE ();
2940 switch (op[1] & 0x00)
2941 {
2942 case 0x00:
2943 goto op_semantics_24;
2944 break;
2945 }
2946 break;
2947 case 0x65:
2948 GETBYTE ();
2949 switch (op[1] & 0x00)
2950 {
2951 case 0x00:
2952 goto op_semantics_24;
2953 break;
2954 }
2955 break;
2956 case 0x66:
2957 GETBYTE ();
2958 switch (op[1] & 0x00)
2959 {
2960 case 0x00:
2961 goto op_semantics_24;
2962 break;
2963 }
2964 break;
2965 case 0x67:
2966 GETBYTE ();
2967 switch (op[1] & 0x00)
2968 {
2969 case 0x00:
2970 goto op_semantics_24;
2971 break;
2972 }
2973 break;
2974 case 0x68:
2975 GETBYTE ();
2976 switch (op[1] & 0x00)
2977 {
2978 case 0x00:
2979 goto op_semantics_24;
2980 break;
2981 }
2982 break;
2983 case 0x69:
2984 GETBYTE ();
2985 switch (op[1] & 0x00)
2986 {
2987 case 0x00:
2988 goto op_semantics_24;
2989 break;
2990 }
2991 break;
2992 case 0x6a:
2993 GETBYTE ();
2994 switch (op[1] & 0x00)
2995 {
2996 case 0x00:
2997 goto op_semantics_24;
2998 break;
2999 }
3000 break;
3001 case 0x6b:
3002 GETBYTE ();
3003 switch (op[1] & 0x00)
3004 {
3005 case 0x00:
3006 goto op_semantics_24;
3007 break;
3008 }
3009 break;
3010 case 0x6c:
3011 GETBYTE ();
3012 switch (op[1] & 0x00)
3013 {
3014 case 0x00:
3015 goto op_semantics_24;
3016 break;
3017 }
3018 break;
3019 case 0x6d:
3020 GETBYTE ();
3021 switch (op[1] & 0x00)
3022 {
3023 case 0x00:
3024 goto op_semantics_24;
3025 break;
3026 }
3027 break;
3028 case 0x6e:
3029 GETBYTE ();
3030 switch (op[1] & 0x00)
3031 {
3032 case 0x00:
3033 goto op_semantics_24;
3034 break;
3035 }
3036 break;
3037 case 0x6f:
3038 GETBYTE ();
3039 switch (op[1] & 0x00)
3040 {
3041 case 0x00:
3042 goto op_semantics_24;
3043 break;
3044 }
3045 break;
3046 case 0x70:
3047 GETBYTE ();
3048 switch (op[1] & 0x00)
3049 {
3050 case 0x00:
3051 goto op_semantics_24;
3052 break;
3053 }
3054 break;
3055 case 0x71:
3056 GETBYTE ();
3057 switch (op[1] & 0x00)
3058 {
3059 case 0x00:
3060 goto op_semantics_24;
3061 break;
3062 }
3063 break;
3064 case 0x72:
3065 GETBYTE ();
3066 switch (op[1] & 0x00)
3067 {
3068 case 0x00:
3069 goto op_semantics_24;
3070 break;
3071 }
3072 break;
3073 case 0x73:
3074 GETBYTE ();
3075 switch (op[1] & 0x00)
3076 {
3077 case 0x00:
3078 goto op_semantics_24;
3079 break;
3080 }
3081 break;
3082 case 0x74:
3083 GETBYTE ();
3084 switch (op[1] & 0x00)
3085 {
3086 case 0x00:
3087 goto op_semantics_24;
3088 break;
3089 }
3090 break;
3091 case 0x75:
3092 GETBYTE ();
3093 switch (op[1] & 0x00)
3094 {
3095 case 0x00:
3096 goto op_semantics_24;
3097 break;
3098 }
3099 break;
3100 case 0x76:
3101 GETBYTE ();
3102 switch (op[1] & 0x00)
3103 {
3104 case 0x00:
3105 goto op_semantics_24;
3106 break;
3107 }
3108 break;
3109 case 0x77:
3110 GETBYTE ();
3111 switch (op[1] & 0x00)
3112 {
3113 case 0x00:
3114 goto op_semantics_24;
3115 break;
3116 }
3117 break;
3118 case 0x78:
3119 GETBYTE ();
3120 switch (op[1] & 0x00)
3121 {
3122 case 0x00:
3123 goto op_semantics_24;
3124 break;
3125 }
3126 break;
3127 case 0x79:
3128 GETBYTE ();
3129 switch (op[1] & 0x00)
3130 {
3131 case 0x00:
3132 goto op_semantics_24;
3133 break;
3134 }
3135 break;
3136 case 0x7a:
3137 GETBYTE ();
3138 switch (op[1] & 0x00)
3139 {
3140 case 0x00:
3141 goto op_semantics_24;
3142 break;
3143 }
3144 break;
3145 case 0x7b:
3146 GETBYTE ();
3147 switch (op[1] & 0x00)
3148 {
3149 case 0x00:
3150 goto op_semantics_24;
3151 break;
3152 }
3153 break;
3154 case 0x7c:
3155 GETBYTE ();
3156 switch (op[1] & 0x00)
3157 {
3158 case 0x00:
3159 goto op_semantics_24;
3160 break;
3161 }
3162 break;
3163 case 0x7d:
3164 GETBYTE ();
3165 switch (op[1] & 0x00)
3166 {
3167 case 0x00:
3168 goto op_semantics_24;
3169 break;
3170 }
3171 break;
3172 case 0x7e:
3173 GETBYTE ();
3174 switch (op[1] & 0x00)
3175 {
3176 case 0x00:
3177 goto op_semantics_24;
3178 break;
3179 }
3180 break;
3181 case 0x7f:
3182 GETBYTE ();
3183 switch (op[1] & 0x00)
3184 {
3185 case 0x00:
3186 goto op_semantics_24;
3187 break;
3188 }
3189 break;
3190 case 0x80:
3191 GETBYTE ();
3192 switch (op[1] & 0x00)
3193 {
3194 case 0x00:
3195 goto op_semantics_24;
3196 break;
3197 }
3198 break;
3199 case 0x81:
3200 GETBYTE ();
3201 switch (op[1] & 0x00)
3202 {
3203 case 0x00:
3204 goto op_semantics_24;
3205 break;
3206 }
3207 break;
3208 case 0x82:
3209 GETBYTE ();
3210 switch (op[1] & 0x00)
3211 {
3212 case 0x00:
3213 goto op_semantics_24;
3214 break;
3215 }
3216 break;
3217 case 0x83:
3218 GETBYTE ();
3219 switch (op[1] & 0x00)
3220 {
3221 case 0x00:
3222 goto op_semantics_24;
3223 break;
3224 }
3225 break;
3226 case 0x84:
3227 GETBYTE ();
3228 switch (op[1] & 0x00)
3229 {
3230 case 0x00:
3231 goto op_semantics_24;
3232 break;
3233 }
3234 break;
3235 case 0x85:
3236 GETBYTE ();
3237 switch (op[1] & 0x00)
3238 {
3239 case 0x00:
3240 goto op_semantics_24;
3241 break;
3242 }
3243 break;
3244 case 0x86:
3245 GETBYTE ();
3246 switch (op[1] & 0x00)
3247 {
3248 case 0x00:
3249 goto op_semantics_24;
3250 break;
3251 }
3252 break;
3253 case 0x87:
3254 GETBYTE ();
3255 switch (op[1] & 0x00)
3256 {
3257 case 0x00:
3258 goto op_semantics_24;
3259 break;
3260 }
3261 break;
3262 case 0x88:
3263 GETBYTE ();
3264 switch (op[1] & 0x00)
3265 {
3266 case 0x00:
3267 goto op_semantics_24;
3268 break;
3269 }
3270 break;
3271 case 0x89:
3272 GETBYTE ();
3273 switch (op[1] & 0x00)
3274 {
3275 case 0x00:
3276 goto op_semantics_24;
3277 break;
3278 }
3279 break;
3280 case 0x8a:
3281 GETBYTE ();
3282 switch (op[1] & 0x00)
3283 {
3284 case 0x00:
3285 goto op_semantics_24;
3286 break;
3287 }
3288 break;
3289 case 0x8b:
3290 GETBYTE ();
3291 switch (op[1] & 0x00)
3292 {
3293 case 0x00:
3294 goto op_semantics_24;
3295 break;
3296 }
3297 break;
3298 case 0x8c:
3299 GETBYTE ();
3300 switch (op[1] & 0x00)
3301 {
3302 case 0x00:
3303 goto op_semantics_24;
3304 break;
3305 }
3306 break;
3307 case 0x8d:
3308 GETBYTE ();
3309 switch (op[1] & 0x00)
3310 {
3311 case 0x00:
3312 goto op_semantics_24;
3313 break;
3314 }
3315 break;
3316 case 0x8e:
3317 GETBYTE ();
3318 switch (op[1] & 0x00)
3319 {
3320 case 0x00:
3321 goto op_semantics_24;
3322 break;
3323 }
3324 break;
3325 case 0x8f:
3326 GETBYTE ();
3327 switch (op[1] & 0x00)
3328 {
3329 case 0x00:
3330 goto op_semantics_24;
3331 break;
3332 }
3333 break;
3334 case 0x90:
3335 GETBYTE ();
3336 switch (op[1] & 0x00)
3337 {
3338 case 0x00:
3339 goto op_semantics_24;
3340 break;
3341 }
3342 break;
3343 case 0x91:
3344 GETBYTE ();
3345 switch (op[1] & 0x00)
3346 {
3347 case 0x00:
3348 goto op_semantics_24;
3349 break;
3350 }
3351 break;
3352 case 0x92:
3353 GETBYTE ();
3354 switch (op[1] & 0x00)
3355 {
3356 case 0x00:
3357 goto op_semantics_24;
3358 break;
3359 }
3360 break;
3361 case 0x93:
3362 GETBYTE ();
3363 switch (op[1] & 0x00)
3364 {
3365 case 0x00:
3366 goto op_semantics_24;
3367 break;
3368 }
3369 break;
3370 case 0x94:
3371 GETBYTE ();
3372 switch (op[1] & 0x00)
3373 {
3374 case 0x00:
3375 goto op_semantics_24;
3376 break;
3377 }
3378 break;
3379 case 0x95:
3380 GETBYTE ();
3381 switch (op[1] & 0x00)
3382 {
3383 case 0x00:
3384 goto op_semantics_24;
3385 break;
3386 }
3387 break;
3388 case 0x96:
3389 GETBYTE ();
3390 switch (op[1] & 0x00)
3391 {
3392 case 0x00:
3393 goto op_semantics_24;
3394 break;
3395 }
3396 break;
3397 case 0x97:
3398 GETBYTE ();
3399 switch (op[1] & 0x00)
3400 {
3401 case 0x00:
3402 goto op_semantics_24;
3403 break;
3404 }
3405 break;
3406 case 0x98:
3407 GETBYTE ();
3408 switch (op[1] & 0x00)
3409 {
3410 case 0x00:
3411 goto op_semantics_24;
3412 break;
3413 }
3414 break;
3415 case 0x99:
3416 GETBYTE ();
3417 switch (op[1] & 0x00)
3418 {
3419 case 0x00:
3420 goto op_semantics_24;
3421 break;
3422 }
3423 break;
3424 case 0x9a:
3425 GETBYTE ();
3426 switch (op[1] & 0x00)
3427 {
3428 case 0x00:
3429 goto op_semantics_24;
3430 break;
3431 }
3432 break;
3433 case 0x9b:
3434 GETBYTE ();
3435 switch (op[1] & 0x00)
3436 {
3437 case 0x00:
3438 goto op_semantics_24;
3439 break;
3440 }
3441 break;
3442 case 0x9c:
3443 GETBYTE ();
3444 switch (op[1] & 0x00)
3445 {
3446 case 0x00:
3447 goto op_semantics_24;
3448 break;
3449 }
3450 break;
3451 case 0x9d:
3452 GETBYTE ();
3453 switch (op[1] & 0x00)
3454 {
3455 case 0x00:
3456 goto op_semantics_24;
3457 break;
3458 }
3459 break;
3460 case 0x9e:
3461 GETBYTE ();
3462 switch (op[1] & 0x00)
3463 {
3464 case 0x00:
3465 goto op_semantics_24;
3466 break;
3467 }
3468 break;
3469 case 0x9f:
3470 GETBYTE ();
3471 switch (op[1] & 0x00)
3472 {
3473 case 0x00:
3474 goto op_semantics_24;
3475 break;
3476 }
3477 break;
3478 case 0xa0:
3479 GETBYTE ();
3480 switch (op[1] & 0x00)
3481 {
3482 case 0x00:
3483 goto op_semantics_24;
3484 break;
3485 }
3486 break;
3487 case 0xa1:
3488 GETBYTE ();
3489 switch (op[1] & 0x00)
3490 {
3491 case 0x00:
3492 goto op_semantics_24;
3493 break;
3494 }
3495 break;
3496 case 0xa2:
3497 GETBYTE ();
3498 switch (op[1] & 0x00)
3499 {
3500 case 0x00:
3501 goto op_semantics_24;
3502 break;
3503 }
3504 break;
3505 case 0xa3:
3506 GETBYTE ();
3507 switch (op[1] & 0x00)
3508 {
3509 case 0x00:
3510 goto op_semantics_24;
3511 break;
3512 }
3513 break;
3514 case 0xa4:
3515 GETBYTE ();
3516 switch (op[1] & 0x00)
3517 {
3518 case 0x00:
3519 goto op_semantics_24;
3520 break;
3521 }
3522 break;
3523 case 0xa5:
3524 GETBYTE ();
3525 switch (op[1] & 0x00)
3526 {
3527 case 0x00:
3528 goto op_semantics_24;
3529 break;
3530 }
3531 break;
3532 case 0xa6:
3533 GETBYTE ();
3534 switch (op[1] & 0x00)
3535 {
3536 case 0x00:
3537 goto op_semantics_24;
3538 break;
3539 }
3540 break;
3541 case 0xa7:
3542 GETBYTE ();
3543 switch (op[1] & 0x00)
3544 {
3545 case 0x00:
3546 goto op_semantics_24;
3547 break;
3548 }
3549 break;
3550 case 0xa8:
3551 GETBYTE ();
3552 switch (op[1] & 0x00)
3553 {
3554 case 0x00:
3555 goto op_semantics_24;
3556 break;
3557 }
3558 break;
3559 case 0xa9:
3560 GETBYTE ();
3561 switch (op[1] & 0x00)
3562 {
3563 case 0x00:
3564 goto op_semantics_24;
3565 break;
3566 }
3567 break;
3568 case 0xaa:
3569 GETBYTE ();
3570 switch (op[1] & 0x00)
3571 {
3572 case 0x00:
3573 goto op_semantics_24;
3574 break;
3575 }
3576 break;
3577 case 0xab:
3578 GETBYTE ();
3579 switch (op[1] & 0x00)
3580 {
3581 case 0x00:
3582 goto op_semantics_24;
3583 break;
3584 }
3585 break;
3586 case 0xac:
3587 GETBYTE ();
3588 switch (op[1] & 0x00)
3589 {
3590 case 0x00:
3591 goto op_semantics_24;
3592 break;
3593 }
3594 break;
3595 case 0xad:
3596 GETBYTE ();
3597 switch (op[1] & 0x00)
3598 {
3599 case 0x00:
3600 goto op_semantics_24;
3601 break;
3602 }
3603 break;
3604 case 0xae:
3605 GETBYTE ();
3606 switch (op[1] & 0x00)
3607 {
3608 case 0x00:
3609 goto op_semantics_24;
3610 break;
3611 }
3612 break;
3613 case 0xaf:
3614 GETBYTE ();
3615 switch (op[1] & 0x00)
3616 {
3617 case 0x00:
3618 goto op_semantics_24;
3619 break;
3620 }
3621 break;
3622 case 0xb0:
3623 GETBYTE ();
3624 switch (op[1] & 0x00)
3625 {
3626 case 0x00:
3627 goto op_semantics_24;
3628 break;
3629 }
3630 break;
3631 case 0xb1:
3632 GETBYTE ();
3633 switch (op[1] & 0x00)
3634 {
3635 case 0x00:
3636 goto op_semantics_24;
3637 break;
3638 }
3639 break;
3640 case 0xb2:
3641 GETBYTE ();
3642 switch (op[1] & 0x00)
3643 {
3644 case 0x00:
3645 goto op_semantics_24;
3646 break;
3647 }
3648 break;
3649 case 0xb3:
3650 GETBYTE ();
3651 switch (op[1] & 0x00)
3652 {
3653 case 0x00:
3654 goto op_semantics_24;
3655 break;
3656 }
3657 break;
3658 case 0xb4:
3659 GETBYTE ();
3660 switch (op[1] & 0x00)
3661 {
3662 case 0x00:
3663 goto op_semantics_24;
3664 break;
3665 }
3666 break;
3667 case 0xb5:
3668 GETBYTE ();
3669 switch (op[1] & 0x00)
3670 {
3671 case 0x00:
3672 goto op_semantics_24;
3673 break;
3674 }
3675 break;
3676 case 0xb6:
3677 GETBYTE ();
3678 switch (op[1] & 0x00)
3679 {
3680 case 0x00:
3681 goto op_semantics_24;
3682 break;
3683 }
3684 break;
3685 case 0xb7:
3686 GETBYTE ();
3687 switch (op[1] & 0x00)
3688 {
3689 case 0x00:
3690 goto op_semantics_24;
3691 break;
3692 }
3693 break;
3694 case 0xb8:
3695 GETBYTE ();
3696 switch (op[1] & 0x00)
3697 {
3698 case 0x00:
3699 goto op_semantics_24;
3700 break;
3701 }
3702 break;
3703 case 0xb9:
3704 GETBYTE ();
3705 switch (op[1] & 0x00)
3706 {
3707 case 0x00:
3708 goto op_semantics_24;
3709 break;
3710 }
3711 break;
3712 case 0xba:
3713 GETBYTE ();
3714 switch (op[1] & 0x00)
3715 {
3716 case 0x00:
3717 goto op_semantics_24;
3718 break;
3719 }
3720 break;
3721 case 0xbb:
3722 GETBYTE ();
3723 switch (op[1] & 0x00)
3724 {
3725 case 0x00:
3726 goto op_semantics_24;
3727 break;
3728 }
3729 break;
3730 case 0xbc:
3731 GETBYTE ();
3732 switch (op[1] & 0x00)
3733 {
3734 case 0x00:
3735 goto op_semantics_24;
3736 break;
3737 }
3738 break;
3739 case 0xbd:
3740 GETBYTE ();
3741 switch (op[1] & 0x00)
3742 {
3743 case 0x00:
3744 goto op_semantics_24;
3745 break;
3746 }
3747 break;
3748 case 0xbe:
3749 GETBYTE ();
3750 switch (op[1] & 0x00)
3751 {
3752 case 0x00:
3753 goto op_semantics_24;
3754 break;
3755 }
3756 break;
3757 case 0xbf:
3758 GETBYTE ();
3759 switch (op[1] & 0x00)
3760 {
3761 case 0x00:
3762 goto op_semantics_24;
3763 break;
3764 }
3765 break;
3766 case 0xc0:
3767 GETBYTE ();
3768 switch (op[1] & 0x00)
3769 {
3770 case 0x00:
3771 goto op_semantics_24;
3772 break;
3773 }
3774 break;
3775 case 0xc1:
3776 GETBYTE ();
3777 switch (op[1] & 0x00)
3778 {
3779 case 0x00:
3780 goto op_semantics_24;
3781 break;
3782 }
3783 break;
3784 case 0xc2:
3785 GETBYTE ();
3786 switch (op[1] & 0x00)
3787 {
3788 case 0x00:
3789 goto op_semantics_24;
3790 break;
3791 }
3792 break;
3793 case 0xc3:
3794 GETBYTE ();
3795 switch (op[1] & 0x00)
3796 {
3797 case 0x00:
3798 goto op_semantics_24;
3799 break;
3800 }
3801 break;
3802 case 0xc4:
3803 GETBYTE ();
3804 switch (op[1] & 0x00)
3805 {
3806 case 0x00:
3807 goto op_semantics_24;
3808 break;
3809 }
3810 break;
3811 case 0xc5:
3812 GETBYTE ();
3813 switch (op[1] & 0x00)
3814 {
3815 case 0x00:
3816 goto op_semantics_24;
3817 break;
3818 }
3819 break;
3820 case 0xc6:
3821 GETBYTE ();
3822 switch (op[1] & 0x00)
3823 {
3824 case 0x00:
3825 goto op_semantics_24;
3826 break;
3827 }
3828 break;
3829 case 0xc7:
3830 GETBYTE ();
3831 switch (op[1] & 0x00)
3832 {
3833 case 0x00:
3834 goto op_semantics_24;
3835 break;
3836 }
3837 break;
3838 case 0xc8:
3839 GETBYTE ();
3840 switch (op[1] & 0x00)
3841 {
3842 case 0x00:
3843 goto op_semantics_24;
3844 break;
3845 }
3846 break;
3847 case 0xc9:
3848 GETBYTE ();
3849 switch (op[1] & 0x00)
3850 {
3851 case 0x00:
3852 goto op_semantics_24;
3853 break;
3854 }
3855 break;
3856 case 0xca:
3857 GETBYTE ();
3858 switch (op[1] & 0x00)
3859 {
3860 case 0x00:
3861 goto op_semantics_24;
3862 break;
3863 }
3864 break;
3865 case 0xcb:
3866 GETBYTE ();
3867 switch (op[1] & 0x00)
3868 {
3869 case 0x00:
3870 goto op_semantics_24;
3871 break;
3872 }
3873 break;
3874 case 0xcc:
3875 GETBYTE ();
3876 switch (op[1] & 0x00)
3877 {
3878 case 0x00:
3879 goto op_semantics_24;
3880 break;
3881 }
3882 break;
3883 case 0xcd:
3884 GETBYTE ();
3885 switch (op[1] & 0x00)
3886 {
3887 case 0x00:
3888 goto op_semantics_24;
3889 break;
3890 }
3891 break;
3892 case 0xce:
3893 GETBYTE ();
3894 switch (op[1] & 0x00)
3895 {
3896 case 0x00:
3897 goto op_semantics_24;
3898 break;
3899 }
3900 break;
3901 case 0xcf:
3902 GETBYTE ();
3903 switch (op[1] & 0x00)
3904 {
3905 case 0x00:
3906 goto op_semantics_24;
3907 break;
3908 }
3909 break;
3910 case 0xd0:
3911 GETBYTE ();
3912 switch (op[1] & 0x00)
3913 {
3914 case 0x00:
3915 goto op_semantics_24;
3916 break;
3917 }
3918 break;
3919 case 0xd1:
3920 GETBYTE ();
3921 switch (op[1] & 0x00)
3922 {
3923 case 0x00:
3924 goto op_semantics_24;
3925 break;
3926 }
3927 break;
3928 case 0xd2:
3929 GETBYTE ();
3930 switch (op[1] & 0x00)
3931 {
3932 case 0x00:
3933 goto op_semantics_24;
3934 break;
3935 }
3936 break;
3937 case 0xd3:
3938 GETBYTE ();
3939 switch (op[1] & 0x00)
3940 {
3941 case 0x00:
3942 goto op_semantics_24;
3943 break;
3944 }
3945 break;
3946 case 0xd4:
3947 GETBYTE ();
3948 switch (op[1] & 0x00)
3949 {
3950 case 0x00:
3951 goto op_semantics_24;
3952 break;
3953 }
3954 break;
3955 case 0xd5:
3956 GETBYTE ();
3957 switch (op[1] & 0x00)
3958 {
3959 case 0x00:
3960 goto op_semantics_24;
3961 break;
3962 }
3963 break;
3964 case 0xd6:
3965 GETBYTE ();
3966 switch (op[1] & 0x00)
3967 {
3968 case 0x00:
3969 goto op_semantics_24;
3970 break;
3971 }
3972 break;
3973 case 0xd7:
3974 GETBYTE ();
3975 switch (op[1] & 0x00)
3976 {
3977 case 0x00:
3978 goto op_semantics_24;
3979 break;
3980 }
3981 break;
3982 case 0xd8:
3983 GETBYTE ();
3984 switch (op[1] & 0x00)
3985 {
3986 case 0x00:
3987 goto op_semantics_24;
3988 break;
3989 }
3990 break;
3991 case 0xd9:
3992 GETBYTE ();
3993 switch (op[1] & 0x00)
3994 {
3995 case 0x00:
3996 goto op_semantics_24;
3997 break;
3998 }
3999 break;
4000 case 0xda:
4001 GETBYTE ();
4002 switch (op[1] & 0x00)
4003 {
4004 case 0x00:
4005 goto op_semantics_24;
4006 break;
4007 }
4008 break;
4009 case 0xdb:
4010 GETBYTE ();
4011 switch (op[1] & 0x00)
4012 {
4013 case 0x00:
4014 goto op_semantics_24;
4015 break;
4016 }
4017 break;
4018 case 0xdc:
4019 GETBYTE ();
4020 switch (op[1] & 0x00)
4021 {
4022 case 0x00:
4023 goto op_semantics_24;
4024 break;
4025 }
4026 break;
4027 case 0xdd:
4028 GETBYTE ();
4029 switch (op[1] & 0x00)
4030 {
4031 case 0x00:
4032 goto op_semantics_24;
4033 break;
4034 }
4035 break;
4036 case 0xde:
4037 GETBYTE ();
4038 switch (op[1] & 0x00)
4039 {
4040 case 0x00:
4041 goto op_semantics_24;
4042 break;
4043 }
4044 break;
4045 case 0xdf:
4046 GETBYTE ();
4047 switch (op[1] & 0x00)
4048 {
4049 case 0x00:
4050 goto op_semantics_24;
4051 break;
4052 }
4053 break;
4054 case 0xe0:
4055 GETBYTE ();
4056 switch (op[1] & 0x00)
4057 {
4058 case 0x00:
4059 goto op_semantics_24;
4060 break;
4061 }
4062 break;
4063 case 0xe1:
4064 GETBYTE ();
4065 switch (op[1] & 0x00)
4066 {
4067 case 0x00:
4068 goto op_semantics_24;
4069 break;
4070 }
4071 break;
4072 case 0xe2:
4073 GETBYTE ();
4074 switch (op[1] & 0x00)
4075 {
4076 case 0x00:
4077 goto op_semantics_24;
4078 break;
4079 }
4080 break;
4081 case 0xe3:
4082 GETBYTE ();
4083 switch (op[1] & 0x00)
4084 {
4085 case 0x00:
4086 goto op_semantics_24;
4087 break;
4088 }
4089 break;
4090 case 0xe4:
4091 GETBYTE ();
4092 switch (op[1] & 0x00)
4093 {
4094 case 0x00:
4095 goto op_semantics_24;
4096 break;
4097 }
4098 break;
4099 case 0xe5:
4100 GETBYTE ();
4101 switch (op[1] & 0x00)
4102 {
4103 case 0x00:
4104 goto op_semantics_24;
4105 break;
4106 }
4107 break;
4108 case 0xe6:
4109 GETBYTE ();
4110 switch (op[1] & 0x00)
4111 {
4112 case 0x00:
4113 goto op_semantics_24;
4114 break;
4115 }
4116 break;
4117 case 0xe7:
4118 GETBYTE ();
4119 switch (op[1] & 0x00)
4120 {
4121 case 0x00:
4122 goto op_semantics_24;
4123 break;
4124 }
4125 break;
4126 case 0xe8:
4127 GETBYTE ();
4128 switch (op[1] & 0x00)
4129 {
4130 case 0x00:
4131 goto op_semantics_24;
4132 break;
4133 }
4134 break;
4135 case 0xe9:
4136 GETBYTE ();
4137 switch (op[1] & 0x00)
4138 {
4139 case 0x00:
4140 goto op_semantics_24;
4141 break;
4142 }
4143 break;
4144 case 0xea:
4145 GETBYTE ();
4146 switch (op[1] & 0x00)
4147 {
4148 case 0x00:
4149 goto op_semantics_24;
4150 break;
4151 }
4152 break;
4153 case 0xeb:
4154 GETBYTE ();
4155 switch (op[1] & 0x00)
4156 {
4157 case 0x00:
4158 goto op_semantics_24;
4159 break;
4160 }
4161 break;
4162 case 0xec:
4163 GETBYTE ();
4164 switch (op[1] & 0x00)
4165 {
4166 case 0x00:
4167 goto op_semantics_24;
4168 break;
4169 }
4170 break;
4171 case 0xed:
4172 GETBYTE ();
4173 switch (op[1] & 0x00)
4174 {
4175 case 0x00:
4176 goto op_semantics_24;
4177 break;
4178 }
4179 break;
4180 case 0xee:
4181 GETBYTE ();
4182 switch (op[1] & 0x00)
4183 {
4184 case 0x00:
4185 goto op_semantics_24;
4186 break;
4187 }
4188 break;
4189 case 0xef:
4190 GETBYTE ();
4191 switch (op[1] & 0x00)
4192 {
4193 case 0x00:
4194 goto op_semantics_24;
4195 break;
4196 }
4197 break;
4198 case 0xf0:
4199 GETBYTE ();
4200 switch (op[1] & 0x00)
4201 {
4202 case 0x00:
4203 goto op_semantics_24;
4204 break;
4205 }
4206 break;
4207 case 0xf1:
4208 GETBYTE ();
4209 switch (op[1] & 0x00)
4210 {
4211 case 0x00:
4212 goto op_semantics_24;
4213 break;
4214 }
4215 break;
4216 case 0xf2:
4217 GETBYTE ();
4218 switch (op[1] & 0x00)
4219 {
4220 case 0x00:
4221 goto op_semantics_24;
4222 break;
4223 }
4224 break;
4225 case 0xf3:
4226 GETBYTE ();
4227 switch (op[1] & 0x00)
4228 {
4229 case 0x00:
4230 goto op_semantics_24;
4231 break;
4232 }
4233 break;
4234 case 0xf4:
4235 GETBYTE ();
4236 switch (op[1] & 0x00)
4237 {
4238 case 0x00:
4239 goto op_semantics_24;
4240 break;
4241 }
4242 break;
4243 case 0xf5:
4244 GETBYTE ();
4245 switch (op[1] & 0x00)
4246 {
4247 case 0x00:
4248 goto op_semantics_24;
4249 break;
4250 }
4251 break;
4252 case 0xf6:
4253 GETBYTE ();
4254 switch (op[1] & 0x00)
4255 {
4256 case 0x00:
4257 goto op_semantics_24;
4258 break;
4259 }
4260 break;
4261 case 0xf7:
4262 GETBYTE ();
4263 switch (op[1] & 0x00)
4264 {
4265 case 0x00:
4266 goto op_semantics_24;
4267 break;
4268 }
4269 break;
4270 case 0xf8:
4271 GETBYTE ();
4272 switch (op[1] & 0x00)
4273 {
4274 case 0x00:
4275 goto op_semantics_24;
4276 break;
4277 }
4278 break;
4279 case 0xf9:
4280 GETBYTE ();
4281 switch (op[1] & 0x00)
4282 {
4283 case 0x00:
4284 goto op_semantics_24;
4285 break;
4286 }
4287 break;
4288 case 0xfa:
4289 GETBYTE ();
4290 switch (op[1] & 0x00)
4291 {
4292 case 0x00:
4293 goto op_semantics_24;
4294 break;
4295 }
4296 break;
4297 case 0xfb:
4298 GETBYTE ();
4299 switch (op[1] & 0x00)
4300 {
4301 case 0x00:
4302 goto op_semantics_24;
4303 break;
4304 }
4305 break;
4306 case 0xfc:
4307 GETBYTE ();
4308 switch (op[1] & 0x00)
4309 {
4310 case 0x00:
4311 goto op_semantics_24;
4312 break;
4313 }
4314 break;
4315 case 0xfd:
4316 GETBYTE ();
4317 switch (op[1] & 0x00)
4318 {
4319 case 0x00:
4320 goto op_semantics_24;
4321 break;
4322 }
4323 break;
4324 case 0xfe:
4325 GETBYTE ();
4326 switch (op[1] & 0x00)
4327 {
4328 case 0x00:
4329 goto op_semantics_24;
4330 break;
4331 }
4332 break;
4333 case 0xff:
4334 GETBYTE ();
4335 switch (op[1] & 0x00)
4336 {
4337 case 0x00:
4338 goto op_semantics_24;
4339 break;
4340 }
4341 break;
4342 }
4343 #line 589 "msp430-decode.opc"
4344
4345 return msp430->n_bytes;
4346 }
A mirror of the official binutils-gdb repository