Annotation of src/external/gpl3/binutils/dist/opcodes/msp430-decode.c, Revision 1.1.1.3.2.2
1.1.1.3.2.1 christos 1: /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */
1.1 christos 2: #line 1 "msp430-decode.opc"
3: /* -*- c -*- */
1.1.1.3.2.2! martin 4: /* Copyright (C) 2013-2020 Free Software Foundation, Inc.
1.1 christos 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>
1.1.1.3.2.1 christos 29: #include "bfd.h"
30: #include "opintl.h"
1.1 christos 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:
1.1.1.3.2.1 christos 146: opcodes_error_handler
147: (_("internal error: immediate() called with invalid byte count %d"),
148: bytes);
1.1 christos 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);
1.1.1.3 christos 243: break;
1.1 christos 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 */
1.1.1.3.2.1 christos 364: #line 440 "msp430-decode.opc"
1.1 christos 365: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 366: #line 440 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 377: #line 440 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 388: #line 445 "msp430-decode.opc"
1.1 christos 389: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 390: #line 445 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 401: #line 445 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 412: #line 450 "msp430-decode.opc"
1.1 christos 413: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 414: #line 450 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 425: #line 450 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 436: #line 455 "msp430-decode.opc"
1.1 christos 437: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 438: #line 455 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 449: #line 455 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 461: #line 522 "msp430-decode.opc"
1.1 christos 462: int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1 christos 463: #line 522 "msp430-decode.opc"
1.1 christos 464: int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1 christos 465: #line 522 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 477: #line 522 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 490: #line 460 "msp430-decode.opc"
1.1 christos 491: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 492: #line 460 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 503: #line 460 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 514: #line 465 "msp430-decode.opc"
1.1 christos 515: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 516: #line 465 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 527: #line 465 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 538: #line 470 "msp430-decode.opc"
1.1 christos 539: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 540: #line 470 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 551: #line 470 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 562: #line 475 "msp430-decode.opc"
1.1 christos 563: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 564: #line 475 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 575: #line 475 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 587: #line 481 "msp430-decode.opc"
1.1 christos 588: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 589: #line 481 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 600: #line 481 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 612: #line 487 "msp430-decode.opc"
1.1 christos 613: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 614: #line 487 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 625: #line 487 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 637: #line 499 "msp430-decode.opc"
1.1 christos 638: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 639: #line 499 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 650: #line 499 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 661: #line 504 "msp430-decode.opc"
1.1 christos 662: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 663: #line 504 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 674: #line 504 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 686: #line 510 "msp430-decode.opc"
1.1 christos 687: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 688: #line 510 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 699: #line 510 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 711: #line 516 "msp430-decode.opc"
1.1 christos 712: int srcr AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 713: #line 516 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 724: #line 516 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 755: #line 529 "msp430-decode.opc"
1.1 christos 756: int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1 christos 757: #line 529 "msp430-decode.opc"
1.1 christos 758: int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1 christos 759: #line 529 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 771: #line 529 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 833: #line 536 "msp430-decode.opc"
1.1 christos 834: int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1 christos 835: #line 536 "msp430-decode.opc"
1.1 christos 836: int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1 christos 837: #line 536 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 849: #line 536 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 911: #line 543 "msp430-decode.opc"
1.1 christos 912: int bt AU = (op[0] >> 2) & 0x03;
1.1.1.3.2.1 christos 913: #line 543 "msp430-decode.opc"
1.1 christos 914: int w AU = (op[1] >> 4) & 0x01;
1.1.1.3.2.1 christos 915: #line 543 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 927: #line 543 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 1600: #line 396 "msp430-decode.opc"
1.1 christos 1601: int so AU = op[0] & 0x03;
1.1.1.3.2.1 christos 1602: #line 396 "msp430-decode.opc"
1.1 christos 1603: int c AU = (op[1] >> 7) & 0x01;
1.1.1.3.2.1 christos 1604: #line 396 "msp430-decode.opc"
1.1 christos 1605: int b AU = (op[1] >> 6) & 0x01;
1.1.1.3.2.1 christos 1606: #line 396 "msp430-decode.opc"
1.1 christos 1607: int ad AU = (op[1] >> 4) & 0x03;
1.1.1.3.2.1 christos 1608: #line 396 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 1622: #line 396 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 1688: #line 550 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 1906: #line 555 "msp430-decode.opc"
1.1 christos 1907: int as AU = (op[1] >> 4) & 0x03;
1.1.1.3.2.1 christos 1908: #line 555 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 1919: #line 555 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 1944: #line 560 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 1954: #line 560 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 1979: #line 565 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 1989: #line 565 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 2017: #line 573 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 2027: #line 573 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 2044: #line 578 "msp430-decode.opc"
1.1 christos 2045: int w AU = op[0] & 0x01;
1.1.1.3.2.1 christos 2046: #line 578 "msp430-decode.opc"
1.1 christos 2047: int bits AU = (op[1] >> 4) & 0x0f;
1.1.1.3.2.1 christos 2048: #line 578 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 2060: #line 578 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 2087: #line 584 "msp430-decode.opc"
1.1 christos 2088: int w AU = op[0] & 0x01;
1.1.1.3.2.1 christos 2089: #line 584 "msp430-decode.opc"
1.1 christos 2090: int bits AU = (op[1] >> 4) & 0x0f;
1.1.1.3.2.1 christos 2091: #line 584 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 2103: #line 584 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 2130: #line 352 "msp430-decode.opc"
1.1 christos 2131: int srx AU = op[0] & 0x07;
1.1.1.3.2.1 christos 2132: #line 352 "msp430-decode.opc"
1.1 christos 2133: int t AU = (op[1] >> 7) & 0x01;
1.1.1.3.2.1 christos 2134: #line 352 "msp430-decode.opc"
1.1 christos 2135: int l AU = (op[1] >> 6) & 0x01;
1.1.1.3.2.1 christos 2136: #line 352 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 2149: #line 352 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 2252: #line 426 "msp430-decode.opc"
1.1 christos 2253: int jmp AU = (op[0] >> 2) & 0x07;
1.1.1.3.2.1 christos 2254: #line 426 "msp430-decode.opc"
1.1 christos 2255: int aa AU = op[0] & 0x03;
1.1.1.3.2.1 christos 2256: #line 426 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 2268: #line 426 "msp430-decode.opc"
1.1 christos 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 */
1.1.1.3.2.1 christos 2573: #line 373 "msp430-decode.opc"
1.1 christos 2574: int dopc AU = (op[0] >> 4) & 0x0f;
1.1.1.3.2.1 christos 2575: #line 373 "msp430-decode.opc"
1.1 christos 2576: int sreg AU = op[0] & 0x0f;
1.1.1.3.2.1 christos 2577: #line 373 "msp430-decode.opc"
1.1 christos 2578: int a AU = (op[1] >> 7) & 0x01;
1.1.1.3.2.1 christos 2579: #line 373 "msp430-decode.opc"
1.1 christos 2580: int b AU = (op[1] >> 6) & 0x01;
1.1.1.3.2.1 christos 2581: #line 373 "msp430-decode.opc"
1.1 christos 2582: int as AU = (op[1] >> 4) & 0x03;
1.1.1.3.2.1 christos 2583: #line 373 "msp430-decode.opc"
1.1 christos 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");
1.1.1.3.2.1 christos 2598: #line 373 "msp430-decode.opc"
1.1 christos 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: }
1.1.1.3.2.1 christos 4345: #line 590 "msp430-decode.opc"
1.1 christos 4346:
4347: return msp430->n_bytes;
4348: }
CVSweb <webmaster@jp.NetBSD.org>