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