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