Fix wrong source file name of cross-arm-binutils.
[platform/upstream/binutils.git] / gas / bfin-parse.c
1 /* A Bison parser, made by GNU Bison 2.3.  */
2
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
4
5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6    Free Software Foundation, Inc.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2, or (at your option)
11    any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
21    Boston, MA 02110-1301, USA.  */
22
23 /* As a special exception, you may create a larger work that contains
24    part or all of the Bison parser skeleton and distribute that work
25    under terms of your choice, so long as that work isn't itself a
26    parser generator using the skeleton or a modified version thereof
27    as a parser skeleton.  Alternatively, if you modify or redistribute
28    the parser skeleton itself, you may (at your option) remove this
29    special exception, which will cause the skeleton and the resulting
30    Bison output files to be licensed under the GNU General Public
31    License without this special exception.
32
33    This special exception was added by the Free Software Foundation in
34    version 2.2 of Bison.  */
35
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37    simplifying the original so-called "semantic" parser.  */
38
39 /* All symbols defined below should begin with yy or YY, to avoid
40    infringing on user name space.  This should be done even for local
41    variables, as they might otherwise be expanded by user macros.
42    There are some unavoidable exceptions within include files to
43    define necessary library symbols; they are noted "INFRINGES ON
44    USER NAME SPACE" below.  */
45
46 /* Identify Bison output.  */
47 #define YYBISON 1
48
49 /* Bison version.  */
50 #define YYBISON_VERSION "2.3"
51
52 /* Skeleton name.  */
53 #define YYSKELETON_NAME "yacc.c"
54
55 /* Pure parsers.  */
56 #define YYPURE 0
57
58 /* Using locations.  */
59 #define YYLSP_NEEDED 0
60
61
62
63 /* Tokens.  */
64 #ifndef YYTOKENTYPE
65 # define YYTOKENTYPE
66    /* Put the tokens into the symbol table, so that GDB and other debuggers
67       know about them.  */
68    enum yytokentype {
69      BYTEOP16P = 258,
70      BYTEOP16M = 259,
71      BYTEOP1P = 260,
72      BYTEOP2P = 261,
73      BYTEOP3P = 262,
74      BYTEUNPACK = 263,
75      BYTEPACK = 264,
76      PACK = 265,
77      SAA = 266,
78      ALIGN8 = 267,
79      ALIGN16 = 268,
80      ALIGN24 = 269,
81      VIT_MAX = 270,
82      EXTRACT = 271,
83      DEPOSIT = 272,
84      EXPADJ = 273,
85      SEARCH = 274,
86      ONES = 275,
87      SIGN = 276,
88      SIGNBITS = 277,
89      LINK = 278,
90      UNLINK = 279,
91      REG = 280,
92      PC = 281,
93      CCREG = 282,
94      BYTE_DREG = 283,
95      REG_A_DOUBLE_ZERO = 284,
96      REG_A_DOUBLE_ONE = 285,
97      A_ZERO_DOT_L = 286,
98      A_ZERO_DOT_H = 287,
99      A_ONE_DOT_L = 288,
100      A_ONE_DOT_H = 289,
101      HALF_REG = 290,
102      NOP = 291,
103      RTI = 292,
104      RTS = 293,
105      RTX = 294,
106      RTN = 295,
107      RTE = 296,
108      HLT = 297,
109      IDLE = 298,
110      STI = 299,
111      CLI = 300,
112      CSYNC = 301,
113      SSYNC = 302,
114      EMUEXCPT = 303,
115      RAISE = 304,
116      EXCPT = 305,
117      LSETUP = 306,
118      LOOP = 307,
119      LOOP_BEGIN = 308,
120      LOOP_END = 309,
121      DISALGNEXCPT = 310,
122      JUMP = 311,
123      JUMP_DOT_S = 312,
124      JUMP_DOT_L = 313,
125      CALL = 314,
126      ABORT = 315,
127      NOT = 316,
128      TILDA = 317,
129      BANG = 318,
130      AMPERSAND = 319,
131      BAR = 320,
132      PERCENT = 321,
133      CARET = 322,
134      BXOR = 323,
135      MINUS = 324,
136      PLUS = 325,
137      STAR = 326,
138      SLASH = 327,
139      NEG = 328,
140      MIN = 329,
141      MAX = 330,
142      ABS = 331,
143      DOUBLE_BAR = 332,
144      _PLUS_BAR_PLUS = 333,
145      _PLUS_BAR_MINUS = 334,
146      _MINUS_BAR_PLUS = 335,
147      _MINUS_BAR_MINUS = 336,
148      _MINUS_MINUS = 337,
149      _PLUS_PLUS = 338,
150      SHIFT = 339,
151      LSHIFT = 340,
152      ASHIFT = 341,
153      BXORSHIFT = 342,
154      _GREATER_GREATER_GREATER_THAN_ASSIGN = 343,
155      ROT = 344,
156      LESS_LESS = 345,
157      GREATER_GREATER = 346,
158      _GREATER_GREATER_GREATER = 347,
159      _LESS_LESS_ASSIGN = 348,
160      _GREATER_GREATER_ASSIGN = 349,
161      DIVS = 350,
162      DIVQ = 351,
163      ASSIGN = 352,
164      _STAR_ASSIGN = 353,
165      _BAR_ASSIGN = 354,
166      _CARET_ASSIGN = 355,
167      _AMPERSAND_ASSIGN = 356,
168      _MINUS_ASSIGN = 357,
169      _PLUS_ASSIGN = 358,
170      _ASSIGN_BANG = 359,
171      _LESS_THAN_ASSIGN = 360,
172      _ASSIGN_ASSIGN = 361,
173      GE = 362,
174      LT = 363,
175      LE = 364,
176      GT = 365,
177      LESS_THAN = 366,
178      FLUSHINV = 367,
179      FLUSH = 368,
180      IFLUSH = 369,
181      PREFETCH = 370,
182      PRNT = 371,
183      OUTC = 372,
184      WHATREG = 373,
185      TESTSET = 374,
186      ASL = 375,
187      ASR = 376,
188      B = 377,
189      W = 378,
190      NS = 379,
191      S = 380,
192      CO = 381,
193      SCO = 382,
194      TH = 383,
195      TL = 384,
196      BP = 385,
197      BREV = 386,
198      X = 387,
199      Z = 388,
200      M = 389,
201      MMOD = 390,
202      R = 391,
203      RND = 392,
204      RNDL = 393,
205      RNDH = 394,
206      RND12 = 395,
207      RND20 = 396,
208      V = 397,
209      LO = 398,
210      HI = 399,
211      BITTGL = 400,
212      BITCLR = 401,
213      BITSET = 402,
214      BITTST = 403,
215      BITMUX = 404,
216      DBGAL = 405,
217      DBGAH = 406,
218      DBGHALT = 407,
219      DBG = 408,
220      DBGA = 409,
221      DBGCMPLX = 410,
222      IF = 411,
223      COMMA = 412,
224      BY = 413,
225      COLON = 414,
226      SEMICOLON = 415,
227      RPAREN = 416,
228      LPAREN = 417,
229      LBRACK = 418,
230      RBRACK = 419,
231      STATUS_REG = 420,
232      MNOP = 421,
233      SYMBOL = 422,
234      NUMBER = 423,
235      GOT = 424,
236      GOT17M4 = 425,
237      FUNCDESC_GOT17M4 = 426,
238      AT = 427,
239      PLTPC = 428
240    };
241 #endif
242 /* Tokens.  */
243 #define BYTEOP16P 258
244 #define BYTEOP16M 259
245 #define BYTEOP1P 260
246 #define BYTEOP2P 261
247 #define BYTEOP3P 262
248 #define BYTEUNPACK 263
249 #define BYTEPACK 264
250 #define PACK 265
251 #define SAA 266
252 #define ALIGN8 267
253 #define ALIGN16 268
254 #define ALIGN24 269
255 #define VIT_MAX 270
256 #define EXTRACT 271
257 #define DEPOSIT 272
258 #define EXPADJ 273
259 #define SEARCH 274
260 #define ONES 275
261 #define SIGN 276
262 #define SIGNBITS 277
263 #define LINK 278
264 #define UNLINK 279
265 #define REG 280
266 #define PC 281
267 #define CCREG 282
268 #define BYTE_DREG 283
269 #define REG_A_DOUBLE_ZERO 284
270 #define REG_A_DOUBLE_ONE 285
271 #define A_ZERO_DOT_L 286
272 #define A_ZERO_DOT_H 287
273 #define A_ONE_DOT_L 288
274 #define A_ONE_DOT_H 289
275 #define HALF_REG 290
276 #define NOP 291
277 #define RTI 292
278 #define RTS 293
279 #define RTX 294
280 #define RTN 295
281 #define RTE 296
282 #define HLT 297
283 #define IDLE 298
284 #define STI 299
285 #define CLI 300
286 #define CSYNC 301
287 #define SSYNC 302
288 #define EMUEXCPT 303
289 #define RAISE 304
290 #define EXCPT 305
291 #define LSETUP 306
292 #define LOOP 307
293 #define LOOP_BEGIN 308
294 #define LOOP_END 309
295 #define DISALGNEXCPT 310
296 #define JUMP 311
297 #define JUMP_DOT_S 312
298 #define JUMP_DOT_L 313
299 #define CALL 314
300 #define ABORT 315
301 #define NOT 316
302 #define TILDA 317
303 #define BANG 318
304 #define AMPERSAND 319
305 #define BAR 320
306 #define PERCENT 321
307 #define CARET 322
308 #define BXOR 323
309 #define MINUS 324
310 #define PLUS 325
311 #define STAR 326
312 #define SLASH 327
313 #define NEG 328
314 #define MIN 329
315 #define MAX 330
316 #define ABS 331
317 #define DOUBLE_BAR 332
318 #define _PLUS_BAR_PLUS 333
319 #define _PLUS_BAR_MINUS 334
320 #define _MINUS_BAR_PLUS 335
321 #define _MINUS_BAR_MINUS 336
322 #define _MINUS_MINUS 337
323 #define _PLUS_PLUS 338
324 #define SHIFT 339
325 #define LSHIFT 340
326 #define ASHIFT 341
327 #define BXORSHIFT 342
328 #define _GREATER_GREATER_GREATER_THAN_ASSIGN 343
329 #define ROT 344
330 #define LESS_LESS 345
331 #define GREATER_GREATER 346
332 #define _GREATER_GREATER_GREATER 347
333 #define _LESS_LESS_ASSIGN 348
334 #define _GREATER_GREATER_ASSIGN 349
335 #define DIVS 350
336 #define DIVQ 351
337 #define ASSIGN 352
338 #define _STAR_ASSIGN 353
339 #define _BAR_ASSIGN 354
340 #define _CARET_ASSIGN 355
341 #define _AMPERSAND_ASSIGN 356
342 #define _MINUS_ASSIGN 357
343 #define _PLUS_ASSIGN 358
344 #define _ASSIGN_BANG 359
345 #define _LESS_THAN_ASSIGN 360
346 #define _ASSIGN_ASSIGN 361
347 #define GE 362
348 #define LT 363
349 #define LE 364
350 #define GT 365
351 #define LESS_THAN 366
352 #define FLUSHINV 367
353 #define FLUSH 368
354 #define IFLUSH 369
355 #define PREFETCH 370
356 #define PRNT 371
357 #define OUTC 372
358 #define WHATREG 373
359 #define TESTSET 374
360 #define ASL 375
361 #define ASR 376
362 #define B 377
363 #define W 378
364 #define NS 379
365 #define S 380
366 #define CO 381
367 #define SCO 382
368 #define TH 383
369 #define TL 384
370 #define BP 385
371 #define BREV 386
372 #define X 387
373 #define Z 388
374 #define M 389
375 #define MMOD 390
376 #define R 391
377 #define RND 392
378 #define RNDL 393
379 #define RNDH 394
380 #define RND12 395
381 #define RND20 396
382 #define V 397
383 #define LO 398
384 #define HI 399
385 #define BITTGL 400
386 #define BITCLR 401
387 #define BITSET 402
388 #define BITTST 403
389 #define BITMUX 404
390 #define DBGAL 405
391 #define DBGAH 406
392 #define DBGHALT 407
393 #define DBG 408
394 #define DBGA 409
395 #define DBGCMPLX 410
396 #define IF 411
397 #define COMMA 412
398 #define BY 413
399 #define COLON 414
400 #define SEMICOLON 415
401 #define RPAREN 416
402 #define LPAREN 417
403 #define LBRACK 418
404 #define RBRACK 419
405 #define STATUS_REG 420
406 #define MNOP 421
407 #define SYMBOL 422
408 #define NUMBER 423
409 #define GOT 424
410 #define GOT17M4 425
411 #define FUNCDESC_GOT17M4 426
412 #define AT 427
413 #define PLTPC 428
414
415
416
417
418 /* Copy the first part of user declarations.  */
419 #line 20 "bfin-parse.y"
420
421
422 #include "as.h"
423
424 #include "bfin-aux.h"  /* Opcode generating auxiliaries.  */
425 #include "libbfd.h"
426 #include "elf/common.h"
427 #include "elf/bfin.h"
428
429 #define DSP32ALU(aopcde, HL, dst1, dst0, src0, src1, s, x, aop) \
430         bfin_gen_dsp32alu (HL, aopcde, aop, s, x, dst0, dst1, src0, src1)
431
432 #define DSP32MAC(op1, MM, mmod, w1, P, h01, h11, h00, h10, dst, op0, src0, src1, w0) \
433         bfin_gen_dsp32mac (op1, MM, mmod, w1, P, h01, h11, h00, h10, op0, \
434                            dst, src0, src1, w0)
435
436 #define DSP32MULT(op1, MM, mmod, w1, P, h01, h11, h00, h10, dst, op0, src0, src1, w0) \
437         bfin_gen_dsp32mult (op1, MM, mmod, w1, P, h01, h11, h00, h10, op0, \
438                             dst, src0, src1, w0)
439
440 #define DSP32SHIFT(sopcde, dst0, src0, src1, sop, hls)  \
441         bfin_gen_dsp32shift (sopcde, dst0, src0, src1, sop, hls)
442
443 #define DSP32SHIFTIMM(sopcde, dst0, immag, src1, sop, hls)  \
444         bfin_gen_dsp32shiftimm (sopcde, dst0, immag, src1, sop, hls)
445
446 #define LDIMMHALF_R(reg, h, s, z, hword) \
447         bfin_gen_ldimmhalf (reg, h, s, z, hword, 1)
448
449 #define LDIMMHALF_R5(reg, h, s, z, hword) \
450         bfin_gen_ldimmhalf (reg, h, s, z, hword, 2)
451
452 #define LDSTIDXI(ptr, reg, w, sz, z, offset)  \
453         bfin_gen_ldstidxi (ptr, reg, w, sz, z, offset)
454
455 #define LDST(ptr, reg, aop, sz, z, w)  \
456         bfin_gen_ldst (ptr, reg, aop, sz, z, w)
457
458 #define LDSTII(ptr, reg, offset, w, op)  \
459         bfin_gen_ldstii (ptr, reg, offset, w, op)
460
461 #define DSPLDST(i, m, reg, aop, w) \
462         bfin_gen_dspldst (i, reg, aop, w, m)
463
464 #define LDSTPMOD(ptr, reg, idx, aop, w) \
465         bfin_gen_ldstpmod (ptr, reg, aop, w, idx)
466
467 #define LDSTIIFP(offset, reg, w)  \
468         bfin_gen_ldstiifp (reg, offset, w)
469
470 #define LOGI2OP(dst, src, opc) \
471         bfin_gen_logi2op (opc, src, dst.regno & CODE_MASK)
472
473 #define ALU2OP(dst, src, opc)  \
474         bfin_gen_alu2op (dst, src, opc)
475
476 #define BRCC(t, b, offset) \
477         bfin_gen_brcc (t, b, offset)
478
479 #define UJUMP(offset) \
480         bfin_gen_ujump (offset)
481
482 #define PROGCTRL(prgfunc, poprnd) \
483         bfin_gen_progctrl (prgfunc, poprnd)
484
485 #define PUSHPOPMULTIPLE(dr, pr, d, p, w) \
486         bfin_gen_pushpopmultiple (dr, pr, d, p, w)
487
488 #define PUSHPOPREG(reg, w) \
489         bfin_gen_pushpopreg (reg, w)
490
491 #define CALLA(addr, s)  \
492         bfin_gen_calla (addr, s)
493
494 #define LINKAGE(r, framesize) \
495         bfin_gen_linkage (r, framesize)
496
497 #define COMPI2OPD(dst, src, op)  \
498         bfin_gen_compi2opd (dst, src, op)
499
500 #define COMPI2OPP(dst, src, op)  \
501         bfin_gen_compi2opp (dst, src, op)
502
503 #define DAGMODIK(i, op)  \
504         bfin_gen_dagmodik (i, op)
505
506 #define DAGMODIM(i, m, op, br)  \
507         bfin_gen_dagmodim (i, m, op, br)
508
509 #define COMP3OP(dst, src0, src1, opc)   \
510         bfin_gen_comp3op (src0, src1, dst, opc)
511
512 #define PTR2OP(dst, src, opc)   \
513         bfin_gen_ptr2op (dst, src, opc)
514
515 #define CCFLAG(x, y, opc, i, g)  \
516         bfin_gen_ccflag (x, y, opc, i, g)
517
518 #define CCMV(src, dst, t) \
519         bfin_gen_ccmv (src, dst, t)
520
521 #define CACTRL(reg, a, op) \
522         bfin_gen_cactrl (reg, a, op)
523
524 #define LOOPSETUP(soffset, c, rop, eoffset, reg) \
525         bfin_gen_loopsetup (soffset, c, rop, eoffset, reg)
526
527 #define HL2(r1, r0)  (IS_H (r1) << 1 | IS_H (r0))
528 #define IS_RANGE(bits, expr, sign, mul)    \
529         value_match(expr, bits, sign, mul, 1)
530 #define IS_URANGE(bits, expr, sign, mul)    \
531         value_match(expr, bits, sign, mul, 0)
532 #define IS_CONST(expr) (expr->type == Expr_Node_Constant)
533 #define IS_RELOC(expr) (expr->type != Expr_Node_Constant)
534 #define IS_IMM(expr, bits)  value_match (expr, bits, 0, 1, 1)
535 #define IS_UIMM(expr, bits)  value_match (expr, bits, 0, 1, 0)
536
537 #define IS_PCREL4(expr) \
538         (value_match (expr, 4, 0, 2, 0))
539
540 #define IS_LPPCREL10(expr) \
541         (value_match (expr, 10, 0, 2, 0))
542
543 #define IS_PCREL10(expr) \
544         (value_match (expr, 10, 0, 2, 1))
545
546 #define IS_PCREL12(expr) \
547         (value_match (expr, 12, 0, 2, 1))
548
549 #define IS_PCREL24(expr) \
550         (value_match (expr, 24, 0, 2, 1))
551
552
553 static int value_match (Expr_Node *, int, int, int, int);
554
555 extern FILE *errorf;
556 extern INSTR_T insn;
557
558 static Expr_Node *binary (Expr_Op_Type, Expr_Node *, Expr_Node *);
559 static Expr_Node *unary  (Expr_Op_Type, Expr_Node *);
560
561 static void notethat (char *, ...);
562
563 char *current_inputline;
564 extern char *yytext;
565 int yyerror (char *);
566
567 /* Used to set SRCx fields to all 1s as described in the PRM.  */
568 static Register reg7 = {REG_R7, 0};
569
570 void error (char *format, ...)
571 {
572     va_list ap;
573     static char buffer[2000];
574
575     va_start (ap, format);
576     vsprintf (buffer, format, ap);
577     va_end (ap);
578
579     as_bad ("%s", buffer);
580 }
581
582 int
583 yyerror (char *msg)
584 {
585   if (msg[0] == '\0')
586     error ("%s", msg);
587
588   else if (yytext[0] != ';')
589     error ("%s. Input text was %s.", msg, yytext);
590   else
591     error ("%s.", msg);
592
593   return -1;
594 }
595
596 static int
597 in_range_p (Expr_Node *exp, int from, int to, unsigned int mask)
598 {
599   int val = EXPR_VALUE (exp);
600   if (exp->type != Expr_Node_Constant)
601     return 0;
602   if (val < from || val > to)
603     return 0;
604   return (val & mask) == 0;
605 }
606
607 extern int yylex (void);
608
609 #define imm3(x) EXPR_VALUE (x)
610 #define imm4(x) EXPR_VALUE (x)
611 #define uimm4(x) EXPR_VALUE (x)
612 #define imm5(x) EXPR_VALUE (x)
613 #define uimm5(x) EXPR_VALUE (x)
614 #define imm6(x) EXPR_VALUE (x)
615 #define imm7(x) EXPR_VALUE (x)
616 #define uimm8(x) EXPR_VALUE (x)
617 #define imm16(x) EXPR_VALUE (x)
618 #define uimm16s4(x) ((EXPR_VALUE (x)) >> 2)
619 #define uimm16(x) EXPR_VALUE (x)
620
621 /* Return true if a value is inside a range.  */
622 #define IN_RANGE(x, low, high) \
623   (((EXPR_VALUE(x)) >= (low)) && (EXPR_VALUE(x)) <= ((high)))
624
625 /* Auxiliary functions.  */
626
627 static int
628 valid_dreg_pair (Register *reg1, Expr_Node *reg2)
629 {
630   if (!IS_DREG (*reg1))
631     {
632       yyerror ("Dregs expected");
633       return 0;
634     }
635
636   if (reg1->regno != 1 && reg1->regno != 3)
637     {
638       yyerror ("Bad register pair");
639       return 0;
640     }
641
642   if (imm7 (reg2) != reg1->regno - 1)
643     {
644       yyerror ("Bad register pair");
645       return 0;
646     }
647
648   reg1->regno--;
649   return 1;
650 }
651
652 static int
653 check_multiply_halfregs (Macfunc *aa, Macfunc *ab)
654 {
655   if ((!REG_EQUAL (aa->s0, ab->s0) && !REG_EQUAL (aa->s0, ab->s1))
656       || (!REG_EQUAL (aa->s1, ab->s1) && !REG_EQUAL (aa->s1, ab->s0)))
657     return yyerror ("Source multiplication register mismatch");
658
659   return 0;
660 }
661
662
663 /* Check mac option.  */
664
665 static int
666 check_macfunc_option (Macfunc *a, Opt_mode *opt)
667 {
668   /* Default option is always valid.  */
669   if (opt->mod == 0)
670     return 0;
671
672   if ((a->w == 1 && a->P == 1
673        && opt->mod != M_FU && opt->mod != M_IS && opt->mod != M_IU
674        && opt->mod != M_S2RND && opt->mod != M_ISS2)
675       || (a->w == 1 && a->P == 0
676           && opt->mod != M_FU && opt->mod != M_IS && opt->mod != M_IU
677           && opt->mod != M_T && opt->mod != M_TFU && opt->mod != M_S2RND
678           && opt->mod != M_ISS2 && opt->mod != M_IH)
679       || (a->w == 0 && a->P == 0
680           && opt->mod != M_FU && opt->mod != M_IS && opt->mod != M_W32))
681     return -1;
682
683   return 0;
684 }
685
686 /* Check (vector) mac funcs and ops.  */
687
688 static int
689 check_macfuncs (Macfunc *aa, Opt_mode *opa,
690                 Macfunc *ab, Opt_mode *opb)
691 {
692   /* Variables for swapping.  */
693   Macfunc mtmp;
694   Opt_mode otmp;
695
696   /* The option mode should be put at the end of the second instruction
697      of the vector except M, which should follow MAC1 instruction.  */
698   if (opa->mod != 0)
699     return yyerror ("Bad opt mode");
700
701   /* If a0macfunc comes before a1macfunc, swap them.  */
702
703   if (aa->n == 0)
704     {
705       /*  (M) is not allowed here.  */
706       if (opa->MM != 0)
707         return yyerror ("(M) not allowed with A0MAC");
708       if (ab->n != 1)
709         return yyerror ("Vector AxMACs can't be same");
710
711       mtmp = *aa; *aa = *ab; *ab = mtmp;
712       otmp = *opa; *opa = *opb; *opb = otmp;
713     }
714   else
715     {
716       if (opb->MM != 0)
717         return yyerror ("(M) not allowed with A0MAC");
718       if (ab->n != 0)
719         return yyerror ("Vector AxMACs can't be same");
720     }
721
722   /*  If both ops are one of 0, 1, or 2, we have multiply_halfregs in both
723   assignment_or_macfuncs.  */
724   if ((aa->op == 0 || aa->op == 1 || aa->op == 2)
725       && (ab->op == 0 || ab->op == 1 || ab->op == 2))
726     {
727       if (check_multiply_halfregs (aa, ab) < 0)
728         return -1;
729     }
730   else
731     {
732       /*  Only one of the assign_macfuncs has a half reg multiply
733       Evil trick: Just 'OR' their source register codes:
734       We can do that, because we know they were initialized to 0
735       in the rules that don't use multiply_halfregs.  */
736       aa->s0.regno |= (ab->s0.regno & CODE_MASK);
737       aa->s1.regno |= (ab->s1.regno & CODE_MASK);
738     }
739
740   if (aa->w == ab->w && aa->P != ab->P)
741     return yyerror ("Destination Dreg sizes (full or half) must match");
742
743   if (aa->w && ab->w)
744     {
745       if (aa->P && (aa->dst.regno - ab->dst.regno) != 1)
746         return yyerror ("Destination Dregs (full) must differ by one");
747       if (!aa->P && aa->dst.regno != ab->dst.regno)
748         return yyerror ("Destination Dregs (half) must match");
749     }
750
751   /* Make sure mod flags get ORed, too.  */
752   opb->mod |= opa->mod;
753
754   /* Check option.  */
755   if (check_macfunc_option (aa, opb) < 0
756       && check_macfunc_option (ab, opb) < 0)
757     return yyerror ("bad option");
758
759   /* Make sure first macfunc has got both P flags ORed.  */
760   aa->P |= ab->P;
761
762   return 0;
763 }
764
765
766 static int
767 is_group1 (INSTR_T x)
768 {
769   /* Group1 is dpsLDST, LDSTpmod, LDST, LDSTiiFP, LDSTii.  */
770   if ((x->value & 0xc000) == 0x8000 || (x->value == 0x0000))
771     return 1;
772
773   return 0;
774 }
775
776 static int
777 is_group2 (INSTR_T x)
778 {
779   if ((((x->value & 0xfc00) == 0x9c00)  /* dspLDST.  */
780        && !((x->value & 0xfde0) == 0x9c60)  /* dagMODim.  */
781        && !((x->value & 0xfde0) == 0x9ce0)  /* dagMODim with bit rev.  */
782        && !((x->value & 0xfde0) == 0x9d60)) /* pick dagMODik.  */
783       || (x->value == 0x0000))
784     return 1;
785   return 0;
786 }
787
788 static int
789 is_store (INSTR_T x)
790 {
791   if (!x)
792     return 0;
793
794   if ((x->value & 0xf000) == 0x8000)
795     {
796       int aop = ((x->value >> 9) & 0x3);
797       int w = ((x->value >> 11) & 0x1);
798       if (!w || aop == 3)
799         return 0;
800       return 1;
801     }
802
803   if (((x->value & 0xFF60) == 0x9E60) ||  /* dagMODim_0 */
804       ((x->value & 0xFFF0) == 0x9F60))    /* dagMODik_0 */
805     return 0;
806
807   /* decode_dspLDST_0 */
808   if ((x->value & 0xFC00) == 0x9C00)
809     {
810       int w = ((x->value >> 9) & 0x1);
811       if (w)
812         return 1;
813     }
814
815   return 0;
816 }
817
818 static INSTR_T
819 gen_multi_instr_1 (INSTR_T dsp32, INSTR_T dsp16_grp1, INSTR_T dsp16_grp2)
820 {
821   int mask1 = dsp32 ? insn_regmask (dsp32->value, dsp32->next->value) : 0;
822   int mask2 = dsp16_grp1 ? insn_regmask (dsp16_grp1->value, 0) : 0;
823   int mask3 = dsp16_grp2 ? insn_regmask (dsp16_grp2->value, 0) : 0;
824
825   if ((mask1 & mask2) || (mask1 & mask3) || (mask2 & mask3))
826     yyerror ("resource conflict in multi-issue instruction");
827
828   /* Anomaly 05000074 */
829   if (ENABLE_AC_05000074
830       && dsp32 != NULL && dsp16_grp1 != NULL
831       && (dsp32->value & 0xf780) == 0xc680
832       && ((dsp16_grp1->value & 0xfe40) == 0x9240
833           || (dsp16_grp1->value & 0xfe08) == 0xba08
834           || (dsp16_grp1->value & 0xfc00) == 0xbc00))
835     yyerror ("anomaly 05000074 - Multi-Issue Instruction with \
836 dsp32shiftimm in slot1 and P-reg Store in slot2 Not Supported");
837
838   if (is_store (dsp16_grp1) && is_store (dsp16_grp2))
839     yyerror ("Only one instruction in multi-issue instruction can be a store");
840
841   return bfin_gen_multi_instr (dsp32, dsp16_grp1, dsp16_grp2);
842 }
843
844
845
846 /* Enabling traces.  */
847 #ifndef YYDEBUG
848 # define YYDEBUG 0
849 #endif
850
851 /* Enabling verbose error messages.  */
852 #ifdef YYERROR_VERBOSE
853 # undef YYERROR_VERBOSE
854 # define YYERROR_VERBOSE 1
855 #else
856 # define YYERROR_VERBOSE 0
857 #endif
858
859 /* Enabling the token table.  */
860 #ifndef YYTOKEN_TABLE
861 # define YYTOKEN_TABLE 0
862 #endif
863
864 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
865 typedef union YYSTYPE
866 #line 446 "bfin-parse.y"
867 {
868   INSTR_T instr;
869   Expr_Node *expr;
870   SYMBOL_T symbol;
871   long value;
872   Register reg;
873   Macfunc macfunc;
874   struct { int r0; int s0; int x0; int aop; } modcodes;
875   struct { int r0; } r0;
876   Opt_mode mod;
877 }
878 /* Line 193 of yacc.c.  */
879 #line 880 "bfin-parse.c"
880         YYSTYPE;
881 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
882 # define YYSTYPE_IS_DECLARED 1
883 # define YYSTYPE_IS_TRIVIAL 1
884 #endif
885
886
887
888 /* Copy the second part of user declarations.  */
889
890
891 /* Line 216 of yacc.c.  */
892 #line 893 "bfin-parse.c"
893
894 #ifdef short
895 # undef short
896 #endif
897
898 #ifdef YYTYPE_UINT8
899 typedef YYTYPE_UINT8 yytype_uint8;
900 #else
901 typedef unsigned char yytype_uint8;
902 #endif
903
904 #ifdef YYTYPE_INT8
905 typedef YYTYPE_INT8 yytype_int8;
906 #elif (defined __STDC__ || defined __C99__FUNC__ \
907      || defined __cplusplus || defined _MSC_VER)
908 typedef signed char yytype_int8;
909 #else
910 typedef short int yytype_int8;
911 #endif
912
913 #ifdef YYTYPE_UINT16
914 typedef YYTYPE_UINT16 yytype_uint16;
915 #else
916 typedef unsigned short int yytype_uint16;
917 #endif
918
919 #ifdef YYTYPE_INT16
920 typedef YYTYPE_INT16 yytype_int16;
921 #else
922 typedef short int yytype_int16;
923 #endif
924
925 #ifndef YYSIZE_T
926 # ifdef __SIZE_TYPE__
927 #  define YYSIZE_T __SIZE_TYPE__
928 # elif defined size_t
929 #  define YYSIZE_T size_t
930 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
931      || defined __cplusplus || defined _MSC_VER)
932 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
933 #  define YYSIZE_T size_t
934 # else
935 #  define YYSIZE_T unsigned int
936 # endif
937 #endif
938
939 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
940
941 #ifndef YY_
942 # if defined YYENABLE_NLS && YYENABLE_NLS
943 #  if ENABLE_NLS
944 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
945 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
946 #  endif
947 # endif
948 # ifndef YY_
949 #  define YY_(msgid) msgid
950 # endif
951 #endif
952
953 /* Suppress unused-variable warnings by "using" E.  */
954 #if ! defined lint || defined __GNUC__
955 # define YYUSE(e) ((void) (e))
956 #else
957 # define YYUSE(e) /* empty */
958 #endif
959
960 /* Identity function, used to suppress warnings about constant conditions.  */
961 #ifndef lint
962 # define YYID(n) (n)
963 #else
964 #if (defined __STDC__ || defined __C99__FUNC__ \
965      || defined __cplusplus || defined _MSC_VER)
966 static int
967 YYID (int i)
968 #else
969 static int
970 YYID (i)
971     int i;
972 #endif
973 {
974   return i;
975 }
976 #endif
977
978 #if ! defined yyoverflow || YYERROR_VERBOSE
979
980 /* The parser invokes alloca or malloc; define the necessary symbols.  */
981
982 # ifdef YYSTACK_USE_ALLOCA
983 #  if YYSTACK_USE_ALLOCA
984 #   ifdef __GNUC__
985 #    define YYSTACK_ALLOC __builtin_alloca
986 #   elif defined __BUILTIN_VA_ARG_INCR
987 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
988 #   elif defined _AIX
989 #    define YYSTACK_ALLOC __alloca
990 #   elif defined _MSC_VER
991 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
992 #    define alloca _alloca
993 #   else
994 #    define YYSTACK_ALLOC alloca
995 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
996      || defined __cplusplus || defined _MSC_VER)
997 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
998 #     ifndef _STDLIB_H
999 #      define _STDLIB_H 1
1000 #     endif
1001 #    endif
1002 #   endif
1003 #  endif
1004 # endif
1005
1006 # ifdef YYSTACK_ALLOC
1007    /* Pacify GCC's `empty if-body' warning.  */
1008 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
1009 #  ifndef YYSTACK_ALLOC_MAXIMUM
1010     /* The OS might guarantee only one guard page at the bottom of the stack,
1011        and a page size can be as small as 4096 bytes.  So we cannot safely
1012        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
1013        to allow for a few compiler-allocated temporary stack slots.  */
1014 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1015 #  endif
1016 # else
1017 #  define YYSTACK_ALLOC YYMALLOC
1018 #  define YYSTACK_FREE YYFREE
1019 #  ifndef YYSTACK_ALLOC_MAXIMUM
1020 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1021 #  endif
1022 #  if (defined __cplusplus && ! defined _STDLIB_H \
1023        && ! ((defined YYMALLOC || defined malloc) \
1024              && (defined YYFREE || defined free)))
1025 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1026 #   ifndef _STDLIB_H
1027 #    define _STDLIB_H 1
1028 #   endif
1029 #  endif
1030 #  ifndef YYMALLOC
1031 #   define YYMALLOC malloc
1032 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1033      || defined __cplusplus || defined _MSC_VER)
1034 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1035 #   endif
1036 #  endif
1037 #  ifndef YYFREE
1038 #   define YYFREE free
1039 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
1040      || defined __cplusplus || defined _MSC_VER)
1041 void free (void *); /* INFRINGES ON USER NAME SPACE */
1042 #   endif
1043 #  endif
1044 # endif
1045 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1046
1047
1048 #if (! defined yyoverflow \
1049      && (! defined __cplusplus \
1050          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1051
1052 /* A type that is properly aligned for any stack member.  */
1053 union yyalloc
1054 {
1055   yytype_int16 yyss;
1056   YYSTYPE yyvs;
1057   };
1058
1059 /* The size of the maximum gap between one aligned stack and the next.  */
1060 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1061
1062 /* The size of an array large to enough to hold all stacks, each with
1063    N elements.  */
1064 # define YYSTACK_BYTES(N) \
1065      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1066       + YYSTACK_GAP_MAXIMUM)
1067
1068 /* Copy COUNT objects from FROM to TO.  The source and destination do
1069    not overlap.  */
1070 # ifndef YYCOPY
1071 #  if defined __GNUC__ && 1 < __GNUC__
1072 #   define YYCOPY(To, From, Count) \
1073       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1074 #  else
1075 #   define YYCOPY(To, From, Count)              \
1076       do                                        \
1077         {                                       \
1078           YYSIZE_T yyi;                         \
1079           for (yyi = 0; yyi < (Count); yyi++)   \
1080             (To)[yyi] = (From)[yyi];            \
1081         }                                       \
1082       while (YYID (0))
1083 #  endif
1084 # endif
1085
1086 /* Relocate STACK from its old location to the new one.  The
1087    local variables YYSIZE and YYSTACKSIZE give the old and new number of
1088    elements in the stack, and YYPTR gives the new location of the
1089    stack.  Advance YYPTR to a properly aligned location for the next
1090    stack.  */
1091 # define YYSTACK_RELOCATE(Stack)                                        \
1092     do                                                                  \
1093       {                                                                 \
1094         YYSIZE_T yynewbytes;                                            \
1095         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
1096         Stack = &yyptr->Stack;                                          \
1097         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
1098         yyptr += yynewbytes / sizeof (*yyptr);                          \
1099       }                                                                 \
1100     while (YYID (0))
1101
1102 #endif
1103
1104 /* YYFINAL -- State number of the termination state.  */
1105 #define YYFINAL  156
1106 /* YYLAST -- Last index in YYTABLE.  */
1107 #define YYLAST   1309
1108
1109 /* YYNTOKENS -- Number of terminals.  */
1110 #define YYNTOKENS  174
1111 /* YYNNTS -- Number of nonterminals.  */
1112 #define YYNNTS  47
1113 /* YYNRULES -- Number of rules.  */
1114 #define YYNRULES  354
1115 /* YYNRULES -- Number of states.  */
1116 #define YYNSTATES  1021
1117
1118 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
1119 #define YYUNDEFTOK  2
1120 #define YYMAXUTOK   428
1121
1122 #define YYTRANSLATE(YYX)                                                \
1123   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1124
1125 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
1126 static const yytype_uint8 yytranslate[] =
1127 {
1128        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1129        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1130        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1131        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1132        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1133        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1134        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1135        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1136        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1137        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1138        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1139        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1140        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1141        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1142        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1143        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1144        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1145        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1146        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1147        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1148        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1149        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1150        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1151        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1152        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
1153        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
1154        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
1155       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1156       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
1157       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
1158       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
1159       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
1160       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
1161       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
1162       85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
1163       95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
1164      105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
1165      115,   116,   117,   118,   119,   120,   121,   122,   123,   124,
1166      125,   126,   127,   128,   129,   130,   131,   132,   133,   134,
1167      135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
1168      145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
1169      155,   156,   157,   158,   159,   160,   161,   162,   163,   164,
1170      165,   166,   167,   168,   169,   170,   171,   172,   173
1171 };
1172
1173 #if YYDEBUG
1174 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1175    YYRHS.  */
1176 static const yytype_uint16 yyprhs[] =
1177 {
1178        0,     0,     3,     4,     6,     9,    16,    21,    23,    25,
1179       28,    34,    36,    43,    50,    54,    58,    76,    94,   106,
1180      118,   130,   143,   156,   169,   175,   179,   183,   187,   196,
1181      210,   223,   237,   251,   260,   278,   285,   295,   299,   306,
1182      310,   316,   323,   332,   341,   344,   347,   352,   356,   359,
1183      364,   368,   375,   380,   388,   396,   400,   404,   411,   415,
1184      420,   424,   428,   432,   444,   456,   466,   472,   478,   488,
1185      494,   500,   507,   514,   520,   526,   532,   539,   546,   552,
1186      554,   558,   562,   566,   570,   575,   580,   590,   600,   606,
1187      614,   619,   626,   633,   641,   651,   660,   669,   681,   691,
1188      696,   702,   709,   717,   724,   729,   736,   742,   749,   756,
1189      761,   770,   781,   792,   805,   811,   818,   824,   831,   836,
1190      841,   846,   854,   864,   874,   884,   891,   898,   905,   914,
1191      923,   930,   936,   942,   951,   956,   964,   966,   968,   970,
1192      972,   974,   976,   978,   980,   982,   984,   987,   990,   995,
1193     1000,  1007,  1014,  1017,  1020,  1025,  1028,  1031,  1034,  1037,
1194     1040,  1043,  1050,  1057,  1063,  1068,  1072,  1076,  1080,  1084,
1195     1088,  1092,  1097,  1100,  1105,  1108,  1113,  1116,  1121,  1124,
1196     1132,  1141,  1150,  1158,  1166,  1174,  1184,  1192,  1201,  1211,
1197     1220,  1227,  1235,  1244,  1254,  1263,  1271,  1279,  1286,  1298,
1198     1306,  1318,  1326,  1330,  1333,  1335,  1343,  1353,  1365,  1369,
1199     1375,  1383,  1386,  1389,  1392,  1395,  1397,  1399,  1402,  1405,
1200     1410,  1412,  1414,  1421,  1428,  1435,  1438,  1441,  1443,  1445,
1201     1446,  1452,  1458,  1462,  1466,  1470,  1474,  1475,  1477,  1479,
1202     1481,  1483,  1485,  1486,  1490,  1491,  1495,  1499,  1500,  1504,
1203     1508,  1514,  1520,  1521,  1525,  1529,  1530,  1534,  1538,  1539,
1204     1543,  1547,  1551,  1557,  1563,  1564,  1568,  1569,  1573,  1575,
1205     1577,  1579,  1581,  1582,  1586,  1590,  1594,  1600,  1606,  1608,
1206     1610,  1612,  1613,  1617,  1618,  1622,  1627,  1632,  1634,  1636,
1207     1638,  1640,  1642,  1644,  1646,  1648,  1652,  1656,  1660,  1664,
1208     1670,  1676,  1682,  1688,  1692,  1696,  1702,  1708,  1709,  1711,
1209     1713,  1716,  1719,  1722,  1726,  1728,  1734,  1740,  1744,  1747,
1210     1750,  1753,  1757,  1759,  1761,  1763,  1765,  1769,  1773,  1777,
1211     1781,  1783,  1785,  1787,  1789,  1793,  1795,  1797,  1801,  1803,
1212     1805,  1809,  1812,  1815,  1817,  1821,  1825,  1829,  1833,  1837,
1213     1841,  1845,  1849,  1853,  1857
1214 };
1215
1216 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1217 static const yytype_int16 yyrhs[] =
1218 {
1219      175,     0,    -1,    -1,   176,    -1,   177,   160,    -1,   177,
1220       77,   177,    77,   177,   160,    -1,   177,    77,   177,   160,
1221       -1,     1,    -1,   166,    -1,   208,   179,    -1,   208,   179,
1222      157,   208,   179,    -1,    55,    -1,    25,    97,   162,   207,
1223      178,   161,    -1,    35,    97,   162,   207,   178,   161,    -1,
1224       32,    97,    35,    -1,    34,    97,    35,    -1,   162,    25,
1225      157,    25,   161,    97,     3,   162,    25,   159,   219,   157,
1226       25,   159,   219,   161,   192,    -1,   162,    25,   157,    25,
1227      161,    97,     4,   162,    25,   159,   219,   157,    25,   159,
1228      219,   161,   192,    -1,   162,    25,   157,    25,   161,    97,
1229        8,    25,   159,   219,   192,    -1,   162,    25,   157,    25,
1230      161,    97,    19,    25,   162,   191,   161,    -1,    25,    97,
1231       33,    70,    34,   157,    25,    97,    31,    70,    32,    -1,
1232       25,    97,   178,    70,   178,   157,    25,    97,   178,    69,
1233      178,   184,    -1,    25,    97,    25,   201,    25,   157,    25,
1234       97,    25,   201,    25,   184,    -1,    25,    97,    25,   200,
1235       25,   157,    25,    97,    25,   200,    25,   185,    -1,    25,
1236       97,    76,    25,   189,    -1,   205,    76,   178,    -1,    31,
1237       97,    35,    -1,    33,    97,    35,    -1,    25,    97,   194,
1238      162,    25,   157,    25,   161,    -1,    25,    97,     5,   162,
1239       25,   159,   219,   157,    25,   159,   219,   161,   193,    -1,
1240       25,    97,     5,   162,    25,   159,   219,   157,    25,   159,
1241      219,   161,    -1,    25,    97,     6,   162,    25,   159,   219,
1242      157,    25,   159,   219,   161,   202,    -1,    25,    97,     7,
1243      162,    25,   159,   219,   157,    25,   159,   219,   161,   203,
1244       -1,    25,    97,     9,   162,    25,   157,    25,   161,    -1,
1245       35,    97,    35,    97,    21,   162,    35,   161,    71,    35,
1246       70,    21,   162,    35,   161,    71,    35,    -1,    25,    97,
1247       25,   201,    25,   184,    -1,    25,    97,   199,   162,    25,
1248      157,    25,   161,   189,    -1,   205,    69,   178,    -1,    35,
1249       97,    35,   201,    35,   184,    -1,   205,   205,   219,    -1,
1250      205,   178,   162,   125,   161,    -1,    35,    97,    25,   162,
1251      137,   161,    -1,    35,    97,    25,   201,    25,   162,   140,
1252      161,    -1,    35,    97,    25,   201,    25,   162,   141,   161,
1253       -1,   205,   178,    -1,   205,    25,    -1,    25,    97,    35,
1254      186,    -1,    35,    97,   219,    -1,   205,   219,    -1,    25,
1255       97,   219,   187,    -1,    35,    97,    25,    -1,    25,    97,
1256       25,   200,    25,   183,    -1,    25,    97,    28,   186,    -1,
1257      205,    76,   178,   157,   205,    76,   178,    -1,   205,    69,
1258      178,   157,   205,    69,   178,    -1,   206,   178,   195,    -1,
1259       25,   102,   219,    -1,    25,   103,    25,   162,   131,   161,
1260       -1,    25,   102,    25,    -1,   178,   103,   178,   195,    -1,
1261       25,   103,    25,    -1,    25,   103,   219,    -1,    25,    98,
1262       25,    -1,    11,   162,    25,   159,   219,   157,    25,   159,
1263      219,   161,   192,    -1,   205,   178,   162,   125,   161,   157,
1264      205,   178,   162,   125,   161,    -1,    25,    97,   162,    25,
1265       70,    25,   161,    90,   219,    -1,    25,    97,    25,    65,
1266       25,    -1,    25,    97,    25,    67,    25,    -1,    25,    97,
1267       25,    70,   162,    25,    90,   219,   161,    -1,    27,    97,
1268      178,   106,   178,    -1,    27,    97,   178,   111,   178,    -1,
1269       27,    97,    25,   111,    25,   196,    -1,    27,    97,    25,
1270      111,   219,   196,    -1,    27,    97,    25,   106,    25,    -1,
1271       27,    97,    25,   106,   219,    -1,    27,    97,   178,   105,
1272      178,    -1,    27,    97,    25,   105,    25,   196,    -1,    27,
1273       97,    25,   105,   219,   196,    -1,    25,    97,    25,    64,
1274       25,    -1,   212,    -1,    25,    97,    25,    -1,    27,    97,
1275       25,    -1,    25,    97,    27,    -1,    27,   104,    27,    -1,
1276       35,    97,   210,   179,    -1,    25,    97,   210,   179,    -1,
1277       35,    97,   210,   179,   157,    35,    97,   210,   179,    -1,
1278       25,    97,   210,   179,   157,    25,    97,   210,   179,    -1,
1279      205,    86,   178,   158,    35,    -1,    35,    97,    86,    35,
1280      158,    35,   190,    -1,   205,   178,    90,   219,    -1,    25,
1281       97,    25,    90,   219,   188,    -1,    35,    97,    35,    90,
1282      219,   190,    -1,    25,    97,    86,    25,   158,    35,   188,
1283       -1,    35,    97,    18,   162,    25,   157,    35,   161,   189,
1284       -1,    35,    97,    18,   162,    35,   157,    35,   161,    -1,
1285       25,    97,    17,   162,    25,   157,    25,   161,    -1,    25,
1286       97,    17,   162,    25,   157,    25,   161,   162,   132,   161,
1287       -1,    25,    97,    16,   162,    25,   157,    35,   161,   186,
1288       -1,   205,   178,    92,   219,    -1,   205,    85,   178,   158,
1289       35,    -1,    35,    97,    85,    35,   158,    35,    -1,    25,
1290       97,    85,    25,   158,    35,   189,    -1,    25,    97,    84,
1291       25,   158,    35,    -1,   205,   178,    91,   219,    -1,    25,
1292       97,    25,    91,   219,   189,    -1,    35,    97,    35,    91,
1293      219,    -1,    35,    97,    35,    92,   219,   190,    -1,    25,
1294       97,    25,    92,   219,   188,    -1,    35,    97,    20,    25,
1295       -1,    25,    97,    10,   162,    35,   157,    35,   161,    -1,
1296       35,    97,    27,    97,    87,   162,   178,   157,    25,   161,
1297       -1,    35,    97,    27,    97,    68,   162,   178,   157,    25,
1298      161,    -1,    35,    97,    27,    97,    68,   162,   178,   157,
1299      178,   157,    27,   161,    -1,   205,    89,   178,   158,    35,
1300       -1,    25,    97,    89,    25,   158,    35,    -1,   205,    89,
1301      178,   158,   219,    -1,    25,    97,    89,    25,   158,   219,
1302       -1,    35,    97,    22,   178,    -1,    35,    97,    22,    25,
1303       -1,    35,    97,    22,    35,    -1,    35,    97,    15,   162,
1304       25,   161,   180,    -1,    25,    97,    15,   162,    25,   157,
1305       25,   161,   180,    -1,   149,   162,    25,   157,    25,   157,
1306      178,   161,   180,    -1,   205,    87,   162,   178,   157,   178,
1307      157,    27,   161,    -1,   146,   162,    25,   157,   219,   161,
1308       -1,   147,   162,    25,   157,   219,   161,    -1,   145,   162,
1309       25,   157,   219,   161,    -1,    27,   104,   148,   162,    25,
1310      157,   219,   161,    -1,    27,    97,   148,   162,    25,   157,
1311      219,   161,    -1,   156,    63,    27,    25,    97,    25,    -1,
1312      156,    27,    25,    97,    25,    -1,   156,    63,    27,    56,
1313      219,    -1,   156,    63,    27,    56,   219,   162,   130,   161,
1314       -1,   156,    27,    56,   219,    -1,   156,    27,    56,   219,
1315      162,   130,   161,    -1,    36,    -1,    38,    -1,    37,    -1,
1316       39,    -1,    40,    -1,    41,    -1,    43,    -1,    46,    -1,
1317       47,    -1,    48,    -1,    45,    25,    -1,    44,    25,    -1,
1318       56,   162,    25,   161,    -1,    59,   162,    25,   161,    -1,
1319       59,   162,    26,    70,    25,   161,    -1,    56,   162,    26,
1320       70,    25,   161,    -1,    49,   219,    -1,    50,   219,    -1,
1321      119,   162,    25,   161,    -1,    56,   219,    -1,    57,   219,
1322       -1,    58,   219,    -1,    58,   217,    -1,    59,   219,    -1,
1323       59,   217,    -1,    96,   162,    25,   157,    25,   161,    -1,
1324       95,   162,    25,   157,    25,   161,    -1,    25,    97,    69,
1325       25,   188,    -1,    25,    97,    62,    25,    -1,    25,    94,
1326       25,    -1,    25,    94,   219,    -1,    25,    88,    25,    -1,
1327       25,    93,    25,    -1,    25,    93,   219,    -1,    25,    88,
1328      219,    -1,   113,   163,    25,   164,    -1,   113,   198,    -1,
1329      112,   163,    25,   164,    -1,   112,   198,    -1,   114,   163,
1330       25,   164,    -1,   114,   198,    -1,   115,   163,    25,   164,
1331       -1,   115,   198,    -1,   122,   163,    25,   204,   164,    97,
1332       25,    -1,   122,   163,    25,   201,   219,   164,    97,    25,
1333       -1,   123,   163,    25,   201,   219,   164,    97,    25,    -1,
1334      123,   163,    25,   204,   164,    97,    25,    -1,   123,   163,
1335       25,   204,   164,    97,    35,    -1,   163,    25,   201,   219,
1336      164,    97,    25,    -1,    25,    97,   123,   163,    25,   201,
1337      219,   164,   186,    -1,    35,    97,   123,   163,    25,   204,
1338      164,    -1,    25,    97,   123,   163,    25,   204,   164,   186,
1339       -1,    25,    97,   123,   163,    25,    83,    25,   164,   186,
1340       -1,    35,    97,   123,   163,    25,    83,    25,   164,    -1,
1341      163,    25,   204,   164,    97,    25,    -1,   163,    25,    83,
1342       25,   164,    97,    25,    -1,   123,   163,    25,    83,    25,
1343      164,    97,    35,    -1,    25,    97,   122,   163,    25,   201,
1344      219,   164,   186,    -1,    25,    97,   122,   163,    25,   204,
1345      164,   186,    -1,    25,    97,   163,    25,    83,    25,   164,
1346       -1,    25,    97,   163,    25,   201,   216,   164,    -1,    25,
1347       97,   163,    25,   204,   164,    -1,   197,    97,   162,    25,
1348      159,   219,   157,    25,   159,   219,   161,    -1,   197,    97,
1349      162,    25,   159,   219,   161,    -1,   162,    25,   159,   219,
1350      157,    25,   159,   219,   161,    97,   198,    -1,   162,    25,
1351      159,   219,   161,    97,   198,    -1,   197,    97,    25,    -1,
1352       23,   219,    -1,    24,    -1,    51,   162,   219,   157,   219,
1353      161,    25,    -1,    51,   162,   219,   157,   219,   161,    25,
1354       97,    25,    -1,    51,   162,   219,   157,   219,   161,    25,
1355       97,    25,    91,   219,    -1,    52,   219,    25,    -1,    52,
1356      219,    25,    97,    25,    -1,    52,   219,    25,    97,    25,
1357       91,   219,    -1,    53,   168,    -1,    53,   219,    -1,    54,
1358      168,    -1,    54,   219,    -1,    60,    -1,   153,    -1,   153,
1359      178,    -1,   153,    25,    -1,   155,   162,    25,   161,    -1,
1360      152,    -1,    42,    -1,   154,   162,    35,   157,   219,   161,
1361       -1,   151,   162,    25,   157,   219,   161,    -1,   150,   162,
1362       25,   157,   219,   161,    -1,   117,   219,    -1,   117,    25,
1363       -1,    29,    -1,    30,    -1,    -1,   162,   134,   157,   135,
1364      161,    -1,   162,   135,   157,   134,   161,    -1,   162,   135,
1365      161,    -1,   162,   134,   161,    -1,   162,   120,   161,    -1,
1366      162,   121,   161,    -1,    -1,   125,    -1,   126,    -1,   127,
1367       -1,   120,    -1,   121,    -1,    -1,   162,   181,   161,    -1,
1368       -1,   162,   124,   161,    -1,   162,   125,   161,    -1,    -1,
1369      162,   182,   161,    -1,   162,   181,   161,    -1,   162,   182,
1370      157,   181,   161,    -1,   162,   181,   157,   182,   161,    -1,
1371       -1,   162,   133,   161,    -1,   162,   132,   161,    -1,    -1,
1372      162,   132,   161,    -1,   162,   133,   161,    -1,    -1,   162,
1373      124,   161,    -1,   162,   125,   161,    -1,   162,   142,   161,
1374       -1,   162,   142,   157,   125,   161,    -1,   162,   125,   157,
1375      142,   161,    -1,    -1,   162,   142,   161,    -1,    -1,   162,
1376      125,   161,    -1,   107,    -1,   110,    -1,   109,    -1,   108,
1377       -1,    -1,   162,   136,   161,    -1,   162,   136,   161,    -1,
1378      162,   135,   161,    -1,   162,   135,   157,   136,   161,    -1,
1379      162,   136,   157,   135,   161,    -1,    12,    -1,    13,    -1,
1380       14,    -1,    -1,   162,   135,   161,    -1,    -1,   162,   135,
1381      161,    -1,   163,    82,    25,   164,    -1,   163,    25,    83,
1382      164,    -1,    74,    -1,    75,    -1,    78,    -1,    79,    -1,
1383       80,    -1,    81,    -1,    70,    -1,    69,    -1,   162,   139,
1384      161,    -1,   162,   128,   161,    -1,   162,   138,   161,    -1,
1385      162,   129,   161,    -1,   162,   139,   157,   136,   161,    -1,
1386      162,   128,   157,   136,   161,    -1,   162,   138,   157,   136,
1387      161,    -1,   162,   129,   157,   136,   161,    -1,   162,   143,
1388      161,    -1,   162,   144,   161,    -1,   162,   143,   157,   136,
1389      161,    -1,   162,   144,   157,   136,   161,    -1,    -1,    83,
1390       -1,    82,    -1,   178,    97,    -1,   178,   102,    -1,   178,
1391      103,    -1,    25,    97,   178,    -1,   209,    -1,    25,    97,
1392      162,   209,   161,    -1,    35,    97,   162,   209,   161,    -1,
1393       35,    97,   178,    -1,   205,   210,    -1,   207,   210,    -1,
1394      206,   210,    -1,    35,    71,    35,    -1,    97,    -1,    99,
1395       -1,   101,    -1,   100,    -1,    27,   211,   165,    -1,    27,
1396      211,   142,    -1,   165,   211,    27,    -1,   142,   211,    27,
1397       -1,   167,    -1,   169,    -1,   170,    -1,   171,    -1,   213,
1398      172,   214,    -1,   215,    -1,   219,    -1,   213,   172,   173,
1399       -1,   168,    -1,   213,    -1,   162,   220,   161,    -1,    62,
1400      220,    -1,    69,   220,    -1,   220,    -1,   220,    71,   220,
1401       -1,   220,    72,   220,    -1,   220,    66,   220,    -1,   220,
1402       70,   220,    -1,   220,    69,   220,    -1,   220,    90,   220,
1403       -1,   220,    91,   220,    -1,   220,    64,   220,    -1,   220,
1404       67,   220,    -1,   220,    65,   220,    -1,   218,    -1
1405 };
1406
1407 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
1408 static const yytype_uint16 yyrline[] =
1409 {
1410        0,   647,   647,   648,   660,   662,   695,   722,   733,   737,
1411      775,   795,   800,   810,   820,   825,   830,   848,   866,   880,
1412      893,   909,   931,   949,   974,   996,  1001,  1011,  1022,  1033,
1413     1047,  1062,  1078,  1094,  1105,  1119,  1145,  1163,  1168,  1174,
1414     1186,  1197,  1208,  1219,  1230,  1241,  1252,  1278,  1292,  1302,
1415     1347,  1366,  1377,  1388,  1399,  1410,  1421,  1437,  1454,  1470,
1416     1481,  1492,  1525,  1536,  1549,  1560,  1599,  1609,  1619,  1639,
1417     1649,  1659,  1670,  1684,  1695,  1708,  1718,  1730,  1745,  1756,
1418     1762,  1784,  1795,  1806,  1814,  1840,  1870,  1899,  1930,  1944,
1419     1955,  1969,  2003,  2021,  2046,  2058,  2076,  2087,  2098,  2109,
1420     2122,  2133,  2144,  2155,  2166,  2177,  2210,  2220,  2233,  2253,
1421     2264,  2275,  2288,  2301,  2312,  2323,  2334,  2345,  2355,  2366,
1422     2377,  2389,  2400,  2411,  2425,  2438,  2450,  2462,  2473,  2484,
1423     2495,  2507,  2519,  2530,  2541,  2552,  2562,  2568,  2574,  2580,
1424     2586,  2592,  2598,  2604,  2610,  2616,  2622,  2633,  2644,  2655,
1425     2666,  2677,  2688,  2699,  2705,  2719,  2730,  2741,  2752,  2763,
1426     2773,  2786,  2794,  2802,  2826,  2837,  2848,  2859,  2870,  2881,
1427     2893,  2906,  2915,  2926,  2937,  2949,  2960,  2971,  2982,  2996,
1428     3008,  3034,  3064,  3075,  3100,  3137,  3165,  3190,  3201,  3212,
1429     3223,  3249,  3268,  3282,  3306,  3318,  3337,  3383,  3420,  3436,
1430     3455,  3469,  3488,  3504,  3512,  3521,  3532,  3544,  3558,  3566,
1431     3576,  3588,  3599,  3609,  3620,  3631,  3637,  3642,  3647,  3653,
1432     3661,  3667,  3673,  3679,  3685,  3691,  3699,  3713,  3717,  3727,
1433     3731,  3736,  3741,  3746,  3753,  3757,  3764,  3768,  3773,  3778,
1434     3786,  3790,  3797,  3801,  3809,  3814,  3820,  3829,  3834,  3840,
1435     3846,  3852,  3861,  3864,  3868,  3875,  3878,  3882,  3889,  3894,
1436     3900,  3906,  3912,  3917,  3925,  3928,  3935,  3938,  3945,  3949,
1437     3953,  3957,  3964,  3967,  3974,  3979,  3986,  3993,  4005,  4009,
1438     4013,  4020,  4023,  4033,  4036,  4045,  4051,  4060,  4064,  4071,
1439     4075,  4079,  4083,  4090,  4094,  4101,  4109,  4117,  4125,  4133,
1440     4140,  4147,  4155,  4165,  4170,  4175,  4180,  4188,  4191,  4195,
1441     4204,  4211,  4218,  4225,  4240,  4246,  4259,  4272,  4290,  4297,
1442     4304,  4314,  4327,  4331,  4335,  4339,  4346,  4352,  4358,  4364,
1443     4374,  4383,  4385,  4387,  4391,  4399,  4403,  4410,  4416,  4422,
1444     4426,  4430,  4434,  4440,  4446,  4450,  4454,  4458,  4462,  4466,
1445     4470,  4474,  4478,  4482,  4486
1446 };
1447 #endif
1448
1449 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1450 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1451    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
1452 static const char *const yytname[] =
1453 {
1454   "$end", "error", "$undefined", "BYTEOP16P", "BYTEOP16M", "BYTEOP1P",
1455   "BYTEOP2P", "BYTEOP3P", "BYTEUNPACK", "BYTEPACK", "PACK", "SAA",
1456   "ALIGN8", "ALIGN16", "ALIGN24", "VIT_MAX", "EXTRACT", "DEPOSIT",
1457   "EXPADJ", "SEARCH", "ONES", "SIGN", "SIGNBITS", "LINK", "UNLINK", "REG",
1458   "PC", "CCREG", "BYTE_DREG", "REG_A_DOUBLE_ZERO", "REG_A_DOUBLE_ONE",
1459   "A_ZERO_DOT_L", "A_ZERO_DOT_H", "A_ONE_DOT_L", "A_ONE_DOT_H", "HALF_REG",
1460   "NOP", "RTI", "RTS", "RTX", "RTN", "RTE", "HLT", "IDLE", "STI", "CLI",
1461   "CSYNC", "SSYNC", "EMUEXCPT", "RAISE", "EXCPT", "LSETUP", "LOOP",
1462   "LOOP_BEGIN", "LOOP_END", "DISALGNEXCPT", "JUMP", "JUMP_DOT_S",
1463   "JUMP_DOT_L", "CALL", "ABORT", "NOT", "TILDA", "BANG", "AMPERSAND",
1464   "BAR", "PERCENT", "CARET", "BXOR", "MINUS", "PLUS", "STAR", "SLASH",
1465   "NEG", "MIN", "MAX", "ABS", "DOUBLE_BAR", "_PLUS_BAR_PLUS",
1466   "_PLUS_BAR_MINUS", "_MINUS_BAR_PLUS", "_MINUS_BAR_MINUS", "_MINUS_MINUS",
1467   "_PLUS_PLUS", "SHIFT", "LSHIFT", "ASHIFT", "BXORSHIFT",
1468   "_GREATER_GREATER_GREATER_THAN_ASSIGN", "ROT", "LESS_LESS",
1469   "GREATER_GREATER", "_GREATER_GREATER_GREATER", "_LESS_LESS_ASSIGN",
1470   "_GREATER_GREATER_ASSIGN", "DIVS", "DIVQ", "ASSIGN", "_STAR_ASSIGN",
1471   "_BAR_ASSIGN", "_CARET_ASSIGN", "_AMPERSAND_ASSIGN", "_MINUS_ASSIGN",
1472   "_PLUS_ASSIGN", "_ASSIGN_BANG", "_LESS_THAN_ASSIGN", "_ASSIGN_ASSIGN",
1473   "GE", "LT", "LE", "GT", "LESS_THAN", "FLUSHINV", "FLUSH", "IFLUSH",
1474   "PREFETCH", "PRNT", "OUTC", "WHATREG", "TESTSET", "ASL", "ASR", "B", "W",
1475   "NS", "S", "CO", "SCO", "TH", "TL", "BP", "BREV", "X", "Z", "M", "MMOD",
1476   "R", "RND", "RNDL", "RNDH", "RND12", "RND20", "V", "LO", "HI", "BITTGL",
1477   "BITCLR", "BITSET", "BITTST", "BITMUX", "DBGAL", "DBGAH", "DBGHALT",
1478   "DBG", "DBGA", "DBGCMPLX", "IF", "COMMA", "BY", "COLON", "SEMICOLON",
1479   "RPAREN", "LPAREN", "LBRACK", "RBRACK", "STATUS_REG", "MNOP", "SYMBOL",
1480   "NUMBER", "GOT", "GOT17M4", "FUNCDESC_GOT17M4", "AT", "PLTPC", "$accept",
1481   "statement", "asm", "asm_1", "REG_A", "opt_mode", "asr_asl", "sco",
1482   "asr_asl_0", "amod0", "amod1", "amod2", "xpmod", "xpmod1", "vsmod",
1483   "vmod", "smod", "searchmod", "aligndir", "byteop_mod", "c_align",
1484   "w32_or_nothing", "iu_or_nothing", "reg_with_predec", "reg_with_postinc",
1485   "min_max", "op_bar_op", "plus_minus", "rnd_op", "b3_op", "post_op",
1486   "a_assign", "a_minusassign", "a_plusassign", "assign_macfunc",
1487   "a_macfunc", "multiply_halfregs", "cc_op", "ccstat", "symbol",
1488   "any_gotrel", "got", "got_or_expr", "pltpc", "eterm", "expr", "expr_1", 0
1489 };
1490 #endif
1491
1492 # ifdef YYPRINT
1493 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1494    token YYLEX-NUM.  */
1495 static const yytype_uint16 yytoknum[] =
1496 {
1497        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1498      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1499      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1500      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1501      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1502      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
1503      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1504      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1505      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
1506      345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
1507      355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
1508      365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
1509      375,   376,   377,   378,   379,   380,   381,   382,   383,   384,
1510      385,   386,   387,   388,   389,   390,   391,   392,   393,   394,
1511      395,   396,   397,   398,   399,   400,   401,   402,   403,   404,
1512      405,   406,   407,   408,   409,   410,   411,   412,   413,   414,
1513      415,   416,   417,   418,   419,   420,   421,   422,   423,   424,
1514      425,   426,   427,   428
1515 };
1516 # endif
1517
1518 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1519 static const yytype_uint8 yyr1[] =
1520 {
1521        0,   174,   175,   175,   176,   176,   176,   176,   177,   177,
1522      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1523      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1524      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1525      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1526      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1527      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1528      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1529      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1530      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1531      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1532      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1533      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1534      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1535      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1536      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1537      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1538      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1539      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1540      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1541      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1542      177,   177,   177,   177,   177,   177,   177,   177,   177,   177,
1543      177,   177,   177,   177,   177,   177,   177,   178,   178,   179,
1544      179,   179,   179,   179,   180,   180,   181,   181,   181,   181,
1545      182,   182,   183,   183,   184,   184,   184,   185,   185,   185,
1546      185,   185,   186,   186,   186,   187,   187,   187,   188,   188,
1547      188,   188,   188,   188,   189,   189,   190,   190,   191,   191,
1548      191,   191,   192,   192,   193,   193,   193,   193,   194,   194,
1549      194,   195,   195,   196,   196,   197,   198,   199,   199,   200,
1550      200,   200,   200,   201,   201,   202,   202,   202,   202,   202,
1551      202,   202,   202,   203,   203,   203,   203,   204,   204,   204,
1552      205,   206,   207,   208,   208,   208,   208,   208,   209,   209,
1553      209,   210,   211,   211,   211,   211,   212,   212,   212,   212,
1554      213,   214,   214,   214,   215,   216,   216,   217,   218,   218,
1555      218,   218,   218,   219,   220,   220,   220,   220,   220,   220,
1556      220,   220,   220,   220,   220
1557 };
1558
1559 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1560 static const yytype_uint8 yyr2[] =
1561 {
1562        0,     2,     0,     1,     2,     6,     4,     1,     1,     2,
1563        5,     1,     6,     6,     3,     3,    17,    17,    11,    11,
1564       11,    12,    12,    12,     5,     3,     3,     3,     8,    13,
1565       12,    13,    13,     8,    17,     6,     9,     3,     6,     3,
1566        5,     6,     8,     8,     2,     2,     4,     3,     2,     4,
1567        3,     6,     4,     7,     7,     3,     3,     6,     3,     4,
1568        3,     3,     3,    11,    11,     9,     5,     5,     9,     5,
1569        5,     6,     6,     5,     5,     5,     6,     6,     5,     1,
1570        3,     3,     3,     3,     4,     4,     9,     9,     5,     7,
1571        4,     6,     6,     7,     9,     8,     8,    11,     9,     4,
1572        5,     6,     7,     6,     4,     6,     5,     6,     6,     4,
1573        8,    10,    10,    12,     5,     6,     5,     6,     4,     4,
1574        4,     7,     9,     9,     9,     6,     6,     6,     8,     8,
1575        6,     5,     5,     8,     4,     7,     1,     1,     1,     1,
1576        1,     1,     1,     1,     1,     1,     2,     2,     4,     4,
1577        6,     6,     2,     2,     4,     2,     2,     2,     2,     2,
1578        2,     6,     6,     5,     4,     3,     3,     3,     3,     3,
1579        3,     4,     2,     4,     2,     4,     2,     4,     2,     7,
1580        8,     8,     7,     7,     7,     9,     7,     8,     9,     8,
1581        6,     7,     8,     9,     8,     7,     7,     6,    11,     7,
1582       11,     7,     3,     2,     1,     7,     9,    11,     3,     5,
1583        7,     2,     2,     2,     2,     1,     1,     2,     2,     4,
1584        1,     1,     6,     6,     6,     2,     2,     1,     1,     0,
1585        5,     5,     3,     3,     3,     3,     0,     1,     1,     1,
1586        1,     1,     0,     3,     0,     3,     3,     0,     3,     3,
1587        5,     5,     0,     3,     3,     0,     3,     3,     0,     3,
1588        3,     3,     5,     5,     0,     3,     0,     3,     1,     1,
1589        1,     1,     0,     3,     3,     3,     5,     5,     1,     1,
1590        1,     0,     3,     0,     3,     4,     4,     1,     1,     1,
1591        1,     1,     1,     1,     1,     3,     3,     3,     3,     5,
1592        5,     5,     5,     3,     3,     5,     5,     0,     1,     1,
1593        2,     2,     2,     3,     1,     5,     5,     3,     2,     2,
1594        2,     3,     1,     1,     1,     1,     3,     3,     3,     3,
1595        1,     1,     1,     1,     3,     1,     1,     3,     1,     1,
1596        3,     2,     2,     1,     3,     3,     3,     3,     3,     3,
1597        3,     3,     3,     3,     1
1598 };
1599
1600 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1601    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
1602    means the default is an error.  */
1603 static const yytype_uint16 yydefact[] =
1604 {
1605        0,     7,     0,     0,   204,     0,     0,   227,   228,     0,
1606        0,     0,     0,     0,   136,   138,   137,   139,   140,   141,
1607      221,   142,     0,     0,   143,   144,   145,     0,     0,     0,
1608        0,     0,     0,    11,     0,     0,     0,     0,   215,     0,
1609        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1610        0,     0,     0,     0,     0,     0,   220,   216,     0,     0,
1611        0,     0,     0,     0,     8,     0,     3,     0,     0,     0,
1612        0,     0,     0,   229,   314,    79,     0,     0,     0,     0,
1613      330,   338,   339,   354,   203,   343,     0,     0,     0,     0,
1614        0,     0,     0,   322,   323,   325,   324,     0,     0,     0,
1615        0,     0,     0,     0,   147,   146,   152,   153,     0,     0,
1616      338,   212,   338,   214,     0,   155,   156,   339,   158,   157,
1617        0,   160,   159,     0,     0,     0,   174,     0,   172,     0,
1618      176,     0,   178,   226,   225,     0,     0,     0,   322,     0,
1619        0,     0,     0,     0,     0,     0,   218,   217,     0,     0,
1620        0,     0,     0,   307,     0,     0,     1,     0,     4,   310,
1621      311,   312,     0,    45,     0,     0,     0,     0,     0,     0,
1622        0,    44,     0,   318,    48,   281,   320,   319,     0,     9,
1623        0,   341,   342,     0,     0,     0,     0,     0,     0,     0,
1624        0,     0,     0,     0,   167,   170,   168,   169,   165,   166,
1625        0,     0,     0,     0,     0,   278,   279,   280,     0,     0,
1626        0,    80,    82,   252,     0,   252,     0,     0,   287,   288,
1627        0,     0,     0,     0,     0,     0,     0,     0,     0,   313,
1628        0,     0,   229,   255,    62,    58,    56,    60,    61,    81,
1629        0,     0,    83,     0,   327,   326,    26,    14,    27,    15,
1630        0,     0,     0,     0,    50,     0,     0,     0,     0,     0,
1631        0,   317,   229,    47,     0,   208,     0,     0,     0,     0,
1632        0,     0,     0,     0,     0,     0,     0,     0,   307,   307,
1633      329,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1634        0,     0,     0,     0,   294,   293,   309,   308,     0,     0,
1635        0,   328,     0,   281,   202,     0,     0,    37,    25,     0,
1636        0,     0,     0,     0,     0,     0,     0,    39,     0,    55,
1637        0,     0,     0,     0,   340,   351,   353,   346,   352,   348,
1638      347,   344,   345,   349,   350,     0,     0,     0,     0,     0,
1639        0,     0,     0,     0,     0,     0,   293,   289,   290,   291,
1640      292,     0,     0,     0,     0,     0,     0,    52,     0,    46,
1641      164,   258,   264,     0,     0,     0,     0,     0,     0,     0,
1642        0,     0,     0,     0,     0,   307,     0,     0,     0,    85,
1643        0,    49,     0,     0,     0,     0,     0,     0,     0,     0,
1644        0,     0,     0,   109,   119,   120,   118,     0,     0,     0,
1645        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1646       84,     0,     0,   148,     0,   337,   149,     0,     0,     0,
1647        0,   173,   171,   175,   177,   154,   308,     0,     0,   308,
1648        0,     0,     0,     0,     0,     0,     0,     0,     0,   219,
1649        0,   134,     0,     0,     0,     0,     0,     0,     0,   285,
1650        0,     6,    59,     0,   321,     0,     0,     0,     0,     0,
1651        0,    90,   104,    99,     0,     0,     0,   233,     0,   232,
1652        0,     0,   229,     0,     0,     0,     0,     0,     0,     0,
1653        0,     0,    78,    66,    67,     0,   258,   264,   258,   242,
1654      244,     0,     0,     0,     0,   163,     0,    24,     0,     0,
1655        0,     0,   307,   307,     0,   312,     0,   315,   308,     0,
1656        0,     0,     0,     0,     0,     0,     0,     0,   283,   283,
1657       73,    74,   283,   283,     0,    75,    69,    70,     0,     0,
1658        0,     0,     0,     0,     0,     0,   266,   106,   266,     0,
1659      244,     0,     0,   307,     0,   316,     0,     0,   209,     0,
1660        0,     0,     0,   286,     0,     0,     0,     0,     0,     0,
1661        0,     0,     0,     0,     0,     0,   131,     0,     0,   132,
1662        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1663        0,   100,    88,     0,   114,   116,    40,   282,     0,     0,
1664        0,     0,    10,     0,     0,     0,     0,     0,     0,     0,
1665        0,     0,     0,    91,   105,   108,     0,   236,    51,     0,
1666        0,    35,   254,   253,     0,     0,     0,     0,     0,   103,
1667      264,   258,   115,   117,     0,     0,   308,     0,     0,     0,
1668       12,     0,   339,   335,     0,   336,   197,     0,     0,     0,
1669        0,   256,   257,    57,     0,    76,    77,    71,    72,     0,
1670        0,     0,     0,     0,    41,     0,     0,     0,     0,    92,
1671      107,     0,    38,   101,   266,   308,     0,    13,     0,     0,
1672        0,   151,   150,   162,   161,     0,     0,     0,     0,     0,
1673      127,   125,   126,     0,   224,   223,   222,     0,   130,     0,
1674        0,     0,     0,     0,     0,   190,     5,     0,     0,     0,
1675        0,     0,   230,   231,     0,   313,     0,     0,     0,     0,
1676        0,     0,     0,     0,     0,     0,     0,     0,   237,   238,
1677      239,     0,     0,     0,     0,     0,   259,     0,   260,     0,
1678      261,   265,   102,    93,     0,   252,     0,     0,   252,     0,
1679      195,     0,   196,     0,     0,     0,     0,     0,     0,     0,
1680        0,   121,     0,     0,     0,     0,     0,     0,     0,     0,
1681       89,     0,   186,     0,   205,   210,     0,   179,     0,     0,
1682      182,   183,     0,   135,     0,     0,     0,     0,     0,     0,
1683        0,   201,   191,   184,     0,   199,    54,    53,     0,     0,
1684        0,     0,     0,     0,    33,   110,     0,   252,    96,     0,
1685        0,   243,     0,   245,   246,     0,     0,     0,   252,   194,
1686      252,   252,   187,     0,   331,   332,   333,   334,     0,    28,
1687      264,   229,   284,   129,   128,     0,     0,   264,    95,    42,
1688       43,     0,     0,   267,     0,   189,   229,     0,   180,   192,
1689      181,     0,   133,     0,     0,     0,     0,     0,     0,     0,
1690        0,     0,     0,     0,     0,     0,   122,    98,     0,    68,
1691        0,     0,     0,   263,   262,   193,   188,   185,    65,     0,
1692       36,    87,   234,   235,    94,     0,     0,     0,     0,    86,
1693      206,   123,     0,     0,     0,     0,     0,     0,   124,     0,
1694      272,     0,     0,     0,     0,     0,     0,     0,     0,   112,
1695        0,   111,     0,     0,     0,     0,   272,   268,   271,   270,
1696      269,     0,     0,     0,     0,     0,    63,     0,     0,     0,
1697       97,   247,   244,    20,   244,     0,     0,   207,     0,     0,
1698       18,    19,   200,   198,    64,     0,    30,     0,     0,   236,
1699       23,    22,    21,   113,     0,     0,     0,   273,     0,    29,
1700        0,    31,     0,    32,   240,   241,     0,     0,     0,     0,
1701        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1702      249,   236,   248,     0,     0,     0,     0,   275,     0,   274,
1703        0,   296,     0,   298,     0,   297,     0,   295,     0,   303,
1704        0,   304,     0,     0,     0,     0,     0,     0,     0,     0,
1705        0,     0,     0,     0,     0,   251,   250,     0,   272,   272,
1706      276,   277,   300,   302,   301,   299,   305,   306,    34,    16,
1707       17
1708 };
1709
1710 /* YYDEFGOTO[NTERM-NUM].  */
1711 static const yytype_int16 yydefgoto[] =
1712 {
1713       -1,    65,    66,    67,   370,   179,   751,   721,   957,   608,
1714      611,   940,   357,   381,   495,   497,   659,   911,   916,   949,
1715      230,   319,   645,    69,   126,   231,   354,   298,   951,   953,
1716      299,   371,   372,    72,    73,    74,   177,    98,    75,    82,
1717      817,   633,   634,   118,    83,    84,    85
1718 };
1719
1720 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1721    STATE-NUM.  */
1722 #define YYPACT_NINF -869
1723 static const yytype_int16 yypact[] =
1724 {
1725      862,  -869,   -96,   -14,  -869,   653,   618,  -869,  -869,   -22,
1726       -7,    20,    71,    85,  -869,  -869,  -869,  -869,  -869,  -869,
1727     -869,  -869,    58,   176,  -869,  -869,  -869,   -14,   -14,    48,
1728      -14,   167,   231,  -869,   327,   -14,   -14,   376,  -869,    53,
1729       56,    94,    96,   120,   126,   114,    64,   139,   144,   419,
1730      115,   171,   185,   199,   207,   230,  -869,   324,   250,   258,
1731       43,   358,    25,   419,  -869,   387,  -869,   -39,    13,   325,
1732      223,   245,   390,   300,  -869,  -869,   443,   -14,   -14,   -14,
1733     -869,  -869,  -869,  -869,  -869,   582,   152,   170,   178,   496,
1734      453,   203,   259,     7,  -869,  -869,  -869,    26,   -46,   448,
1735      455,   458,   464,   111,  -869,  -869,  -869,  -869,   -14,   463,
1736      -10,  -869,    -9,  -869,    32,  -869,  -869,   308,  -869,  -869,
1737      102,  -869,  -869,   479,   492,   497,  -869,   505,  -869,   508,
1738     -869,   523,  -869,  -869,  -869,   526,   541,   561,  -869,   530,
1739      567,   581,   586,   602,   611,   625,  -869,  -869,   549,   632,
1740       57,   589,   221,   172,   637,   614,  -869,  1008,  -869,  -869,
1741     -869,   365,     4,  -869,   584,   394,   365,   365,   365,   498,
1742      365,    -6,   -14,  -869,  -869,   507,  -869,  -869,   301,   510,
1743      519,  -869,  -869,   524,   -14,   -14,   -14,   -14,   -14,   -14,
1744      -14,   -14,   -14,   -14,  -869,  -869,  -869,  -869,  -869,  -869,
1745      548,   554,   563,   576,   583,  -869,  -869,  -869,   587,   592,
1746      597,   601,  -869,   598,   673,   -19,   279,   293,  -869,  -869,
1747      663,   698,   719,   723,   728,   594,   599,    63,   733,   691,
1748      603,   604,   300,   605,  -869,  -869,  -869,   606,  -869,   225,
1749      607,   271,  -869,   608,  -869,  -869,  -869,  -869,  -869,  -869,
1750      609,   610,   739,   208,   -25,   676,   538,   740,   741,   615,
1751      394,  -869,   300,  -869,   617,   680,   620,   709,   612,   621,
1752      710,   626,   627,   -41,    -3,    14,    17,   628,   281,   349,
1753     -869,   631,   633,   634,   636,   638,   639,   640,   641,   690,
1754      -14,    62,   767,   -14,  -869,  -869,  -869,   769,   -14,   643,
1755      644,  -869,    -8,   507,  -869,   773,   764,   646,   647,   648,
1756      651,   365,   652,   -14,   -14,   -14,   675,  -869,   666,  -869,
1757      134,   166,   276,   -14,  -869,   630,   642,  -869,   483,   368,
1758      368,  -869,  -869,   532,   532,   780,   786,   787,   788,   779,
1759      790,   791,   792,   793,   794,   795,   659,  -869,  -869,  -869,
1760     -869,   -14,   -14,   -14,   797,   798,   318,  -869,   799,  -869,
1761     -869,   662,   664,   667,   669,   670,   671,   806,   807,   765,
1762      340,   390,   390,   245,   677,   384,   365,   809,   811,   682,
1763      493,  -869,   706,   297,   317,   319,   815,   365,   365,   365,
1764      816,   817,   226,  -869,  -869,  -869,  -869,   707,   818,    37,
1765      -14,   -14,   -14,   824,   812,   688,   692,   823,   245,   693,
1766      694,   -14,   827,  -869,   828,  -869,  -869,   830,   831,   833,
1767      685,  -869,  -869,  -869,  -869,  -869,  -869,   -14,   697,   842,
1768      -14,   704,   -14,   -14,   -14,   844,   -14,   -14,   -14,  -869,
1769      845,   712,   774,   -14,   714,   182,   715,   716,   785,  -869,
1770     1008,  -869,  -869,   724,  -869,   365,   365,   849,   853,   766,
1771      100,  -869,  -869,  -869,   729,   763,   796,  -869,   800,  -869,
1772      829,   832,   300,   768,   771,   776,   777,   770,   775,   781,
1773      783,   784,  -869,  -869,  -869,   903,   662,   664,   662,   -58,
1774      -15,   772,   782,   789,    33,  -869,   802,  -869,   902,   907,
1775      910,   472,   281,   445,   924,  -869,   801,  -869,   925,   -14,
1776      803,   804,   808,   813,   926,   805,   810,   819,   820,   820,
1777     -869,  -869,   820,   820,   821,  -869,  -869,  -869,   826,   825,
1778      834,   835,   836,   837,   838,   839,   840,  -869,   840,   841,
1779      843,   917,   918,   562,   859,  -869,   919,   860,   864,   861,
1780      865,   868,   869,  -869,   846,   863,   870,   872,   866,   908,
1781      909,   911,   914,   912,   913,   915,  -869,   857,   931,   916,
1782      867,   934,   871,   875,   876,   944,   920,   -14,   891,   921,
1783      922,  -869,  -869,   365,  -869,  -869,   927,  -869,   928,   929,
1784        5,    10,  -869,   964,   -14,   -14,   -14,   968,   959,   970,
1785      961,   981,   933,  -869,  -869,  -869,  1050,   119,  -869,  1052,
1786      559,  -869,  -869,  -869,  1054,   930,   211,   247,   932,  -869,
1787      664,   662,  -869,  -869,   -14,   923,  1056,   -14,   935,   936,
1788     -869,   937,   938,  -869,   941,  -869,  -869,  1057,  1058,  1060,
1789      989,  -869,  -869,  -869,   953,  -869,  -869,  -869,  -869,   -14,
1790      -14,   940,  1059,  1061,  -869,   546,   365,   365,   967,  -869,
1791     -869,  1063,  -869,  -869,   840,  1070,   942,  -869,  1003,  1082,
1792      -14,  -869,  -869,  -869,  -869,  1011,  1084,  1014,  1015,   278,
1793     -869,  -869,  -869,   365,  -869,  -869,  -869,   952,  -869,   984,
1794      216,   956,   954,  1091,  1093,  -869,  -869,   287,   365,   365,
1795      962,   365,  -869,  -869,   365,  -869,   365,   965,   969,   971,
1796      972,   973,   974,   975,   976,   977,   -14,  1035,  -869,  -869,
1797     -869,   978,  1036,   979,   980,  1045,  -869,  1001,  -869,  1019,
1798     -869,  -869,  -869,  -869,   982,   598,   983,   985,   598,  1055,
1799     -869,   407,  -869,  1051,   990,   991,   390,   995,  1004,  1005,
1800      574,  -869,  1006,  1007,  1016,  1017,  1012,  1018,  1020,  1021,
1801     -869,  1022,  -869,   390,  1075,  -869,  1151,  -869,  1144,  1155,
1802     -869,  -869,  1023,  -869,  1024,  1025,  1026,  1158,  1164,   -14,
1803     1165,  -869,  -869,  -869,  1166,  -869,  -869,  -869,  1167,   365,
1804      -14,  1168,  1170,  1171,  -869,  -869,   940,   598,  1030,  1037,
1805     1172,  -869,  1174,  -869,  -869,  1169,  1040,  1041,   598,  -869,
1806      598,   598,  -869,   -14,  -869,  -869,  -869,  -869,   365,  -869,
1807      664,   300,  -869,  -869,  -869,  1042,  1043,   664,  -869,  -869,
1808     -869,   372,  1180,  -869,  1135,  -869,   300,  1182,  -869,  -869,
1809     -869,   940,  -869,  1183,  1184,  1053,  1048,  1062,  1128,  1065,
1810     1064,  1066,  1068,  1067,  1071,  1072,  -869,  -869,  1081,  -869,
1811      596,   635,  1145,  -869,  -869,  -869,  -869,  -869,  -869,  1147,
1812     -869,  -869,  -869,  -869,  -869,  1073,  1076,  1074,  1179,  -869,
1813     1126,  -869,  1077,  1078,   -14,   619,  1121,   -14,  -869,  1094,
1814     1079,   -14,   -14,   -14,  1083,  1195,  1196,  1190,   365,  -869,
1815     1200,  -869,  1162,   -14,   -14,   -14,  1079,  -869,  -869,  -869,
1816     -869,  1085,   954,  1086,  1087,  1102,  -869,  1088,  1089,  1090,
1817     -869,  1080,   843,  -869,   843,  1092,  1218,  -869,  1095,  1097,
1818     -869,  -869,  -869,  -869,  -869,  1096,  1098,  1099,  1100,   350,
1819     -869,  -869,  -869,  -869,  1101,  1215,  1220,  -869,   595,  -869,
1820       84,  -869,   591,  -869,  -869,  -869,   312,   375,  1208,  1105,
1821     1106,   378,   402,   403,   418,   426,   460,   476,   481,   616,
1822     -869,   119,  -869,  1107,   -14,   -14,  1119,  -869,  1123,  -869,
1823     1120,  -869,  1130,  -869,  1131,  -869,  1133,  -869,  1134,  -869,
1824     1136,  -869,  1110,  1112,  1188,  1113,  1114,  1115,  1116,  1117,
1825     1118,  1122,  1124,  1125,  1127,  -869,  -869,  1245,  1079,  1079,
1826     -869,  -869,  -869,  -869,  -869,  -869,  -869,  -869,  -869,  -869,
1827     -869
1828 };
1829
1830 /* YYPGOTO[NTERM-NUM].  */
1831 static const yytype_int16 yypgoto[] =
1832 {
1833     -869,  -869,  -869,  -133,    41,  -216,  -733,  -868,   313,  -869,
1834     -509,  -869,  -198,  -869,  -458,  -460,  -515,  -869,  -804,  -869,
1835     -869,   986,    23,  -869,   -31,  -869,   421,  -205,  -869,  -869,
1836     -253,     2,    22,  -171,   987,  -206,   -56,    46,  -869,   -17,
1837     -869,  -869,  -869,  1247,  -869,   -27,     0
1838 };
1839
1840 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1841    positive, shift that token.  If negative, reduce the rule which
1842    number is the opposite.  If zero, do what YYDEFACT says.
1843    If YYTABLE_NINF, syntax error.  */
1844 #define YYTABLE_NINF -214
1845 static const yytype_int16 yytable[] =
1846 {
1847      106,   107,    70,   109,   111,   113,   355,   115,   116,   119,
1848      122,   128,   130,   132,   173,   176,   379,   359,   134,   117,
1849      117,   374,    71,   660,   302,   428,   431,   604,   603,   304,
1850      605,   662,   239,   232,     7,     8,     7,     8,   157,     7,
1851        8,    68,   420,   174,   294,   295,   410,   262,    77,   398,
1852      153,   404,   306,   242,   409,    78,   373,   266,   267,   195,
1853      197,   199,   233,   856,   236,   238,    76,  -211,  -213,   450,
1854      150,   956,   172,   427,   430,    99,   263,   181,   182,   183,
1855      420,   264,   289,   104,   313,   314,   315,   442,   369,   408,
1856      100,   159,     7,     8,    77,   139,   244,   420,   147,   606,
1857      420,    78,   930,   993,   607,   534,   151,   154,   881,   155,
1858      159,   171,   175,   290,   183,   160,   161,   101,   443,   245,
1859      183,   158,   510,   421,   535,    77,   250,   269,   270,   251,
1860      229,   252,    78,   253,   241,   584,   254,   397,   255,   133,
1861        7,     8,   609,   356,   261,   317,   256,   610,    79,   760,
1862     -211,  -213,   451,    80,    81,   240,   316,   615,   616,    70,
1863      732,   422,    77,   733,    77,   182,   305,   704,   102,    78,
1864      509,    78,   706,    77,   243,   617,    77,   194,   423,    71,
1865       78,   424,   103,    78,   325,   326,   327,   328,   329,   330,
1866      331,   332,   333,   334,    79,   196,   257,   258,    68,    80,
1867       81,   105,   303,   198,  1019,  1020,   307,   308,   309,   310,
1868      108,   312,   963,   964,    77,   123,   181,   182,   124,   775,
1869      776,    78,   965,   966,   777,    79,   135,   183,   235,    77,
1870       80,    81,    77,   394,   259,   778,    78,     7,     8,    78,
1871       77,   294,   295,   395,   718,   719,   720,    78,   163,   625,
1872      628,   530,     7,     8,   296,   297,   592,   125,   164,   127,
1873      183,   531,    79,   441,    79,    77,   445,    80,    81,    80,
1874       81,   447,    78,   260,     7,     8,    79,   140,    80,    81,
1875      164,    80,    81,   129,   237,    77,   461,   462,   463,   131,
1876      666,   466,   165,    77,   396,   467,   473,   624,   627,   166,
1877       78,   470,   136,   770,   360,     7,     8,   137,   167,   168,
1878      169,   471,   170,   771,    79,   173,   176,   576,   361,    80,
1879       81,    77,   518,   468,   486,   487,   488,   469,    78,    79,
1880      383,   384,    79,   141,    80,   110,   385,    80,    81,   571,
1881       79,    77,   520,   572,   522,    80,    81,   142,    78,   146,
1882      294,   295,   459,     7,     8,    77,   519,   521,   523,    77,
1883      870,   143,    78,   296,   426,    79,    78,   874,   727,   144,
1884       80,    81,   728,   536,   537,   538,   387,   388,   292,    77,
1885      293,    77,   389,   152,   547,    79,    78,   156,    78,    77,
1886       80,    81,   145,    79,     7,     8,    78,   875,    80,   112,
1887      554,     7,     8,   557,   729,   559,   560,   561,   730,   563,
1888      564,   565,   148,   941,   506,   942,   569,   511,   294,   295,
1889      149,    79,   162,     7,     8,   164,    80,    81,   525,   526,
1890      527,   296,   429,   585,   186,   320,   321,   159,    77,   190,
1891      191,    79,   160,   505,   784,    78,    80,    81,   785,   544,
1892      491,   492,    70,   294,   295,    79,    77,   579,   580,    79,
1893       80,    81,   178,    78,    80,    81,   296,   508,   180,   969,
1894      954,   955,    71,   970,   623,   718,   719,   720,   234,    79,
1895      268,    79,   635,   246,    80,    81,    80,    81,   265,   114,
1896      247,    68,   632,   248,    80,    81,   578,   578,   374,   249,
1897      409,   200,   201,   202,   271,   203,   204,   622,   205,   206,
1898      207,   208,   209,   210,   294,   295,   138,   272,    94,    95,
1899       96,   211,   273,   212,   213,     7,     8,   296,   626,   214,
1900      274,   215,   971,   275,    77,   976,   972,   809,   120,   977,
1901      812,    78,   646,    80,    81,   647,   648,   184,   276,   186,
1902      697,   277,   188,   189,   190,   191,    79,   280,   216,   978,
1903      980,    80,    81,   979,   981,   217,   278,   708,   709,   710,
1904      218,   219,   220,   192,   193,   982,   814,   815,   816,   983,
1905      221,   222,   223,   984,   287,   224,   279,   985,   184,   185,
1906      186,   187,   281,   188,   189,   190,   191,   734,   186,   857,
1907      737,   188,   189,   190,   191,   871,   282,   294,   295,   306,
1908      865,   283,   866,   867,   192,   193,   291,   986,   225,   226,
1909      879,   987,   748,   749,   700,   515,   516,   284,   400,   401,
1910      402,   705,   261,   988,    79,   403,   285,   989,   990,    80,
1911       81,   301,   991,   765,   296,   665,   184,   185,   186,   187,
1912      286,   188,   189,   190,   191,   306,   896,   288,   227,   228,
1913      311,   781,   300,    80,    81,   343,   344,   322,   345,   318,
1914      294,   346,   192,   193,   347,   348,   349,   350,   323,   347,
1915      348,   349,   350,   723,   724,   324,   754,   755,   362,   799,
1916      821,   351,   352,   353,   825,   826,   186,   756,   757,   188,
1917      189,   190,   191,   789,   294,   295,   184,   836,   186,   187,
1918      335,   188,   189,   190,   191,    93,   336,    94,    95,    96,
1919      192,   193,    97,   363,   772,   337,   907,   908,   909,   910,
1920      961,   962,   192,   193,   967,   968,   954,   955,   338,   786,
1921      787,    86,   578,   358,   364,   339,    87,    88,   365,   340,
1922       89,    90,   847,   366,   341,    91,    92,   367,   375,   342,
1923      356,   376,   368,   852,   393,   377,   378,   380,   382,   386,
1924      390,   391,   392,   399,   411,   405,   406,   412,   407,   414,
1925      417,   413,   416,   418,   419,   415,   868,   440,   432,   425,
1926      433,   434,   444,   435,   446,   436,   437,   438,   453,   454,
1927      464,   465,   439,   455,   456,   474,   457,   448,   449,   458,
1928      460,   475,   476,   477,   478,   479,   480,   481,   482,   483,
1929      484,   485,   489,   490,   494,   498,   496,   499,   500,   501,
1930      851,   502,   503,   493,   512,   504,   513,   517,   507,   514,
1931      524,   528,   529,   533,   532,   539,   541,   540,   543,   553,
1932      542,   546,   548,   549,   545,   550,   551,   906,   552,   869,
1933      913,   555,    -2,     1,   917,   918,   919,   556,   558,   562,
1934      566,   568,   876,     2,   567,   570,   927,   928,   929,   573,
1935      574,   932,   575,   577,   581,     3,     4,     5,   582,     6,
1936      586,     7,     8,     9,    10,    11,    12,    13,    14,    15,
1937       16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
1938       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
1939       36,    37,    38,   583,   587,   593,   590,   597,   602,   591,
1940      594,   588,   598,   612,   589,   595,   596,   619,   599,   924,
1941      600,   601,   620,   613,   618,   621,   614,   995,   996,   629,
1942      631,   640,   663,   664,   668,   670,   688,    39,    40,   691,
1943      676,   637,   630,   679,   690,   638,   641,   636,   692,   695,
1944      639,   642,   693,   694,    41,    42,    43,    44,   649,    45,
1945      643,    46,   644,   650,    47,    48,   651,   687,   159,   707,
1946      698,   652,   653,   711,   712,   713,   714,   654,   699,   655,
1947      656,   657,   658,   661,    49,   610,   715,    50,    51,    52,
1948      675,    53,    54,    55,    56,    57,    58,    59,    60,     2,
1949      667,   669,   671,   716,    61,    62,   672,    63,    64,   673,
1950      674,     3,     4,     5,   677,     6,   678,     7,     8,     9,
1951       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
1952       20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
1953       30,    31,    32,    33,    34,    35,    36,    37,    38,   680,
1954      681,   683,   682,   684,   685,   717,   686,   722,   689,   725,
1955      696,   736,   743,   744,   701,   745,   746,   735,   747,   702,
1956      703,   726,   758,   731,   752,   761,   753,   739,   759,   738,
1957      763,   740,   750,    39,    40,   742,   762,   764,   766,   767,
1958      741,   768,   769,   773,   774,   779,   782,   780,   783,   788,
1959       41,    42,    43,    44,   790,    45,   791,    46,   792,   793,
1960       47,    48,   800,   802,   794,   795,   796,   797,   798,   801,
1961      803,   804,   805,   806,   807,   813,   808,   810,   818,   811,
1962       49,   819,   820,    50,    51,    52,   822,    53,    54,    55,
1963       56,    57,    58,    59,    60,   823,   824,   827,   828,   831,
1964       61,    62,   837,    63,    64,   832,   838,   829,   830,   839,
1965      840,   833,   834,   845,   841,   842,   835,   843,   844,   846,
1966      848,   849,   858,   853,   850,   854,   855,   860,   859,   861,
1967      862,   863,   864,   872,   873,   877,   878,   880,   882,   883,
1968      885,   420,   884,   894,   902,   897,   898,   903,   912,   914,
1969      921,   922,   923,   886,   887,   888,   891,   925,   889,   890,
1970      892,   893,   926,   900,   899,   901,   904,   905,   935,   944,
1971      959,   915,   939,   973,   920,   960,   931,   933,   934,   936,
1972      937,   938,   945,   943,   946,   997,   999,   947,   998,  1007,
1973      948,   950,   952,   958,   974,   975,  1000,  1001,   994,  1002,
1974     1003,  1005,  1004,  1006,  1008,  1009,  1010,  1011,  1012,  1013,
1975     1018,   895,   992,  1014,   121,  1015,  1016,     0,  1017,   452,
1976        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1977        0,     0,     0,     0,     0,     0,     0,     0,     0,   472
1978 };
1979
1980 static const yytype_int16 yycheck[] =
1981 {
1982       27,    28,     0,    30,    31,    32,   211,    34,    35,    36,
1983       37,    42,    43,    44,    70,    71,   232,   215,    45,    36,
1984       37,   227,     0,   538,   157,   278,   279,   487,   486,    25,
1985      488,   540,    25,    89,    29,    30,    29,    30,    77,    29,
1986       30,     0,    83,    70,    69,    70,   262,   103,    62,   254,
1987       25,   256,    71,    27,   260,    69,   227,    25,    26,    86,
1988       87,    88,    89,   796,    91,    92,   162,    77,    77,    77,
1989       27,   939,    70,   278,   279,    97,   103,    77,    78,    79,
1990       83,   108,    25,    25,    90,    91,    92,    25,    25,   260,
1991       97,    97,    29,    30,    62,    49,   142,    83,    57,   157,
1992       83,    69,   906,   971,   162,    68,    63,    82,   841,    63,
1993       97,    70,    71,    56,   114,   102,   103,    97,    56,   165,
1994      120,   160,   375,   164,    87,    62,    15,    25,    26,    18,
1995       89,    20,    69,    22,    93,    35,    25,   162,    27,    25,
1996       29,    30,   157,   162,   103,   172,    35,   162,   162,   664,
1997      160,   160,   160,   167,   168,   148,   162,   124,   125,   157,
1998      620,   164,    62,   621,    62,   165,   162,   162,    97,    69,
1999      375,    69,   162,    62,   148,   142,    62,    25,   164,   157,
2000       69,   164,    97,    69,   184,   185,   186,   187,   188,   189,
2001      190,   191,   192,   193,   162,    25,    85,    86,   157,   167,
2002      168,    25,   161,    25,  1008,  1009,   165,   166,   167,   168,
2003      162,   170,   128,   129,    62,   162,   216,   217,   162,     3,
2004        4,    69,   138,   139,     8,   162,   162,   227,    25,    62,
2005      167,   168,    62,    25,   123,    19,    69,    29,    30,    69,
2006       62,    69,    70,    35,   125,   126,   127,    69,    25,   502,
2007      503,    25,    29,    30,    82,    83,   472,   163,    35,   163,
2008      260,    35,   162,   290,   162,    62,   293,   167,   168,   167,
2009      168,   298,    69,   162,    29,    30,   162,   162,   167,   168,
2010       35,   167,   168,   163,    25,    62,   313,   314,   315,   163,
2011      543,   157,    69,    62,   253,   161,   323,   502,   503,    76,
2012       69,    25,   163,    25,    25,    29,    30,   163,    85,    86,
2013       87,    35,    89,    35,   162,   371,   372,   450,    25,   167,
2014      168,    62,    25,   157,   351,   352,   353,   161,    69,   162,
2015      105,   106,   162,   162,   167,   168,   111,   167,   168,   157,
2016      162,    62,    25,   161,    25,   167,   168,   162,    69,    25,
2017       69,    70,   311,    29,    30,    62,   383,   384,   385,    62,
2018      820,   162,    69,    82,    83,   162,    69,   827,   157,   162,
2019      167,   168,   161,   400,   401,   402,   105,   106,   157,    62,
2020      159,    62,   111,    25,   411,   162,    69,     0,    69,    62,
2021      167,   168,   162,   162,    29,    30,    69,    25,   167,   168,
2022      427,    29,    30,   430,   157,   432,   433,   434,   161,   436,
2023      437,   438,   162,   922,   373,   924,   443,   376,    69,    70,
2024      162,   162,    97,    29,    30,    35,   167,   168,   387,   388,
2025      389,    82,    83,   460,    66,   134,   135,    97,    62,    71,
2026       72,   162,   102,   103,   157,    69,   167,   168,   161,   408,
2027      132,   133,   450,    69,    70,   162,    62,   455,   456,   162,
2028      167,   168,   162,    69,   167,   168,    82,    83,    25,   157,
2029      120,   121,   450,   161,   501,   125,   126,   127,    25,   162,
2030      172,   162,   509,    35,   167,   168,   167,   168,    25,   162,
2031       35,   450,   509,    35,   167,   168,   455,   456,   704,    35,
2032      706,     5,     6,     7,    25,     9,    10,    35,    12,    13,
2033       14,    15,    16,    17,    69,    70,    97,    25,    99,   100,
2034      101,    25,    25,    27,    28,    29,    30,    82,    83,    33,
2035       25,    35,   157,    25,    62,   157,   161,   735,   162,   161,
2036      738,    69,   519,   167,   168,   522,   523,    64,    25,    66,
2037      577,    25,    69,    70,    71,    72,   162,    27,    62,   157,
2038      157,   167,   168,   161,   161,    69,    25,   594,   595,   596,
2039       74,    75,    76,    90,    91,   157,   169,   170,   171,   161,
2040       84,    85,    86,   157,    35,    89,    25,   161,    64,    65,
2041       66,    67,    25,    69,    70,    71,    72,   624,    66,   797,
2042      627,    69,    70,    71,    72,   821,    25,    69,    70,    71,
2043      808,    25,   810,   811,    90,    91,    27,   157,   122,   123,
2044      836,   161,   649,   650,   583,   132,   133,    25,    90,    91,
2045       92,   590,   591,   157,   162,    97,    25,   161,   157,   167,
2046      168,    27,   161,   670,    82,    83,    64,    65,    66,    67,
2047       25,    69,    70,    71,    72,    71,   861,    25,   162,   163,
2048      162,   692,    25,   167,   168,    64,    65,   157,    67,   162,
2049       69,    70,    90,    91,    78,    79,    80,    81,   159,    78,
2050       79,    80,    81,   124,   125,   161,   140,   141,    25,   716,
2051      746,    90,    91,    92,   120,   121,    66,   656,   657,    69,
2052       70,    71,    72,   701,    69,    70,    64,   763,    66,    67,
2053      162,    69,    70,    71,    72,    97,   162,    99,   100,   101,
2054       90,    91,   104,    25,   683,   162,   107,   108,   109,   110,
2055      135,   136,    90,    91,   143,   144,   120,   121,   162,   698,
2056      699,    88,   701,    70,    25,   162,    93,    94,    25,   162,
2057       97,    98,   779,    25,   162,   102,   103,   163,    25,   162,
2058      162,    70,   163,   790,    25,   162,   162,   162,   162,   162,
2059      162,   162,   162,    97,   157,    35,    35,    97,   163,    70,
2060       70,   161,   161,   157,   157,   173,   813,    97,   157,   161,
2061      157,   157,    25,   157,    25,   157,   157,   157,    25,    35,
2062      125,   135,   161,   157,   157,    25,   158,   164,   164,   158,
2063      158,    25,    25,    25,    35,    25,    25,    25,    25,    25,
2064       25,   162,    25,    25,   162,   158,   162,   158,   158,   158,
2065      789,    25,    25,    34,    25,    70,    25,   131,   161,   157,
2066       25,    25,    25,    25,   137,    21,   158,    35,    25,   164,
2067      158,   157,    25,    25,   161,    25,    25,   884,    25,   818,
2068      887,   164,     0,     1,   891,   892,   893,    25,   164,    25,
2069       25,    97,   831,    11,   162,   161,   903,   904,   905,   164,
2070      164,   912,    97,   159,    35,    23,    24,    25,    35,    27,
2071      161,    29,    30,    31,    32,    33,    34,    35,    36,    37,
2072       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
2073       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
2074       58,    59,    60,   157,   161,   157,    97,   157,    25,    97,
2075      159,   135,   157,   161,   134,   159,   159,    35,   157,   898,
2076      157,   157,    35,   161,   142,    35,   157,   974,   975,    25,
2077       25,    25,    35,    35,    35,    91,    25,    95,    96,    25,
2078       97,   157,   161,    97,    97,   157,   161,   164,    97,    25,
2079      157,   161,    97,    97,   112,   113,   114,   115,   157,   117,
2080      161,   119,   162,   157,   122,   123,   161,   130,    97,    25,
2081       69,   157,   157,    25,    35,    25,    35,   161,    76,   162,
2082      162,   162,   162,   162,   142,   162,    25,   145,   146,   147,
2083      164,   149,   150,   151,   152,   153,   154,   155,   156,    11,
2084      161,   161,   161,    90,   162,   163,   161,   165,   166,   161,
2085      161,    23,    24,    25,   164,    27,   164,    29,    30,    31,
2086       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
2087       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
2088       52,    53,    54,    55,    56,    57,    58,    59,    60,   161,
2089      161,   157,   161,   161,   161,    25,   161,    25,   162,    25,
2090      160,    25,    25,    25,   157,    25,    97,   164,   135,   161,
2091      161,   161,   125,   161,    35,    25,    35,   161,    35,   164,
2092       97,   164,   162,    95,    96,   164,   164,    25,    97,    25,
2093      172,    97,    97,   161,   130,   159,    25,   163,    25,   157,
2094      112,   113,   114,   115,   159,   117,   157,   119,   157,   157,
2095      122,   123,    97,    97,   161,   161,   161,   161,   161,   161,
2096      161,   161,    97,   142,   125,    90,   164,   164,    97,   164,
2097      142,   161,   161,   145,   146,   147,   161,   149,   150,   151,
2098      152,   153,   154,   155,   156,   161,   161,   161,   161,   157,
2099      162,   163,    97,   165,   166,   157,    25,   161,   161,    35,
2100       25,   161,   161,    25,   161,   161,   164,   162,   162,    25,
2101       25,    25,   162,    25,    27,    25,    25,    25,   161,    25,
2102       31,   161,   161,   161,   161,    25,    71,    25,    25,    25,
2103      162,    83,   159,   132,    35,    70,    69,    91,    97,   125,
2104       25,    25,    32,   161,   159,   161,   159,    27,   162,   161,
2105      159,   159,    70,   157,   161,   161,   159,   159,   136,    21,
2106       25,   162,   162,    35,   161,    25,   161,   161,   161,   161,
2107      161,   161,   157,   161,   157,   136,   136,   161,   135,    71,
2108      162,   162,   162,   162,   159,   159,   136,   136,   161,   136,
2109      136,   161,   136,   161,   161,   161,   161,   161,   161,   161,
2110       35,   860,   969,   161,    37,   161,   161,    -1,   161,   303,
2111       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
2112       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   322
2113 };
2114
2115 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2116    symbol of state STATE-NUM.  */
2117 static const yytype_uint8 yystos[] =
2118 {
2119        0,     1,    11,    23,    24,    25,    27,    29,    30,    31,
2120       32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
2121       42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
2122       52,    53,    54,    55,    56,    57,    58,    59,    60,    95,
2123       96,   112,   113,   114,   115,   117,   119,   122,   123,   142,
2124      145,   146,   147,   149,   150,   151,   152,   153,   154,   155,
2125      156,   162,   163,   165,   166,   175,   176,   177,   178,   197,
2126      205,   206,   207,   208,   209,   212,   162,    62,    69,   162,
2127      167,   168,   213,   218,   219,   220,    88,    93,    94,    97,
2128       98,   102,   103,    97,    99,   100,   101,   104,   211,    97,
2129       97,    97,    97,    97,    25,    25,   219,   219,   162,   219,
2130      168,   219,   168,   219,   162,   219,   219,   213,   217,   219,
2131      162,   217,   219,   162,   162,   163,   198,   163,   198,   163,
2132      198,   163,   198,    25,   219,   162,   163,   163,    97,   211,
2133      162,   162,   162,   162,   162,   162,    25,   178,   162,   162,
2134       27,    63,    25,    25,    82,   211,     0,    77,   160,    97,
2135      102,   103,    97,    25,    35,    69,    76,    85,    86,    87,
2136       89,   178,   205,   210,   219,   178,   210,   210,   162,   179,
2137       25,   220,   220,   220,    64,    65,    66,    67,    69,    70,
2138       71,    72,    90,    91,    25,   219,    25,   219,    25,   219,
2139        5,     6,     7,     9,    10,    12,    13,    14,    15,    16,
2140       17,    25,    27,    28,    33,    35,    62,    69,    74,    75,
2141       76,    84,    85,    86,    89,   122,   123,   162,   163,   178,
2142      194,   199,   210,   219,    25,    25,   219,    25,   219,    25,
2143      148,   178,    27,   148,   142,   165,    35,    35,    35,    35,
2144       15,    18,    20,    22,    25,    27,    35,    85,    86,   123,
2145      162,   178,   210,   219,   219,    25,    25,    26,   172,    25,
2146       26,    25,    25,    25,    25,    25,    25,    25,    25,    25,
2147       27,    25,    25,    25,    25,    25,    25,    35,    25,    25,
2148       56,    27,   157,   159,    69,    70,    82,    83,   201,   204,
2149       25,    27,   177,   178,    25,   162,    71,   178,   178,   178,
2150      178,   162,   178,    90,    91,    92,   162,   219,   162,   195,
2151      134,   135,   157,   159,   161,   220,   220,   220,   220,   220,
2152      220,   220,   220,   220,   220,   162,   162,   162,   162,   162,
2153      162,   162,   162,    64,    65,    67,    70,    78,    79,    80,
2154       81,    90,    91,    92,   200,   201,   162,   186,    70,   186,
2155       25,    25,    25,    25,    25,    25,    25,   163,   163,    25,
2156      178,   205,   206,   207,   209,    25,    70,   162,   162,   179,
2157      162,   187,   162,   105,   106,   111,   162,   105,   106,   111,
2158      162,   162,   162,    25,    25,    35,   178,   162,   201,    97,
2159       90,    91,    92,    97,   201,    35,    35,   163,   207,   209,
2160      179,   157,    97,   161,    70,   173,   161,    70,   157,   157,
2161       83,   164,   164,   164,   164,   161,    83,   201,   204,    83,
2162      201,   204,   157,   157,   157,   157,   157,   157,   157,   161,
2163       97,   219,    25,    56,    25,   219,    25,   219,   164,   164,
2164       77,   160,   195,    25,    35,   157,   157,   158,   158,   178,
2165      158,   219,   219,   219,   125,   135,   157,   161,   157,   161,
2166       25,    35,   208,   219,    25,    25,    25,    25,    35,    25,
2167       25,    25,    25,    25,    25,   162,   219,   219,   219,    25,
2168       25,   132,   133,    34,   162,   188,   162,   189,   158,   158,
2169      158,   158,    25,    25,    70,   103,   178,   161,    83,   201,
2170      204,   178,    25,    25,   157,   132,   133,   131,    25,   219,
2171       25,   219,    25,   219,    25,   178,   178,   178,    25,    25,
2172       25,    35,   137,    25,    68,    87,   219,   219,   219,    21,
2173       35,   158,   158,    25,   178,   161,   157,   219,    25,    25,
2174       25,    25,    25,   164,   219,   164,    25,   219,   164,   219,
2175      219,   219,    25,   219,   219,   219,    25,   162,    97,   219,
2176      161,   157,   161,   164,   164,    97,   177,   159,   178,   205,
2177      205,    35,    35,   157,    35,   219,   161,   161,   135,   134,
2178       97,    97,   179,   157,   159,   159,   159,   157,   157,   157,
2179      157,   157,    25,   188,   189,   188,   157,   162,   183,   157,
2180      162,   184,   161,   161,   157,   124,   125,   142,   142,    35,
2181       35,    35,    35,   219,   201,   204,    83,   201,   204,    25,
2182      161,    25,   213,   215,   216,   219,   164,   157,   157,   157,
2183       25,   161,   161,   161,   162,   196,   196,   196,   196,   157,
2184      157,   161,   157,   157,   161,   162,   162,   162,   162,   190,
2185      190,   162,   184,    35,    35,    83,   204,   161,    35,   161,
2186       91,   161,   161,   161,   161,   164,    97,   164,   164,    97,
2187      161,   161,   161,   157,   161,   161,   161,   130,    25,   162,
2188       97,    25,    97,    97,    97,    25,   160,   219,    69,    76,
2189      178,   157,   161,   161,   162,   178,   162,    25,   219,   219,
2190      219,    25,    35,    25,    35,    25,    90,    25,   125,   126,
2191      127,   181,    25,   124,   125,    25,   161,   157,   161,   157,
2192      161,   161,   189,   188,   219,   164,    25,   219,   164,   161,
2193      164,   172,   164,    25,    25,    25,    97,   135,   219,   219,
2194      162,   180,    35,    35,   140,   141,   178,   178,   125,    35,
2195      190,    25,   164,    97,    25,   219,    97,    25,    97,    97,
2196       25,    35,   178,   161,   130,     3,     4,     8,    19,   159,
2197      163,   198,    25,    25,   157,   161,   178,   178,   157,   205,
2198      159,   157,   157,   157,   161,   161,   161,   161,   161,   219,
2199       97,   161,    97,   161,   161,    97,   142,   125,   164,   186,
2200      164,   164,   186,    90,   169,   170,   171,   214,    97,   161,
2201      161,   210,   161,   161,   161,   120,   121,   161,   161,   161,
2202      161,   157,   157,   161,   161,   164,   210,    97,    25,    35,
2203       25,   161,   161,   162,   162,    25,    25,   219,    25,    25,
2204       27,   178,   219,    25,    25,    25,   180,   186,   162,   161,
2205       25,    25,    31,   161,   161,   186,   186,   186,   219,   178,
2206      189,   179,   161,   161,   189,    25,   178,    25,    71,   179,
2207       25,   180,    25,    25,   159,   162,   161,   159,   161,   162,
2208      161,   159,   159,   159,   132,   200,   201,    70,    69,   161,
2209      157,   161,    35,    91,   159,   159,   219,   107,   108,   109,
2210      110,   191,    97,   219,   125,   162,   192,   219,   219,   219,
2211      161,    25,    25,    32,   178,    27,    70,   219,   219,   219,
2212      192,   161,   198,   161,   161,   136,   161,   161,   161,   162,
2213      185,   184,   184,   161,    21,   157,   157,   161,   162,   193,
2214      162,   202,   162,   203,   120,   121,   181,   182,   162,    25,
2215       25,   135,   136,   128,   129,   138,   139,   143,   144,   157,
2216      161,   157,   161,    35,   159,   159,   157,   161,   157,   161,
2217      157,   161,   157,   161,   157,   161,   157,   161,   157,   161,
2218      157,   161,   182,   181,   161,   219,   219,   136,   135,   136,
2219      136,   136,   136,   136,   136,   161,   161,    71,   161,   161,
2220      161,   161,   161,   161,   161,   161,   161,   161,    35,   192,
2221      192
2222 };
2223
2224 #define yyerrok         (yyerrstatus = 0)
2225 #define yyclearin       (yychar = YYEMPTY)
2226 #define YYEMPTY         (-2)
2227 #define YYEOF           0
2228
2229 #define YYACCEPT        goto yyacceptlab
2230 #define YYABORT         goto yyabortlab
2231 #define YYERROR         goto yyerrorlab
2232
2233
2234 /* Like YYERROR except do call yyerror.  This remains here temporarily
2235    to ease the transition to the new meaning of YYERROR, for GCC.
2236    Once GCC version 2 has supplanted version 1, this can go.  */
2237
2238 #define YYFAIL          goto yyerrlab
2239
2240 #define YYRECOVERING()  (!!yyerrstatus)
2241
2242 #define YYBACKUP(Token, Value)                                  \
2243 do                                                              \
2244   if (yychar == YYEMPTY && yylen == 1)                          \
2245     {                                                           \
2246       yychar = (Token);                                         \
2247       yylval = (Value);                                         \
2248       yytoken = YYTRANSLATE (yychar);                           \
2249       YYPOPSTACK (1);                                           \
2250       goto yybackup;                                            \
2251     }                                                           \
2252   else                                                          \
2253     {                                                           \
2254       yyerror (YY_("syntax error: cannot back up")); \
2255       YYERROR;                                                  \
2256     }                                                           \
2257 while (YYID (0))
2258
2259
2260 #define YYTERROR        1
2261 #define YYERRCODE       256
2262
2263
2264 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2265    If N is 0, then set CURRENT to the empty location which ends
2266    the previous symbol: RHS[0] (always defined).  */
2267
2268 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2269 #ifndef YYLLOC_DEFAULT
2270 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
2271     do                                                                  \
2272       if (YYID (N))                                                    \
2273         {                                                               \
2274           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
2275           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
2276           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
2277           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
2278         }                                                               \
2279       else                                                              \
2280         {                                                               \
2281           (Current).first_line   = (Current).last_line   =              \
2282             YYRHSLOC (Rhs, 0).last_line;                                \
2283           (Current).first_column = (Current).last_column =              \
2284             YYRHSLOC (Rhs, 0).last_column;                              \
2285         }                                                               \
2286     while (YYID (0))
2287 #endif
2288
2289
2290 /* YY_LOCATION_PRINT -- Print the location on the stream.
2291    This macro was not mandated originally: define only if we know
2292    we won't break user code: when these are the locations we know.  */
2293
2294 #ifndef YY_LOCATION_PRINT
2295 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2296 #  define YY_LOCATION_PRINT(File, Loc)                  \
2297      fprintf (File, "%d.%d-%d.%d",                      \
2298               (Loc).first_line, (Loc).first_column,     \
2299               (Loc).last_line,  (Loc).last_column)
2300 # else
2301 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2302 # endif
2303 #endif
2304
2305
2306 /* YYLEX -- calling `yylex' with the right arguments.  */
2307
2308 #ifdef YYLEX_PARAM
2309 # define YYLEX yylex (YYLEX_PARAM)
2310 #else
2311 # define YYLEX yylex ()
2312 #endif
2313
2314 /* Enable debugging if requested.  */
2315 #if YYDEBUG
2316
2317 # ifndef YYFPRINTF
2318 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2319 #  define YYFPRINTF fprintf
2320 # endif
2321
2322 # define YYDPRINTF(Args)                        \
2323 do {                                            \
2324   if (yydebug)                                  \
2325     YYFPRINTF Args;                             \
2326 } while (YYID (0))
2327
2328 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
2329 do {                                                                      \
2330   if (yydebug)                                                            \
2331     {                                                                     \
2332       YYFPRINTF (stderr, "%s ", Title);                                   \
2333       yy_symbol_print (stderr,                                            \
2334                   Type, Value); \
2335       YYFPRINTF (stderr, "\n");                                           \
2336     }                                                                     \
2337 } while (YYID (0))
2338
2339
2340 /*--------------------------------.
2341 | Print this symbol on YYOUTPUT.  |
2342 `--------------------------------*/
2343
2344 /*ARGSUSED*/
2345 #if (defined __STDC__ || defined __C99__FUNC__ \
2346      || defined __cplusplus || defined _MSC_VER)
2347 static void
2348 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2349 #else
2350 static void
2351 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
2352     FILE *yyoutput;
2353     int yytype;
2354     YYSTYPE const * const yyvaluep;
2355 #endif
2356 {
2357   if (!yyvaluep)
2358     return;
2359 # ifdef YYPRINT
2360   if (yytype < YYNTOKENS)
2361     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2362 # else
2363   YYUSE (yyoutput);
2364 # endif
2365   switch (yytype)
2366     {
2367       default:
2368         break;
2369     }
2370 }
2371
2372
2373 /*--------------------------------.
2374 | Print this symbol on YYOUTPUT.  |
2375 `--------------------------------*/
2376
2377 #if (defined __STDC__ || defined __C99__FUNC__ \
2378      || defined __cplusplus || defined _MSC_VER)
2379 static void
2380 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2381 #else
2382 static void
2383 yy_symbol_print (yyoutput, yytype, yyvaluep)
2384     FILE *yyoutput;
2385     int yytype;
2386     YYSTYPE const * const yyvaluep;
2387 #endif
2388 {
2389   if (yytype < YYNTOKENS)
2390     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2391   else
2392     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2393
2394   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
2395   YYFPRINTF (yyoutput, ")");
2396 }
2397
2398 /*------------------------------------------------------------------.
2399 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2400 | TOP (included).                                                   |
2401 `------------------------------------------------------------------*/
2402
2403 #if (defined __STDC__ || defined __C99__FUNC__ \
2404      || defined __cplusplus || defined _MSC_VER)
2405 static void
2406 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
2407 #else
2408 static void
2409 yy_stack_print (bottom, top)
2410     yytype_int16 *bottom;
2411     yytype_int16 *top;
2412 #endif
2413 {
2414   YYFPRINTF (stderr, "Stack now");
2415   for (; bottom <= top; ++bottom)
2416     YYFPRINTF (stderr, " %d", *bottom);
2417   YYFPRINTF (stderr, "\n");
2418 }
2419
2420 # define YY_STACK_PRINT(Bottom, Top)                            \
2421 do {                                                            \
2422   if (yydebug)                                                  \
2423     yy_stack_print ((Bottom), (Top));                           \
2424 } while (YYID (0))
2425
2426
2427 /*------------------------------------------------.
2428 | Report that the YYRULE is going to be reduced.  |
2429 `------------------------------------------------*/
2430
2431 #if (defined __STDC__ || defined __C99__FUNC__ \
2432      || defined __cplusplus || defined _MSC_VER)
2433 static void
2434 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
2435 #else
2436 static void
2437 yy_reduce_print (yyvsp, yyrule)
2438     YYSTYPE *yyvsp;
2439     int yyrule;
2440 #endif
2441 {
2442   int yynrhs = yyr2[yyrule];
2443   int yyi;
2444   unsigned long int yylno = yyrline[yyrule];
2445   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2446              yyrule - 1, yylno);
2447   /* The symbols being reduced.  */
2448   for (yyi = 0; yyi < yynrhs; yyi++)
2449     {
2450       fprintf (stderr, "   $%d = ", yyi + 1);
2451       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
2452                        &(yyvsp[(yyi + 1) - (yynrhs)])
2453                                        );
2454       fprintf (stderr, "\n");
2455     }
2456 }
2457
2458 # define YY_REDUCE_PRINT(Rule)          \
2459 do {                                    \
2460   if (yydebug)                          \
2461     yy_reduce_print (yyvsp, Rule); \
2462 } while (YYID (0))
2463
2464 /* Nonzero means print parse trace.  It is left uninitialized so that
2465    multiple parsers can coexist.  */
2466 int yydebug;
2467 #else /* !YYDEBUG */
2468 # define YYDPRINTF(Args)
2469 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2470 # define YY_STACK_PRINT(Bottom, Top)
2471 # define YY_REDUCE_PRINT(Rule)
2472 #endif /* !YYDEBUG */
2473
2474
2475 /* YYINITDEPTH -- initial size of the parser's stacks.  */
2476 #ifndef YYINITDEPTH
2477 # define YYINITDEPTH 200
2478 #endif
2479
2480 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2481    if the built-in stack extension method is used).
2482
2483    Do not make this value too large; the results are undefined if
2484    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2485    evaluated with infinite-precision integer arithmetic.  */
2486
2487 #ifndef YYMAXDEPTH
2488 # define YYMAXDEPTH 10000
2489 #endif
2490
2491 \f
2492
2493 #if YYERROR_VERBOSE
2494
2495 # ifndef yystrlen
2496 #  if defined __GLIBC__ && defined _STRING_H
2497 #   define yystrlen strlen
2498 #  else
2499 /* Return the length of YYSTR.  */
2500 #if (defined __STDC__ || defined __C99__FUNC__ \
2501      || defined __cplusplus || defined _MSC_VER)
2502 static YYSIZE_T
2503 yystrlen (const char *yystr)
2504 #else
2505 static YYSIZE_T
2506 yystrlen (yystr)
2507     const char *yystr;
2508 #endif
2509 {
2510   YYSIZE_T yylen;
2511   for (yylen = 0; yystr[yylen]; yylen++)
2512     continue;
2513   return yylen;
2514 }
2515 #  endif
2516 # endif
2517
2518 # ifndef yystpcpy
2519 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2520 #   define yystpcpy stpcpy
2521 #  else
2522 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2523    YYDEST.  */
2524 #if (defined __STDC__ || defined __C99__FUNC__ \
2525      || defined __cplusplus || defined _MSC_VER)
2526 static char *
2527 yystpcpy (char *yydest, const char *yysrc)
2528 #else
2529 static char *
2530 yystpcpy (yydest, yysrc)
2531     char *yydest;
2532     const char *yysrc;
2533 #endif
2534 {
2535   char *yyd = yydest;
2536   const char *yys = yysrc;
2537
2538   while ((*yyd++ = *yys++) != '\0')
2539     continue;
2540
2541   return yyd - 1;
2542 }
2543 #  endif
2544 # endif
2545
2546 # ifndef yytnamerr
2547 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2548    quotes and backslashes, so that it's suitable for yyerror.  The
2549    heuristic is that double-quoting is unnecessary unless the string
2550    contains an apostrophe, a comma, or backslash (other than
2551    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
2552    null, do not copy; instead, return the length of what the result
2553    would have been.  */
2554 static YYSIZE_T
2555 yytnamerr (char *yyres, const char *yystr)
2556 {
2557   if (*yystr == '"')
2558     {
2559       YYSIZE_T yyn = 0;
2560       char const *yyp = yystr;
2561
2562       for (;;)
2563         switch (*++yyp)
2564           {
2565           case '\'':
2566           case ',':
2567             goto do_not_strip_quotes;
2568
2569           case '\\':
2570             if (*++yyp != '\\')
2571               goto do_not_strip_quotes;
2572             /* Fall through.  */
2573           default:
2574             if (yyres)
2575               yyres[yyn] = *yyp;
2576             yyn++;
2577             break;
2578
2579           case '"':
2580             if (yyres)
2581               yyres[yyn] = '\0';
2582             return yyn;
2583           }
2584     do_not_strip_quotes: ;
2585     }
2586
2587   if (! yyres)
2588     return yystrlen (yystr);
2589
2590   return yystpcpy (yyres, yystr) - yyres;
2591 }
2592 # endif
2593
2594 /* Copy into YYRESULT an error message about the unexpected token
2595    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
2596    including the terminating null byte.  If YYRESULT is null, do not
2597    copy anything; just return the number of bytes that would be
2598    copied.  As a special case, return 0 if an ordinary "syntax error"
2599    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
2600    size calculation.  */
2601 static YYSIZE_T
2602 yysyntax_error (char *yyresult, int yystate, int yychar)
2603 {
2604   int yyn = yypact[yystate];
2605
2606   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
2607     return 0;
2608   else
2609     {
2610       int yytype = YYTRANSLATE (yychar);
2611       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2612       YYSIZE_T yysize = yysize0;
2613       YYSIZE_T yysize1;
2614       int yysize_overflow = 0;
2615       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2616       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2617       int yyx;
2618
2619 # if 0
2620       /* This is so xgettext sees the translatable formats that are
2621          constructed on the fly.  */
2622       YY_("syntax error, unexpected %s");
2623       YY_("syntax error, unexpected %s, expecting %s");
2624       YY_("syntax error, unexpected %s, expecting %s or %s");
2625       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
2626       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
2627 # endif
2628       char *yyfmt;
2629       char const *yyf;
2630       static char const yyunexpected[] = "syntax error, unexpected %s";
2631       static char const yyexpecting[] = ", expecting %s";
2632       static char const yyor[] = " or %s";
2633       char yyformat[sizeof yyunexpected
2634                     + sizeof yyexpecting - 1
2635                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2636                        * (sizeof yyor - 1))];
2637       char const *yyprefix = yyexpecting;
2638
2639       /* Start YYX at -YYN if negative to avoid negative indexes in
2640          YYCHECK.  */
2641       int yyxbegin = yyn < 0 ? -yyn : 0;
2642
2643       /* Stay within bounds of both yycheck and yytname.  */
2644       int yychecklim = YYLAST - yyn + 1;
2645       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2646       int yycount = 1;
2647
2648       yyarg[0] = yytname[yytype];
2649       yyfmt = yystpcpy (yyformat, yyunexpected);
2650
2651       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2652         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2653           {
2654             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2655               {
2656                 yycount = 1;
2657                 yysize = yysize0;
2658                 yyformat[sizeof yyunexpected - 1] = '\0';
2659                 break;
2660               }
2661             yyarg[yycount++] = yytname[yyx];
2662             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2663             yysize_overflow |= (yysize1 < yysize);
2664             yysize = yysize1;
2665             yyfmt = yystpcpy (yyfmt, yyprefix);
2666             yyprefix = yyor;
2667           }
2668
2669       yyf = YY_(yyformat);
2670       yysize1 = yysize + yystrlen (yyf);
2671       yysize_overflow |= (yysize1 < yysize);
2672       yysize = yysize1;
2673
2674       if (yysize_overflow)
2675         return YYSIZE_MAXIMUM;
2676
2677       if (yyresult)
2678         {
2679           /* Avoid sprintf, as that infringes on the user's name space.
2680              Don't have undefined behavior even if the translation
2681              produced a string with the wrong number of "%s"s.  */
2682           char *yyp = yyresult;
2683           int yyi = 0;
2684           while ((*yyp = *yyf) != '\0')
2685             {
2686               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2687                 {
2688                   yyp += yytnamerr (yyp, yyarg[yyi++]);
2689                   yyf += 2;
2690                 }
2691               else
2692                 {
2693                   yyp++;
2694                   yyf++;
2695                 }
2696             }
2697         }
2698       return yysize;
2699     }
2700 }
2701 #endif /* YYERROR_VERBOSE */
2702 \f
2703
2704 /*-----------------------------------------------.
2705 | Release the memory associated to this symbol.  |
2706 `-----------------------------------------------*/
2707
2708 /*ARGSUSED*/
2709 #if (defined __STDC__ || defined __C99__FUNC__ \
2710      || defined __cplusplus || defined _MSC_VER)
2711 static void
2712 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2713 #else
2714 static void
2715 yydestruct (yymsg, yytype, yyvaluep)
2716     const char *yymsg;
2717     int yytype;
2718     YYSTYPE *yyvaluep;
2719 #endif
2720 {
2721   YYUSE (yyvaluep);
2722
2723   if (!yymsg)
2724     yymsg = "Deleting";
2725   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2726
2727   switch (yytype)
2728     {
2729
2730       default:
2731         break;
2732     }
2733 }
2734 \f
2735
2736 /* Prevent warnings from -Wmissing-prototypes.  */
2737
2738 #ifdef YYPARSE_PARAM
2739 #if defined __STDC__ || defined __cplusplus
2740 int yyparse (void *YYPARSE_PARAM);
2741 #else
2742 int yyparse ();
2743 #endif
2744 #else /* ! YYPARSE_PARAM */
2745 #if defined __STDC__ || defined __cplusplus
2746 int yyparse (void);
2747 #else
2748 int yyparse ();
2749 #endif
2750 #endif /* ! YYPARSE_PARAM */
2751
2752
2753
2754 /* The look-ahead symbol.  */
2755 int yychar;
2756
2757 /* The semantic value of the look-ahead symbol.  */
2758 YYSTYPE yylval;
2759
2760 /* Number of syntax errors so far.  */
2761 int yynerrs;
2762
2763
2764
2765 /*----------.
2766 | yyparse.  |
2767 `----------*/
2768
2769 #ifdef YYPARSE_PARAM
2770 #if (defined __STDC__ || defined __C99__FUNC__ \
2771      || defined __cplusplus || defined _MSC_VER)
2772 int
2773 yyparse (void *YYPARSE_PARAM)
2774 #else
2775 int
2776 yyparse (YYPARSE_PARAM)
2777     void *YYPARSE_PARAM;
2778 #endif
2779 #else /* ! YYPARSE_PARAM */
2780 #if (defined __STDC__ || defined __C99__FUNC__ \
2781      || defined __cplusplus || defined _MSC_VER)
2782 int
2783 yyparse (void)
2784 #else
2785 int
2786 yyparse ()
2787
2788 #endif
2789 #endif
2790 {
2791   
2792   int yystate;
2793   int yyn;
2794   int yyresult;
2795   /* Number of tokens to shift before error messages enabled.  */
2796   int yyerrstatus;
2797   /* Look-ahead token as an internal (translated) token number.  */
2798   int yytoken = 0;
2799 #if YYERROR_VERBOSE
2800   /* Buffer for error messages, and its allocated size.  */
2801   char yymsgbuf[128];
2802   char *yymsg = yymsgbuf;
2803   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2804 #endif
2805
2806   /* Three stacks and their tools:
2807      `yyss': related to states,
2808      `yyvs': related to semantic values,
2809      `yyls': related to locations.
2810
2811      Refer to the stacks thru separate pointers, to allow yyoverflow
2812      to reallocate them elsewhere.  */
2813
2814   /* The state stack.  */
2815   yytype_int16 yyssa[YYINITDEPTH];
2816   yytype_int16 *yyss = yyssa;
2817   yytype_int16 *yyssp;
2818
2819   /* The semantic value stack.  */
2820   YYSTYPE yyvsa[YYINITDEPTH];
2821   YYSTYPE *yyvs = yyvsa;
2822   YYSTYPE *yyvsp;
2823
2824
2825
2826 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
2827
2828   YYSIZE_T yystacksize = YYINITDEPTH;
2829
2830   /* The variables used to return semantic value and location from the
2831      action routines.  */
2832   YYSTYPE yyval;
2833
2834
2835   /* The number of symbols on the RHS of the reduced rule.
2836      Keep to zero when no symbol should be popped.  */
2837   int yylen = 0;
2838
2839   YYDPRINTF ((stderr, "Starting parse\n"));
2840
2841   yystate = 0;
2842   yyerrstatus = 0;
2843   yynerrs = 0;
2844   yychar = YYEMPTY;             /* Cause a token to be read.  */
2845
2846   /* Initialize stack pointers.
2847      Waste one element of value and location stack
2848      so that they stay on the same level as the state stack.
2849      The wasted elements are never initialized.  */
2850
2851   yyssp = yyss;
2852   yyvsp = yyvs;
2853
2854   goto yysetstate;
2855
2856 /*------------------------------------------------------------.
2857 | yynewstate -- Push a new state, which is found in yystate.  |
2858 `------------------------------------------------------------*/
2859  yynewstate:
2860   /* In all cases, when you get here, the value and location stacks
2861      have just been pushed.  So pushing a state here evens the stacks.  */
2862   yyssp++;
2863
2864  yysetstate:
2865   *yyssp = yystate;
2866
2867   if (yyss + yystacksize - 1 <= yyssp)
2868     {
2869       /* Get the current used size of the three stacks, in elements.  */
2870       YYSIZE_T yysize = yyssp - yyss + 1;
2871
2872 #ifdef yyoverflow
2873       {
2874         /* Give user a chance to reallocate the stack.  Use copies of
2875            these so that the &'s don't force the real ones into
2876            memory.  */
2877         YYSTYPE *yyvs1 = yyvs;
2878         yytype_int16 *yyss1 = yyss;
2879
2880
2881         /* Each stack pointer address is followed by the size of the
2882            data in use in that stack, in bytes.  This used to be a
2883            conditional around just the two extra args, but that might
2884            be undefined if yyoverflow is a macro.  */
2885         yyoverflow (YY_("memory exhausted"),
2886                     &yyss1, yysize * sizeof (*yyssp),
2887                     &yyvs1, yysize * sizeof (*yyvsp),
2888
2889                     &yystacksize);
2890
2891         yyss = yyss1;
2892         yyvs = yyvs1;
2893       }
2894 #else /* no yyoverflow */
2895 # ifndef YYSTACK_RELOCATE
2896       goto yyexhaustedlab;
2897 # else
2898       /* Extend the stack our own way.  */
2899       if (YYMAXDEPTH <= yystacksize)
2900         goto yyexhaustedlab;
2901       yystacksize *= 2;
2902       if (YYMAXDEPTH < yystacksize)
2903         yystacksize = YYMAXDEPTH;
2904
2905       {
2906         yytype_int16 *yyss1 = yyss;
2907         union yyalloc *yyptr =
2908           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2909         if (! yyptr)
2910           goto yyexhaustedlab;
2911         YYSTACK_RELOCATE (yyss);
2912         YYSTACK_RELOCATE (yyvs);
2913
2914 #  undef YYSTACK_RELOCATE
2915         if (yyss1 != yyssa)
2916           YYSTACK_FREE (yyss1);
2917       }
2918 # endif
2919 #endif /* no yyoverflow */
2920
2921       yyssp = yyss + yysize - 1;
2922       yyvsp = yyvs + yysize - 1;
2923
2924
2925       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2926                   (unsigned long int) yystacksize));
2927
2928       if (yyss + yystacksize - 1 <= yyssp)
2929         YYABORT;
2930     }
2931
2932   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2933
2934   goto yybackup;
2935
2936 /*-----------.
2937 | yybackup.  |
2938 `-----------*/
2939 yybackup:
2940
2941   /* Do appropriate processing given the current state.  Read a
2942      look-ahead token if we need one and don't already have one.  */
2943
2944   /* First try to decide what to do without reference to look-ahead token.  */
2945   yyn = yypact[yystate];
2946   if (yyn == YYPACT_NINF)
2947     goto yydefault;
2948
2949   /* Not known => get a look-ahead token if don't already have one.  */
2950
2951   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
2952   if (yychar == YYEMPTY)
2953     {
2954       YYDPRINTF ((stderr, "Reading a token: "));
2955       yychar = YYLEX;
2956     }
2957
2958   if (yychar <= YYEOF)
2959     {
2960       yychar = yytoken = YYEOF;
2961       YYDPRINTF ((stderr, "Now at end of input.\n"));
2962     }
2963   else
2964     {
2965       yytoken = YYTRANSLATE (yychar);
2966       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2967     }
2968
2969   /* If the proper action on seeing token YYTOKEN is to reduce or to
2970      detect an error, take that action.  */
2971   yyn += yytoken;
2972   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2973     goto yydefault;
2974   yyn = yytable[yyn];
2975   if (yyn <= 0)
2976     {
2977       if (yyn == 0 || yyn == YYTABLE_NINF)
2978         goto yyerrlab;
2979       yyn = -yyn;
2980       goto yyreduce;
2981     }
2982
2983   if (yyn == YYFINAL)
2984     YYACCEPT;
2985
2986   /* Count tokens shifted since error; after three, turn off error
2987      status.  */
2988   if (yyerrstatus)
2989     yyerrstatus--;
2990
2991   /* Shift the look-ahead token.  */
2992   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2993
2994   /* Discard the shifted token unless it is eof.  */
2995   if (yychar != YYEOF)
2996     yychar = YYEMPTY;
2997
2998   yystate = yyn;
2999   *++yyvsp = yylval;
3000
3001   goto yynewstate;
3002
3003
3004 /*-----------------------------------------------------------.
3005 | yydefault -- do the default action for the current state.  |
3006 `-----------------------------------------------------------*/
3007 yydefault:
3008   yyn = yydefact[yystate];
3009   if (yyn == 0)
3010     goto yyerrlab;
3011   goto yyreduce;
3012
3013
3014 /*-----------------------------.
3015 | yyreduce -- Do a reduction.  |
3016 `-----------------------------*/
3017 yyreduce:
3018   /* yyn is the number of a rule to reduce with.  */
3019   yylen = yyr2[yyn];
3020
3021   /* If YYLEN is nonzero, implement the default value of the action:
3022      `$$ = $1'.
3023
3024      Otherwise, the following line sets YYVAL to garbage.
3025      This behavior is undocumented and Bison
3026      users should not rely upon it.  Assigning to YYVAL
3027      unconditionally makes the parser a bit smaller, and it avoids a
3028      GCC warning that YYVAL may be used uninitialized.  */
3029   yyval = yyvsp[1-yylen];
3030
3031
3032   YY_REDUCE_PRINT (yyn);
3033   switch (yyn)
3034     {
3035         case 3:
3036 #line 649 "bfin-parse.y"
3037     {
3038           insn = (yyvsp[(1) - (1)].instr);
3039           if (insn == (INSTR_T) 0)
3040             return NO_INSN_GENERATED;
3041           else if (insn == (INSTR_T) - 1)
3042             return SEMANTIC_ERROR;
3043           else
3044             return INSN_GENERATED;
3045         }
3046     break;
3047
3048   case 5:
3049 #line 663 "bfin-parse.y"
3050     {
3051           if (((yyvsp[(1) - (6)].instr)->value & 0xf800) == 0xc000)
3052             {
3053               if (is_group1 ((yyvsp[(3) - (6)].instr)) && is_group2 ((yyvsp[(5) - (6)].instr)))
3054                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(1) - (6)].instr), (yyvsp[(3) - (6)].instr), (yyvsp[(5) - (6)].instr));
3055               else if (is_group2 ((yyvsp[(3) - (6)].instr)) && is_group1 ((yyvsp[(5) - (6)].instr)))
3056                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(1) - (6)].instr), (yyvsp[(5) - (6)].instr), (yyvsp[(3) - (6)].instr));
3057               else
3058                 return yyerror ("Wrong 16 bit instructions groups, slot 2 and slot 3 must be 16-bit instrution group");
3059             }
3060           else if (((yyvsp[(3) - (6)].instr)->value & 0xf800) == 0xc000)
3061             {
3062               if (is_group1 ((yyvsp[(1) - (6)].instr)) && is_group2 ((yyvsp[(5) - (6)].instr)))
3063                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(3) - (6)].instr), (yyvsp[(1) - (6)].instr), (yyvsp[(5) - (6)].instr));
3064               else if (is_group2 ((yyvsp[(1) - (6)].instr)) && is_group1 ((yyvsp[(5) - (6)].instr)))
3065                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(3) - (6)].instr), (yyvsp[(5) - (6)].instr), (yyvsp[(1) - (6)].instr));
3066               else
3067                 return yyerror ("Wrong 16 bit instructions groups, slot 1 and slot 3 must be 16-bit instrution group");
3068             }
3069           else if (((yyvsp[(5) - (6)].instr)->value & 0xf800) == 0xc000)
3070             {
3071               if (is_group1 ((yyvsp[(1) - (6)].instr)) && is_group2 ((yyvsp[(3) - (6)].instr)))
3072                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(5) - (6)].instr), (yyvsp[(1) - (6)].instr), (yyvsp[(3) - (6)].instr));
3073               else if (is_group2 ((yyvsp[(1) - (6)].instr)) && is_group1 ((yyvsp[(3) - (6)].instr)))
3074                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(5) - (6)].instr), (yyvsp[(3) - (6)].instr), (yyvsp[(1) - (6)].instr));
3075               else
3076                 return yyerror ("Wrong 16 bit instructions groups, slot 1 and slot 2 must be 16-bit instrution group");
3077             }
3078           else
3079             error ("\nIllegal Multi Issue Construct, at least any one of the slot must be DSP32 instruction group\n");
3080         }
3081     break;
3082
3083   case 6:
3084 #line 696 "bfin-parse.y"
3085     {
3086           if (((yyvsp[(1) - (4)].instr)->value & 0xf800) == 0xc000)
3087             {
3088               if (is_group1 ((yyvsp[(3) - (4)].instr)))
3089                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(1) - (4)].instr), (yyvsp[(3) - (4)].instr), 0);
3090               else if (is_group2 ((yyvsp[(3) - (4)].instr)))
3091                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(1) - (4)].instr), 0, (yyvsp[(3) - (4)].instr));
3092               else
3093                 return yyerror ("Wrong 16 bit instructions groups, slot 2 must be the 16-bit instruction group");
3094             }
3095           else if (((yyvsp[(3) - (4)].instr)->value & 0xf800) == 0xc000)
3096             {
3097               if (is_group1 ((yyvsp[(1) - (4)].instr)))
3098                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(3) - (4)].instr), (yyvsp[(1) - (4)].instr), 0);
3099               else if (is_group2 ((yyvsp[(1) - (4)].instr)))
3100                 (yyval.instr) = gen_multi_instr_1 ((yyvsp[(3) - (4)].instr), 0, (yyvsp[(1) - (4)].instr));
3101               else
3102                 return yyerror ("Wrong 16 bit instructions groups, slot 1 must be the 16-bit instruction group");
3103             }
3104           else if (is_group1 ((yyvsp[(1) - (4)].instr)) && is_group2 ((yyvsp[(3) - (4)].instr)))
3105               (yyval.instr) = gen_multi_instr_1 (0, (yyvsp[(1) - (4)].instr), (yyvsp[(3) - (4)].instr));
3106           else if (is_group2 ((yyvsp[(1) - (4)].instr)) && is_group1 ((yyvsp[(3) - (4)].instr)))
3107             (yyval.instr) = gen_multi_instr_1 (0, (yyvsp[(3) - (4)].instr), (yyvsp[(1) - (4)].instr));
3108           else
3109             return yyerror ("Wrong 16 bit instructions groups, slot 1 and slot 2 must be the 16-bit instruction group");
3110         }
3111     break;
3112
3113   case 7:
3114 #line 723 "bfin-parse.y"
3115     {
3116         (yyval.instr) = 0;
3117         yyerror ("");
3118         yyerrok;
3119         }
3120     break;
3121
3122   case 8:
3123 #line 734 "bfin-parse.y"
3124     {
3125           (yyval.instr) = DSP32MAC (3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
3126         }
3127     break;
3128
3129   case 9:
3130 #line 738 "bfin-parse.y"
3131     {
3132           int op0, op1;
3133           int w0 = 0, w1 = 0;
3134           int h00, h10, h01, h11;
3135
3136           if (check_macfunc_option (&(yyvsp[(1) - (2)].macfunc), &(yyvsp[(2) - (2)].mod)) < 0)
3137             return yyerror ("bad option");
3138
3139           if ((yyvsp[(1) - (2)].macfunc).n == 0)
3140             {
3141               if ((yyvsp[(2) - (2)].mod).MM)
3142                 return yyerror ("(m) not allowed with a0 unit");
3143               op1 = 3;
3144               op0 = (yyvsp[(1) - (2)].macfunc).op;
3145               w1 = 0;
3146               w0 = (yyvsp[(1) - (2)].macfunc).w;
3147               h00 = IS_H ((yyvsp[(1) - (2)].macfunc).s0);
3148               h10 = IS_H ((yyvsp[(1) - (2)].macfunc).s1);
3149               h01 = h11 = 0;
3150             }
3151           else
3152             {
3153               op1 = (yyvsp[(1) - (2)].macfunc).op;
3154               op0 = 3;
3155               w1 = (yyvsp[(1) - (2)].macfunc).w;
3156               w0 = 0;
3157               h00 = h10 = 0;
3158               h01 = IS_H ((yyvsp[(1) - (2)].macfunc).s0);
3159               h11 = IS_H ((yyvsp[(1) - (2)].macfunc).s1);
3160             }
3161           (yyval.instr) = DSP32MAC (op1, (yyvsp[(2) - (2)].mod).MM, (yyvsp[(2) - (2)].mod).mod, w1, (yyvsp[(1) - (2)].macfunc).P, h01, h11, h00, h10,
3162                          &(yyvsp[(1) - (2)].macfunc).dst, op0, &(yyvsp[(1) - (2)].macfunc).s0, &(yyvsp[(1) - (2)].macfunc).s1, w0);
3163         }
3164     break;
3165
3166   case 10:
3167 #line 776 "bfin-parse.y"
3168     {
3169           Register *dst;
3170
3171           if (check_macfuncs (&(yyvsp[(1) - (5)].macfunc), &(yyvsp[(2) - (5)].mod), &(yyvsp[(4) - (5)].macfunc), &(yyvsp[(5) - (5)].mod)) < 0)
3172             return -1;
3173           notethat ("assign_macfunc (.), assign_macfunc (.)\n");
3174
3175           if ((yyvsp[(1) - (5)].macfunc).w)
3176             dst = &(yyvsp[(1) - (5)].macfunc).dst;
3177           else
3178             dst = &(yyvsp[(4) - (5)].macfunc).dst;
3179
3180           (yyval.instr) = DSP32MAC ((yyvsp[(1) - (5)].macfunc).op, (yyvsp[(2) - (5)].mod).MM, (yyvsp[(5) - (5)].mod).mod, (yyvsp[(1) - (5)].macfunc).w, (yyvsp[(1) - (5)].macfunc).P,
3181                          IS_H ((yyvsp[(1) - (5)].macfunc).s0),  IS_H ((yyvsp[(1) - (5)].macfunc).s1), IS_H ((yyvsp[(4) - (5)].macfunc).s0), IS_H ((yyvsp[(4) - (5)].macfunc).s1),
3182                          dst, (yyvsp[(4) - (5)].macfunc).op, &(yyvsp[(1) - (5)].macfunc).s0, &(yyvsp[(1) - (5)].macfunc).s1, (yyvsp[(4) - (5)].macfunc).w);
3183         }
3184     break;
3185
3186   case 11:
3187 #line 796 "bfin-parse.y"
3188     {
3189           notethat ("dsp32alu: DISALGNEXCPT\n");
3190           (yyval.instr) = DSP32ALU (18, 0, 0, 0, 0, 0, 0, 0, 3);
3191         }
3192     break;
3193
3194   case 12:
3195 #line 801 "bfin-parse.y"
3196     {
3197           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && !IS_A1 ((yyvsp[(4) - (6)].reg)) && IS_A1 ((yyvsp[(5) - (6)].reg)))
3198             {
3199               notethat ("dsp32alu: dregs = ( A0 += A1 )\n");
3200               (yyval.instr) = DSP32ALU (11, 0, 0, &(yyvsp[(1) - (6)].reg), &reg7, &reg7, 0, 0, 0);
3201             }
3202           else
3203             return yyerror ("Register mismatch");
3204         }
3205     break;
3206
3207   case 13:
3208 #line 811 "bfin-parse.y"
3209     {
3210           if (!IS_A1 ((yyvsp[(4) - (6)].reg)) && IS_A1 ((yyvsp[(5) - (6)].reg)))
3211             {
3212               notethat ("dsp32alu: dregs_half = ( A0 += A1 )\n");
3213               (yyval.instr) = DSP32ALU (11, IS_H ((yyvsp[(1) - (6)].reg)), 0, &(yyvsp[(1) - (6)].reg), &reg7, &reg7, 0, 0, 1);
3214             }
3215           else
3216             return yyerror ("Register mismatch");
3217         }
3218     break;
3219
3220   case 14:
3221 #line 821 "bfin-parse.y"
3222     {
3223           notethat ("dsp32alu: A_ZERO_DOT_H = dregs_hi\n");
3224           (yyval.instr) = DSP32ALU (9, IS_H ((yyvsp[(3) - (3)].reg)), 0, 0, &(yyvsp[(3) - (3)].reg), 0, 0, 0, 0);
3225         }
3226     break;
3227
3228   case 15:
3229 #line 826 "bfin-parse.y"
3230     {
3231           notethat ("dsp32alu: A_ZERO_DOT_H = dregs_hi\n");
3232           (yyval.instr) = DSP32ALU (9, IS_H ((yyvsp[(3) - (3)].reg)), 0, 0, &(yyvsp[(3) - (3)].reg), 0, 0, 0, 2);
3233         }
3234     break;
3235
3236   case 16:
3237 #line 832 "bfin-parse.y"
3238     {
3239           if (!IS_DREG ((yyvsp[(2) - (17)].reg)) || !IS_DREG ((yyvsp[(4) - (17)].reg)))
3240             return yyerror ("Dregs expected");
3241           else if (REG_SAME ((yyvsp[(2) - (17)].reg), (yyvsp[(4) - (17)].reg)))
3242             return yyerror ("Illegal dest register combination");
3243           else if (!valid_dreg_pair (&(yyvsp[(9) - (17)].reg), (yyvsp[(11) - (17)].expr)))
3244             return yyerror ("Bad dreg pair");
3245           else if (!valid_dreg_pair (&(yyvsp[(13) - (17)].reg), (yyvsp[(15) - (17)].expr)))
3246             return yyerror ("Bad dreg pair");
3247           else
3248             {
3249               notethat ("dsp32alu: (dregs , dregs ) = BYTEOP16P (dregs_pair , dregs_pair ) (aligndir)\n");
3250               (yyval.instr) = DSP32ALU (21, 0, &(yyvsp[(2) - (17)].reg), &(yyvsp[(4) - (17)].reg), &(yyvsp[(9) - (17)].reg), &(yyvsp[(13) - (17)].reg), (yyvsp[(17) - (17)].r0).r0, 0, 0);
3251             }
3252         }
3253     break;
3254
3255   case 17:
3256 #line 850 "bfin-parse.y"
3257     {
3258           if (!IS_DREG ((yyvsp[(2) - (17)].reg)) || !IS_DREG ((yyvsp[(4) - (17)].reg)))
3259             return yyerror ("Dregs expected");
3260           else if (REG_SAME ((yyvsp[(2) - (17)].reg), (yyvsp[(4) - (17)].reg)))
3261             return yyerror ("Illegal dest register combination");
3262           else if (!valid_dreg_pair (&(yyvsp[(9) - (17)].reg), (yyvsp[(11) - (17)].expr)))
3263             return yyerror ("Bad dreg pair");
3264           else if (!valid_dreg_pair (&(yyvsp[(13) - (17)].reg), (yyvsp[(15) - (17)].expr)))
3265             return yyerror ("Bad dreg pair");
3266           else
3267             {
3268               notethat ("dsp32alu: (dregs , dregs ) = BYTEOP16M (dregs_pair , dregs_pair ) (aligndir)\n");
3269               (yyval.instr) = DSP32ALU (21, 0, &(yyvsp[(2) - (17)].reg), &(yyvsp[(4) - (17)].reg), &(yyvsp[(9) - (17)].reg), &(yyvsp[(13) - (17)].reg), (yyvsp[(17) - (17)].r0).r0, 0, 1);
3270             }
3271         }
3272     break;
3273
3274   case 18:
3275 #line 867 "bfin-parse.y"
3276     {
3277           if (!IS_DREG ((yyvsp[(2) - (11)].reg)) || !IS_DREG ((yyvsp[(4) - (11)].reg)))
3278             return yyerror ("Dregs expected");
3279           else if (REG_SAME ((yyvsp[(2) - (11)].reg), (yyvsp[(4) - (11)].reg)))
3280             return yyerror ("Illegal dest register combination");
3281           else if (!valid_dreg_pair (&(yyvsp[(8) - (11)].reg), (yyvsp[(10) - (11)].expr)))
3282             return yyerror ("Bad dreg pair");
3283           else
3284             {
3285               notethat ("dsp32alu: (dregs , dregs ) = BYTEUNPACK dregs_pair (aligndir)\n");
3286               (yyval.instr) = DSP32ALU (24, 0, &(yyvsp[(2) - (11)].reg), &(yyvsp[(4) - (11)].reg), &(yyvsp[(8) - (11)].reg), 0, (yyvsp[(11) - (11)].r0).r0, 0, 1);
3287             }
3288         }
3289     break;
3290
3291   case 19:
3292 #line 881 "bfin-parse.y"
3293     {
3294           if (REG_SAME ((yyvsp[(2) - (11)].reg), (yyvsp[(4) - (11)].reg)))
3295             return yyerror ("Illegal dest register combination");
3296
3297           if (IS_DREG ((yyvsp[(2) - (11)].reg)) && IS_DREG ((yyvsp[(4) - (11)].reg)) && IS_DREG ((yyvsp[(8) - (11)].reg)))
3298             {
3299               notethat ("dsp32alu: (dregs , dregs ) = SEARCH dregs (searchmod)\n");
3300               (yyval.instr) = DSP32ALU (13, 0, &(yyvsp[(2) - (11)].reg), &(yyvsp[(4) - (11)].reg), &(yyvsp[(8) - (11)].reg), 0, 0, 0, (yyvsp[(10) - (11)].r0).r0);
3301             }
3302           else
3303             return yyerror ("Register mismatch");
3304         }
3305     break;
3306
3307   case 20:
3308 #line 895 "bfin-parse.y"
3309     {
3310           if (REG_SAME ((yyvsp[(1) - (11)].reg), (yyvsp[(7) - (11)].reg)))
3311             return yyerror ("Illegal dest register combination");
3312
3313           if (IS_DREG ((yyvsp[(1) - (11)].reg)) && IS_DREG ((yyvsp[(7) - (11)].reg)))
3314             {
3315               notethat ("dsp32alu: dregs = A1.l + A1.h, dregs = A0.l + A0.h  \n");
3316               (yyval.instr) = DSP32ALU (12, 0, &(yyvsp[(1) - (11)].reg), &(yyvsp[(7) - (11)].reg), &reg7, &reg7, 0, 0, 1);
3317             }
3318           else
3319             return yyerror ("Register mismatch");
3320         }
3321     break;
3322
3323   case 21:
3324 #line 910 "bfin-parse.y"
3325     {
3326           if (REG_SAME ((yyvsp[(1) - (12)].reg), (yyvsp[(7) - (12)].reg)))
3327             return yyerror ("Resource conflict in dest reg");
3328
3329           if (IS_DREG ((yyvsp[(1) - (12)].reg)) && IS_DREG ((yyvsp[(7) - (12)].reg)) && !REG_SAME ((yyvsp[(3) - (12)].reg), (yyvsp[(5) - (12)].reg))
3330               && IS_A1 ((yyvsp[(9) - (12)].reg)) && !IS_A1 ((yyvsp[(11) - (12)].reg)))
3331             {
3332               notethat ("dsp32alu: dregs = A1 + A0 , dregs = A1 - A0 (amod1)\n");
3333               (yyval.instr) = DSP32ALU (17, 0, &(yyvsp[(1) - (12)].reg), &(yyvsp[(7) - (12)].reg), &reg7, &reg7, (yyvsp[(12) - (12)].modcodes).s0, (yyvsp[(12) - (12)].modcodes).x0, 0);
3334
3335             }
3336           else if (IS_DREG ((yyvsp[(1) - (12)].reg)) && IS_DREG ((yyvsp[(7) - (12)].reg)) && !REG_SAME ((yyvsp[(3) - (12)].reg), (yyvsp[(5) - (12)].reg))
3337                    && !IS_A1 ((yyvsp[(9) - (12)].reg)) && IS_A1 ((yyvsp[(11) - (12)].reg)))
3338             {
3339               notethat ("dsp32alu: dregs = A0 + A1 , dregs = A0 - A1 (amod1)\n");
3340               (yyval.instr) = DSP32ALU (17, 0, &(yyvsp[(1) - (12)].reg), &(yyvsp[(7) - (12)].reg), &reg7, &reg7, (yyvsp[(12) - (12)].modcodes).s0, (yyvsp[(12) - (12)].modcodes).x0, 1);
3341             }
3342           else
3343             return yyerror ("Register mismatch");
3344         }
3345     break;
3346
3347   case 22:
3348 #line 932 "bfin-parse.y"
3349     {
3350           if ((yyvsp[(4) - (12)].r0).r0 == (yyvsp[(10) - (12)].r0).r0)
3351             return yyerror ("Operators must differ");
3352
3353           if (IS_DREG ((yyvsp[(1) - (12)].reg)) && IS_DREG ((yyvsp[(3) - (12)].reg)) && IS_DREG ((yyvsp[(5) - (12)].reg))
3354               && REG_SAME ((yyvsp[(3) - (12)].reg), (yyvsp[(9) - (12)].reg)) && REG_SAME ((yyvsp[(5) - (12)].reg), (yyvsp[(11) - (12)].reg)))
3355             {
3356               notethat ("dsp32alu: dregs = dregs + dregs,"
3357                        "dregs = dregs - dregs (amod1)\n");
3358               (yyval.instr) = DSP32ALU (4, 0, &(yyvsp[(1) - (12)].reg), &(yyvsp[(7) - (12)].reg), &(yyvsp[(3) - (12)].reg), &(yyvsp[(5) - (12)].reg), (yyvsp[(12) - (12)].modcodes).s0, (yyvsp[(12) - (12)].modcodes).x0, 2);
3359             }
3360           else
3361             return yyerror ("Register mismatch");
3362         }
3363     break;
3364
3365   case 23:
3366 #line 950 "bfin-parse.y"
3367     {
3368           if (!REG_SAME ((yyvsp[(3) - (12)].reg), (yyvsp[(9) - (12)].reg)) || !REG_SAME ((yyvsp[(5) - (12)].reg), (yyvsp[(11) - (12)].reg)))
3369             return yyerror ("Differing source registers");
3370
3371           if (!IS_DREG ((yyvsp[(1) - (12)].reg)) || !IS_DREG ((yyvsp[(3) - (12)].reg)) || !IS_DREG ((yyvsp[(5) - (12)].reg)) || !IS_DREG ((yyvsp[(7) - (12)].reg)))
3372             return yyerror ("Dregs expected");
3373
3374           if (REG_SAME ((yyvsp[(1) - (12)].reg), (yyvsp[(7) - (12)].reg)))
3375             return yyerror ("Resource conflict in dest reg");
3376
3377           if ((yyvsp[(4) - (12)].r0).r0 == 1 && (yyvsp[(10) - (12)].r0).r0 == 2)
3378             {
3379               notethat ("dsp32alu:  dregs = dregs .|. dregs , dregs = dregs .|. dregs (amod2)\n");
3380               (yyval.instr) = DSP32ALU (1, 1, &(yyvsp[(1) - (12)].reg), &(yyvsp[(7) - (12)].reg), &(yyvsp[(3) - (12)].reg), &(yyvsp[(5) - (12)].reg), (yyvsp[(12) - (12)].modcodes).s0, (yyvsp[(12) - (12)].modcodes).x0, (yyvsp[(12) - (12)].modcodes).r0);
3381             }
3382           else if ((yyvsp[(4) - (12)].r0).r0 == 0 && (yyvsp[(10) - (12)].r0).r0 == 3)
3383             {
3384               notethat ("dsp32alu:  dregs = dregs .|. dregs , dregs = dregs .|. dregs (amod2)\n");
3385               (yyval.instr) = DSP32ALU (1, 0, &(yyvsp[(1) - (12)].reg), &(yyvsp[(7) - (12)].reg), &(yyvsp[(3) - (12)].reg), &(yyvsp[(5) - (12)].reg), (yyvsp[(12) - (12)].modcodes).s0, (yyvsp[(12) - (12)].modcodes).x0, (yyvsp[(12) - (12)].modcodes).r0);
3386             }
3387           else
3388             return yyerror ("Bar operand mismatch");
3389         }
3390     break;
3391
3392   case 24:
3393 #line 975 "bfin-parse.y"
3394     {
3395           int op;
3396
3397           if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(4) - (5)].reg)))
3398             {
3399               if ((yyvsp[(5) - (5)].r0).r0)
3400                 {
3401                   notethat ("dsp32alu: dregs = ABS dregs (v)\n");
3402                   op = 6;
3403                 }
3404               else
3405                 {
3406                   /* Vector version of ABS.  */
3407                   notethat ("dsp32alu: dregs = ABS dregs\n");
3408                   op = 7;
3409                 }
3410               (yyval.instr) = DSP32ALU (op, 0, 0, &(yyvsp[(1) - (5)].reg), &(yyvsp[(4) - (5)].reg), 0, 0, 0, 2);
3411             }
3412           else
3413             return yyerror ("Dregs expected");
3414         }
3415     break;
3416
3417   case 25:
3418 #line 997 "bfin-parse.y"
3419     {
3420           notethat ("dsp32alu: Ax = ABS Ax\n");
3421           (yyval.instr) = DSP32ALU (16, IS_A1 ((yyvsp[(1) - (3)].reg)), 0, 0, &reg7, &reg7, 0, 0, IS_A1 ((yyvsp[(3) - (3)].reg)));
3422         }
3423     break;
3424
3425   case 26:
3426 #line 1002 "bfin-parse.y"
3427     {
3428           if (IS_DREG_L ((yyvsp[(3) - (3)].reg)))
3429             {
3430               notethat ("dsp32alu: A0.l = reg_half\n");
3431               (yyval.instr) = DSP32ALU (9, IS_H ((yyvsp[(3) - (3)].reg)), 0, 0, &(yyvsp[(3) - (3)].reg), 0, 0, 0, 0);
3432             }
3433           else
3434             return yyerror ("A0.l = Rx.l expected");
3435         }
3436     break;
3437
3438   case 27:
3439 #line 1012 "bfin-parse.y"
3440     {
3441           if (IS_DREG_L ((yyvsp[(3) - (3)].reg)))
3442             {
3443               notethat ("dsp32alu: A1.l = reg_half\n");
3444               (yyval.instr) = DSP32ALU (9, IS_H ((yyvsp[(3) - (3)].reg)), 0, 0, &(yyvsp[(3) - (3)].reg), 0, 0, 0, 2);
3445             }
3446           else
3447             return yyerror ("A1.l = Rx.l expected");
3448         }
3449     break;
3450
3451   case 28:
3452 #line 1023 "bfin-parse.y"
3453     {
3454           if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
3455             {
3456               notethat ("dsp32shift: dregs = ALIGN8 (dregs , dregs )\n");
3457               (yyval.instr) = DSP32SHIFT (13, &(yyvsp[(1) - (8)].reg), &(yyvsp[(7) - (8)].reg), &(yyvsp[(5) - (8)].reg), (yyvsp[(3) - (8)].r0).r0, 0);
3458             }
3459           else
3460             return yyerror ("Dregs expected");
3461         }
3462     break;
3463
3464   case 29:
3465 #line 1034 "bfin-parse.y"
3466     {
3467           if (!IS_DREG ((yyvsp[(1) - (13)].reg)))
3468             return yyerror ("Dregs expected");
3469           else if (!valid_dreg_pair (&(yyvsp[(5) - (13)].reg), (yyvsp[(7) - (13)].expr)))
3470             return yyerror ("Bad dreg pair");
3471           else if (!valid_dreg_pair (&(yyvsp[(9) - (13)].reg), (yyvsp[(11) - (13)].expr)))
3472             return yyerror ("Bad dreg pair");
3473           else
3474             {
3475               notethat ("dsp32alu: dregs = BYTEOP1P (dregs_pair , dregs_pair ) (T)\n");
3476               (yyval.instr) = DSP32ALU (20, 0, 0, &(yyvsp[(1) - (13)].reg), &(yyvsp[(5) - (13)].reg), &(yyvsp[(9) - (13)].reg), (yyvsp[(13) - (13)].modcodes).s0, 0, (yyvsp[(13) - (13)].modcodes).r0);
3477             }
3478         }
3479     break;
3480
3481   case 30:
3482 #line 1048 "bfin-parse.y"
3483     {
3484           if (!IS_DREG ((yyvsp[(1) - (12)].reg)))
3485             return yyerror ("Dregs expected");
3486           else if (!valid_dreg_pair (&(yyvsp[(5) - (12)].reg), (yyvsp[(7) - (12)].expr)))
3487             return yyerror ("Bad dreg pair");
3488           else if (!valid_dreg_pair (&(yyvsp[(9) - (12)].reg), (yyvsp[(11) - (12)].expr)))
3489             return yyerror ("Bad dreg pair");
3490           else
3491             {
3492               notethat ("dsp32alu: dregs = BYTEOP1P (dregs_pair , dregs_pair ) (T)\n");
3493               (yyval.instr) = DSP32ALU (20, 0, 0, &(yyvsp[(1) - (12)].reg), &(yyvsp[(5) - (12)].reg), &(yyvsp[(9) - (12)].reg), 0, 0, 0);
3494             }
3495         }
3496     break;
3497
3498   case 31:
3499 #line 1064 "bfin-parse.y"
3500     {
3501           if (!IS_DREG ((yyvsp[(1) - (13)].reg)))
3502             return yyerror ("Dregs expected");
3503           else if (!valid_dreg_pair (&(yyvsp[(5) - (13)].reg), (yyvsp[(7) - (13)].expr)))
3504             return yyerror ("Bad dreg pair");
3505           else if (!valid_dreg_pair (&(yyvsp[(9) - (13)].reg), (yyvsp[(11) - (13)].expr)))
3506             return yyerror ("Bad dreg pair");
3507           else
3508             {
3509               notethat ("dsp32alu: dregs = BYTEOP2P (dregs_pair , dregs_pair ) (rnd_op)\n");
3510               (yyval.instr) = DSP32ALU (22, (yyvsp[(13) - (13)].modcodes).r0, 0, &(yyvsp[(1) - (13)].reg), &(yyvsp[(5) - (13)].reg), &(yyvsp[(9) - (13)].reg), (yyvsp[(13) - (13)].modcodes).s0, (yyvsp[(13) - (13)].modcodes).x0, (yyvsp[(13) - (13)].modcodes).aop);
3511             }
3512         }
3513     break;
3514
3515   case 32:
3516 #line 1080 "bfin-parse.y"
3517     {
3518           if (!IS_DREG ((yyvsp[(1) - (13)].reg)))
3519             return yyerror ("Dregs expected");
3520           else if (!valid_dreg_pair (&(yyvsp[(5) - (13)].reg), (yyvsp[(7) - (13)].expr)))
3521             return yyerror ("Bad dreg pair");
3522           else if (!valid_dreg_pair (&(yyvsp[(9) - (13)].reg), (yyvsp[(11) - (13)].expr)))
3523             return yyerror ("Bad dreg pair");
3524           else
3525             {
3526               notethat ("dsp32alu: dregs = BYTEOP3P (dregs_pair , dregs_pair ) (b3_op)\n");
3527               (yyval.instr) = DSP32ALU (23, (yyvsp[(13) - (13)].modcodes).x0, 0, &(yyvsp[(1) - (13)].reg), &(yyvsp[(5) - (13)].reg), &(yyvsp[(9) - (13)].reg), (yyvsp[(13) - (13)].modcodes).s0, 0, 0);
3528             }
3529         }
3530     break;
3531
3532   case 33:
3533 #line 1095 "bfin-parse.y"
3534     {
3535           if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
3536             {
3537               notethat ("dsp32alu: dregs = BYTEPACK (dregs , dregs )\n");
3538               (yyval.instr) = DSP32ALU (24, 0, 0, &(yyvsp[(1) - (8)].reg), &(yyvsp[(5) - (8)].reg), &(yyvsp[(7) - (8)].reg), 0, 0, 0);
3539             }
3540           else
3541             return yyerror ("Dregs expected");
3542         }
3543     break;
3544
3545   case 34:
3546 #line 1107 "bfin-parse.y"
3547     {
3548           if (IS_HCOMPL ((yyvsp[(1) - (17)].reg), (yyvsp[(3) - (17)].reg)) && IS_HCOMPL ((yyvsp[(7) - (17)].reg), (yyvsp[(14) - (17)].reg)) && IS_HCOMPL ((yyvsp[(10) - (17)].reg), (yyvsp[(17) - (17)].reg)))
3549             {
3550               notethat ("dsp32alu:      dregs_hi = dregs_lo ="
3551                        "SIGN (dregs_hi) * dregs_hi + "
3552                        "SIGN (dregs_lo) * dregs_lo \n");
3553
3554                 (yyval.instr) = DSP32ALU (12, 0, 0, &(yyvsp[(1) - (17)].reg), &(yyvsp[(7) - (17)].reg), &(yyvsp[(10) - (17)].reg), 0, 0, 0);
3555             }
3556           else
3557             return yyerror ("Dregs expected");
3558         }
3559     break;
3560
3561   case 35:
3562 #line 1120 "bfin-parse.y"
3563     {
3564           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
3565             {
3566               if ((yyvsp[(6) - (6)].modcodes).aop == 0)
3567                 {
3568                   /* No saturation flag specified, generate the 16 bit variant.  */
3569                   notethat ("COMP3op: dregs = dregs +- dregs\n");
3570                   (yyval.instr) = COMP3OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg), (yyvsp[(4) - (6)].r0).r0);
3571                 }
3572               else
3573                 {
3574                  /* Saturation flag specified, generate the 32 bit variant.  */
3575                  notethat ("dsp32alu: dregs = dregs +- dregs (amod1)\n");
3576                  (yyval.instr) = DSP32ALU (4, 0, 0, &(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg), (yyvsp[(6) - (6)].modcodes).s0, (yyvsp[(6) - (6)].modcodes).x0, (yyvsp[(4) - (6)].r0).r0);
3577                 }
3578             }
3579           else
3580             if (IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)) && IS_PREG ((yyvsp[(5) - (6)].reg)) && (yyvsp[(4) - (6)].r0).r0 == 0)
3581               {
3582                 notethat ("COMP3op: pregs = pregs + pregs\n");
3583                 (yyval.instr) = COMP3OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg), 5);
3584               }
3585             else
3586               return yyerror ("Dregs expected");
3587         }
3588     break;
3589
3590   case 36:
3591 #line 1146 "bfin-parse.y"
3592     {
3593           int op;
3594
3595           if (IS_DREG ((yyvsp[(1) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && IS_DREG ((yyvsp[(7) - (9)].reg)))
3596             {
3597               if ((yyvsp[(9) - (9)].r0).r0)
3598                 op = 6;
3599               else
3600                 op = 7;
3601
3602               notethat ("dsp32alu: dregs = {MIN|MAX} (dregs, dregs)\n");
3603               (yyval.instr) = DSP32ALU (op, 0, 0, &(yyvsp[(1) - (9)].reg), &(yyvsp[(5) - (9)].reg), &(yyvsp[(7) - (9)].reg), 0, 0, (yyvsp[(3) - (9)].r0).r0);
3604             }
3605           else
3606             return yyerror ("Dregs expected");
3607         }
3608     break;
3609
3610   case 37:
3611 #line 1164 "bfin-parse.y"
3612     {
3613           notethat ("dsp32alu: Ax = - Ax\n");
3614           (yyval.instr) = DSP32ALU (14, IS_A1 ((yyvsp[(1) - (3)].reg)), 0, 0, &reg7, &reg7, 0, 0, IS_A1 ((yyvsp[(3) - (3)].reg)));
3615         }
3616     break;
3617
3618   case 38:
3619 #line 1169 "bfin-parse.y"
3620     {
3621           notethat ("dsp32alu: dregs_lo = dregs_lo +- dregs_lo (amod1)\n");
3622           (yyval.instr) = DSP32ALU (2 | (yyvsp[(4) - (6)].r0).r0, IS_H ((yyvsp[(1) - (6)].reg)), 0, &(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg),
3623                          (yyvsp[(6) - (6)].modcodes).s0, (yyvsp[(6) - (6)].modcodes).x0, HL2 ((yyvsp[(3) - (6)].reg), (yyvsp[(5) - (6)].reg)));
3624         }
3625     break;
3626
3627   case 39:
3628 #line 1175 "bfin-parse.y"
3629     {
3630           if (EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 0 && !REG_SAME ((yyvsp[(1) - (3)].reg), (yyvsp[(2) - (3)].reg)))
3631             {
3632               notethat ("dsp32alu: A1 = A0 = 0\n");
3633               (yyval.instr) = DSP32ALU (8, 0, 0, 0, &reg7, &reg7, 0, 0, 2);
3634             }
3635           else
3636             return yyerror ("Bad value, 0 expected");
3637         }
3638     break;
3639
3640   case 40:
3641 #line 1187 "bfin-parse.y"
3642     {
3643           if (REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(2) - (5)].reg)))
3644             {
3645               notethat ("dsp32alu: Ax = Ax (S)\n");
3646               (yyval.instr) = DSP32ALU (8, 0, 0, 0, &reg7, &reg7, 1, 0, IS_A1 ((yyvsp[(1) - (5)].reg)));
3647             }
3648           else
3649             return yyerror ("Registers must be equal");
3650         }
3651     break;
3652
3653   case 41:
3654 #line 1198 "bfin-parse.y"
3655     {
3656           if (IS_DREG ((yyvsp[(3) - (6)].reg)))
3657             {
3658               notethat ("dsp32alu: dregs_half = dregs (RND)\n");
3659               (yyval.instr) = DSP32ALU (12, IS_H ((yyvsp[(1) - (6)].reg)), 0, &(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 0, 0, 0, 3);
3660             }
3661           else
3662             return yyerror ("Dregs expected");
3663         }
3664     break;
3665
3666   case 42:
3667 #line 1209 "bfin-parse.y"
3668     {
3669           if (IS_DREG ((yyvsp[(3) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)))
3670             {
3671               notethat ("dsp32alu: dregs_half = dregs (+-) dregs (RND12)\n");
3672               (yyval.instr) = DSP32ALU (5, IS_H ((yyvsp[(1) - (8)].reg)), 0, &(yyvsp[(1) - (8)].reg), &(yyvsp[(3) - (8)].reg), &(yyvsp[(5) - (8)].reg), 0, 0, (yyvsp[(4) - (8)].r0).r0);
3673             }
3674           else
3675             return yyerror ("Dregs expected");
3676         }
3677     break;
3678
3679   case 43:
3680 #line 1220 "bfin-parse.y"
3681     {
3682           if (IS_DREG ((yyvsp[(3) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)))
3683             {
3684               notethat ("dsp32alu: dregs_half = dregs -+ dregs (RND20)\n");
3685               (yyval.instr) = DSP32ALU (5, IS_H ((yyvsp[(1) - (8)].reg)), 0, &(yyvsp[(1) - (8)].reg), &(yyvsp[(3) - (8)].reg), &(yyvsp[(5) - (8)].reg), 0, 1, (yyvsp[(4) - (8)].r0).r0 | 2);
3686             }
3687           else
3688             return yyerror ("Dregs expected");
3689         }
3690     break;
3691
3692   case 44:
3693 #line 1231 "bfin-parse.y"
3694     {
3695           if (!REG_SAME ((yyvsp[(1) - (2)].reg), (yyvsp[(2) - (2)].reg)))
3696             {
3697               notethat ("dsp32alu: An = Am\n");
3698               (yyval.instr) = DSP32ALU (8, 0, 0, 0, &reg7, &reg7, IS_A1 ((yyvsp[(1) - (2)].reg)), 0, 3);
3699             }
3700           else
3701             return yyerror ("Accu reg arguments must differ");
3702         }
3703     break;
3704
3705   case 45:
3706 #line 1242 "bfin-parse.y"
3707     {
3708           if (IS_DREG ((yyvsp[(2) - (2)].reg)))
3709             {
3710               notethat ("dsp32alu: An = dregs\n");
3711               (yyval.instr) = DSP32ALU (9, 0, 0, 0, &(yyvsp[(2) - (2)].reg), 0, 1, 0, IS_A1 ((yyvsp[(1) - (2)].reg)) << 1);
3712             }
3713           else
3714             return yyerror ("Dregs expected");
3715         }
3716     break;
3717
3718   case 46:
3719 #line 1253 "bfin-parse.y"
3720     {
3721           if (!IS_H ((yyvsp[(3) - (4)].reg)))
3722             {
3723               if ((yyvsp[(1) - (4)].reg).regno == REG_A0x && IS_DREG ((yyvsp[(3) - (4)].reg)))
3724                 {
3725                   notethat ("dsp32alu: A0.x = dregs_lo\n");
3726                   (yyval.instr) = DSP32ALU (9, 0, 0, 0, &(yyvsp[(3) - (4)].reg), 0, 0, 0, 1);
3727                 }
3728               else if ((yyvsp[(1) - (4)].reg).regno == REG_A1x && IS_DREG ((yyvsp[(3) - (4)].reg)))
3729                 {
3730                   notethat ("dsp32alu: A1.x = dregs_lo\n");
3731                   (yyval.instr) = DSP32ALU (9, 0, 0, 0, &(yyvsp[(3) - (4)].reg), 0, 0, 0, 3);
3732                 }
3733               else if (IS_DREG ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(3) - (4)].reg)))
3734                 {
3735                   notethat ("ALU2op: dregs = dregs_lo\n");
3736                   (yyval.instr) = ALU2OP (&(yyvsp[(1) - (4)].reg), &(yyvsp[(3) - (4)].reg), 10 | ((yyvsp[(4) - (4)].r0).r0 ? 0: 1));
3737                 }
3738               else
3739                 return yyerror ("Register mismatch");
3740             }
3741           else
3742             return yyerror ("Low reg expected");
3743         }
3744     break;
3745
3746   case 47:
3747 #line 1279 "bfin-parse.y"
3748     {
3749           notethat ("LDIMMhalf: pregs_half = imm16\n");
3750
3751           if (!IS_DREG ((yyvsp[(1) - (3)].reg)) && !IS_PREG ((yyvsp[(1) - (3)].reg)) && !IS_IREG ((yyvsp[(1) - (3)].reg))
3752               && !IS_MREG ((yyvsp[(1) - (3)].reg)) && !IS_BREG ((yyvsp[(1) - (3)].reg)) && !IS_LREG ((yyvsp[(1) - (3)].reg)))
3753             return yyerror ("Wrong register for load immediate");
3754
3755           if (!IS_IMM ((yyvsp[(3) - (3)].expr), 16) && !IS_UIMM ((yyvsp[(3) - (3)].expr), 16))
3756             return yyerror ("Constant out of range");
3757
3758           (yyval.instr) = LDIMMHALF_R (&(yyvsp[(1) - (3)].reg), IS_H ((yyvsp[(1) - (3)].reg)), 0, 0, (yyvsp[(3) - (3)].expr));
3759         }
3760     break;
3761
3762   case 48:
3763 #line 1293 "bfin-parse.y"
3764     {
3765           notethat ("dsp32alu: An = 0\n");
3766
3767           if (imm7 ((yyvsp[(2) - (2)].expr)) != 0)
3768             return yyerror ("0 expected");
3769
3770           (yyval.instr) = DSP32ALU (8, 0, 0, 0, 0, 0, 0, 0, IS_A1 ((yyvsp[(1) - (2)].reg)));
3771         }
3772     break;
3773
3774   case 49:
3775 #line 1303 "bfin-parse.y"
3776     {
3777           if (!IS_DREG ((yyvsp[(1) - (4)].reg)) && !IS_PREG ((yyvsp[(1) - (4)].reg)) && !IS_IREG ((yyvsp[(1) - (4)].reg))
3778               && !IS_MREG ((yyvsp[(1) - (4)].reg)) && !IS_BREG ((yyvsp[(1) - (4)].reg)) && !IS_LREG ((yyvsp[(1) - (4)].reg)))
3779             return yyerror ("Wrong register for load immediate");
3780
3781           if ((yyvsp[(4) - (4)].r0).r0 == 0)
3782             {
3783               /* 7 bit immediate value if possible.
3784                  We will check for that constant value for efficiency
3785                  If it goes to reloc, it will be 16 bit.  */
3786               if (IS_CONST ((yyvsp[(3) - (4)].expr)) && IS_IMM ((yyvsp[(3) - (4)].expr), 7) && IS_DREG ((yyvsp[(1) - (4)].reg)))
3787                 {
3788                   notethat ("COMPI2opD: dregs = imm7 (x) \n");
3789                   (yyval.instr) = COMPI2OPD (&(yyvsp[(1) - (4)].reg), imm7 ((yyvsp[(3) - (4)].expr)), 0);
3790                 }
3791               else if (IS_CONST ((yyvsp[(3) - (4)].expr)) && IS_IMM ((yyvsp[(3) - (4)].expr), 7) && IS_PREG ((yyvsp[(1) - (4)].reg)))
3792                 {
3793                   notethat ("COMPI2opP: pregs = imm7 (x)\n");
3794                   (yyval.instr) = COMPI2OPP (&(yyvsp[(1) - (4)].reg), imm7 ((yyvsp[(3) - (4)].expr)), 0);
3795                 }
3796               else
3797                 {
3798                   if (IS_CONST ((yyvsp[(3) - (4)].expr)) && !IS_IMM ((yyvsp[(3) - (4)].expr), 16))
3799                     return yyerror ("Immediate value out of range");
3800
3801                   notethat ("LDIMMhalf: regs = luimm16 (x)\n");
3802                   /* reg, H, S, Z.   */
3803                   (yyval.instr) = LDIMMHALF_R5 (&(yyvsp[(1) - (4)].reg), 0, 1, 0, (yyvsp[(3) - (4)].expr));
3804                 }
3805             }
3806           else
3807             {
3808               /* (z) There is no 7 bit zero extended instruction.
3809               If the expr is a relocation, generate it.   */
3810
3811               if (IS_CONST ((yyvsp[(3) - (4)].expr)) && !IS_UIMM ((yyvsp[(3) - (4)].expr), 16))
3812                 return yyerror ("Immediate value out of range");
3813
3814               notethat ("LDIMMhalf: regs = luimm16 (x)\n");
3815               /* reg, H, S, Z.  */
3816               (yyval.instr) = LDIMMHALF_R5 (&(yyvsp[(1) - (4)].reg), 0, 0, 1, (yyvsp[(3) - (4)].expr));
3817             }
3818         }
3819     break;
3820
3821   case 50:
3822 #line 1348 "bfin-parse.y"
3823     {
3824           if (IS_H ((yyvsp[(1) - (3)].reg)))
3825             return yyerror ("Low reg expected");
3826
3827           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && (yyvsp[(3) - (3)].reg).regno == REG_A0x)
3828             {
3829               notethat ("dsp32alu: dregs_lo = A0.x\n");
3830               (yyval.instr) = DSP32ALU (10, 0, 0, &(yyvsp[(1) - (3)].reg), &reg7, &reg7, 0, 0, 0);
3831             }
3832           else if (IS_DREG ((yyvsp[(1) - (3)].reg)) && (yyvsp[(3) - (3)].reg).regno == REG_A1x)
3833             {
3834               notethat ("dsp32alu: dregs_lo = A1.x\n");
3835               (yyval.instr) = DSP32ALU (10, 0, 0, &(yyvsp[(1) - (3)].reg), &reg7, &reg7, 0, 0, 1);
3836             }
3837           else
3838             return yyerror ("Register mismatch");
3839         }
3840     break;
3841
3842   case 51:
3843 #line 1367 "bfin-parse.y"
3844     {
3845           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
3846             {
3847               notethat ("dsp32alu: dregs = dregs .|. dregs (amod0)\n");
3848               (yyval.instr) = DSP32ALU (0, 0, 0, &(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg), (yyvsp[(6) - (6)].modcodes).s0, (yyvsp[(6) - (6)].modcodes).x0, (yyvsp[(4) - (6)].r0).r0);
3849             }
3850           else
3851             return yyerror ("Register mismatch");
3852         }
3853     break;
3854
3855   case 52:
3856 #line 1378 "bfin-parse.y"
3857     {
3858           if (IS_DREG ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(3) - (4)].reg)))
3859             {
3860               notethat ("ALU2op: dregs = dregs_byte\n");
3861               (yyval.instr) = ALU2OP (&(yyvsp[(1) - (4)].reg), &(yyvsp[(3) - (4)].reg), 12 | ((yyvsp[(4) - (4)].r0).r0 ? 0: 1));
3862             }
3863           else
3864             return yyerror ("Register mismatch");
3865         }
3866     break;
3867
3868   case 53:
3869 #line 1389 "bfin-parse.y"
3870     {
3871           if (REG_SAME ((yyvsp[(1) - (7)].reg), (yyvsp[(3) - (7)].reg)) && REG_SAME ((yyvsp[(5) - (7)].reg), (yyvsp[(7) - (7)].reg)) && !REG_SAME ((yyvsp[(1) - (7)].reg), (yyvsp[(5) - (7)].reg)))
3872             {
3873               notethat ("dsp32alu: A1 = ABS A1 , A0 = ABS A0\n");
3874               (yyval.instr) = DSP32ALU (16, 0, 0, 0, &reg7, &reg7, 0, 0, 3);
3875             }
3876           else
3877             return yyerror ("Register mismatch");
3878         }
3879     break;
3880
3881   case 54:
3882 #line 1400 "bfin-parse.y"
3883     {
3884           if (REG_SAME ((yyvsp[(1) - (7)].reg), (yyvsp[(3) - (7)].reg)) && REG_SAME ((yyvsp[(5) - (7)].reg), (yyvsp[(7) - (7)].reg)) && !REG_SAME ((yyvsp[(1) - (7)].reg), (yyvsp[(5) - (7)].reg)))
3885             {
3886               notethat ("dsp32alu: A1 = - A1 , A0 = - A0\n");
3887               (yyval.instr) = DSP32ALU (14, 0, 0, 0, &reg7, &reg7, 0, 0, 3);
3888             }
3889           else
3890             return yyerror ("Register mismatch");
3891         }
3892     break;
3893
3894   case 55:
3895 #line 1411 "bfin-parse.y"
3896     {
3897           if (!IS_A1 ((yyvsp[(1) - (3)].reg)) && IS_A1 ((yyvsp[(2) - (3)].reg)))
3898             {
3899               notethat ("dsp32alu: A0 -= A1\n");
3900               (yyval.instr) = DSP32ALU (11, 0, 0, 0, &reg7, &reg7, (yyvsp[(3) - (3)].r0).r0, 0, 3);
3901             }
3902           else
3903             return yyerror ("Register mismatch");
3904         }
3905     break;
3906
3907   case 56:
3908 #line 1422 "bfin-parse.y"
3909     {
3910           if (IS_IREG ((yyvsp[(1) - (3)].reg)) && EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 4)
3911             {
3912               notethat ("dagMODik: iregs -= 4\n");
3913               (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 3);
3914             }
3915           else if (IS_IREG ((yyvsp[(1) - (3)].reg)) && EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 2)
3916             {
3917               notethat ("dagMODik: iregs -= 2\n");
3918               (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 1);
3919             }
3920           else
3921             return yyerror ("Register or value mismatch");
3922         }
3923     break;
3924
3925   case 57:
3926 #line 1438 "bfin-parse.y"
3927     {
3928           if (IS_IREG ((yyvsp[(1) - (6)].reg)) && IS_MREG ((yyvsp[(3) - (6)].reg)))
3929             {
3930               notethat ("dagMODim: iregs += mregs (opt_brev)\n");
3931               /* i, m, op, br.  */
3932               (yyval.instr) = DAGMODIM (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 0, 1);
3933             }
3934           else if (IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)))
3935             {
3936               notethat ("PTR2op: pregs += pregs (BREV )\n");
3937               (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 5);
3938             }
3939           else
3940             return yyerror ("Register mismatch");
3941         }
3942     break;
3943
3944   case 58:
3945 #line 1455 "bfin-parse.y"
3946     {
3947           if (IS_IREG ((yyvsp[(1) - (3)].reg)) && IS_MREG ((yyvsp[(3) - (3)].reg)))
3948             {
3949               notethat ("dagMODim: iregs -= mregs\n");
3950               (yyval.instr) = DAGMODIM (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 1, 0);
3951             }
3952           else if (IS_PREG ((yyvsp[(1) - (3)].reg)) && IS_PREG ((yyvsp[(3) - (3)].reg)))
3953             {
3954               notethat ("PTR2op: pregs -= pregs\n");
3955               (yyval.instr) = PTR2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 0);
3956             }
3957           else
3958             return yyerror ("Register mismatch");
3959         }
3960     break;
3961
3962   case 59:
3963 #line 1471 "bfin-parse.y"
3964     {
3965           if (!IS_A1 ((yyvsp[(1) - (4)].reg)) && IS_A1 ((yyvsp[(3) - (4)].reg)))
3966             {
3967               notethat ("dsp32alu: A0 += A1 (W32)\n");
3968               (yyval.instr) = DSP32ALU (11, 0, 0, 0, &reg7, &reg7, (yyvsp[(4) - (4)].r0).r0, 0, 2);
3969             }
3970           else
3971             return yyerror ("Register mismatch");
3972         }
3973     break;
3974
3975   case 60:
3976 #line 1482 "bfin-parse.y"
3977     {
3978           if (IS_IREG ((yyvsp[(1) - (3)].reg)) && IS_MREG ((yyvsp[(3) - (3)].reg)))
3979             {
3980               notethat ("dagMODim: iregs += mregs\n");
3981               (yyval.instr) = DAGMODIM (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 0, 0);
3982             }
3983           else
3984             return yyerror ("iregs += mregs expected");
3985         }
3986     break;
3987
3988   case 61:
3989 #line 1493 "bfin-parse.y"
3990     {
3991           if (IS_IREG ((yyvsp[(1) - (3)].reg)))
3992             {
3993               if (EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 4)
3994                 {
3995                   notethat ("dagMODik: iregs += 4\n");
3996                   (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 2);
3997                 }
3998               else if (EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 2)
3999                 {
4000                   notethat ("dagMODik: iregs += 2\n");
4001                   (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 0);
4002                 }
4003               else
4004                 return yyerror ("iregs += [ 2 | 4 ");
4005             }
4006           else if (IS_PREG ((yyvsp[(1) - (3)].reg)) && IS_IMM ((yyvsp[(3) - (3)].expr), 7))
4007             {
4008               notethat ("COMPI2opP: pregs += imm7\n");
4009               (yyval.instr) = COMPI2OPP (&(yyvsp[(1) - (3)].reg), imm7 ((yyvsp[(3) - (3)].expr)), 1);
4010             }
4011           else if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_IMM ((yyvsp[(3) - (3)].expr), 7))
4012             {
4013               notethat ("COMPI2opD: dregs += imm7\n");
4014               (yyval.instr) = COMPI2OPD (&(yyvsp[(1) - (3)].reg), imm7 ((yyvsp[(3) - (3)].expr)), 1);
4015             }
4016           else if ((IS_DREG ((yyvsp[(1) - (3)].reg)) || IS_PREG ((yyvsp[(1) - (3)].reg))) && IS_CONST ((yyvsp[(3) - (3)].expr)))
4017             return yyerror ("Immediate value out of range");
4018           else
4019             return yyerror ("Register mismatch");
4020         }
4021     break;
4022
4023   case 62:
4024 #line 1526 "bfin-parse.y"
4025     {
4026           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
4027             {
4028               notethat ("ALU2op: dregs *= dregs\n");
4029               (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 3);
4030             }
4031           else
4032             return yyerror ("Register mismatch");
4033         }
4034     break;
4035
4036   case 63:
4037 #line 1537 "bfin-parse.y"
4038     {
4039           if (!valid_dreg_pair (&(yyvsp[(3) - (11)].reg), (yyvsp[(5) - (11)].expr)))
4040             return yyerror ("Bad dreg pair");
4041           else if (!valid_dreg_pair (&(yyvsp[(7) - (11)].reg), (yyvsp[(9) - (11)].expr)))
4042             return yyerror ("Bad dreg pair");
4043           else
4044             {
4045               notethat ("dsp32alu: SAA (dregs_pair , dregs_pair ) (aligndir)\n");
4046               (yyval.instr) = DSP32ALU (18, 0, 0, 0, &(yyvsp[(3) - (11)].reg), &(yyvsp[(7) - (11)].reg), (yyvsp[(11) - (11)].r0).r0, 0, 0);
4047             }
4048         }
4049     break;
4050
4051   case 64:
4052 #line 1550 "bfin-parse.y"
4053     {
4054           if (REG_SAME ((yyvsp[(1) - (11)].reg), (yyvsp[(2) - (11)].reg)) && REG_SAME ((yyvsp[(7) - (11)].reg), (yyvsp[(8) - (11)].reg)) && !REG_SAME ((yyvsp[(1) - (11)].reg), (yyvsp[(7) - (11)].reg)))
4055             {
4056               notethat ("dsp32alu: A1 = A1 (S) , A0 = A0 (S)\n");
4057               (yyval.instr) = DSP32ALU (8, 0, 0, 0, &reg7, &reg7, 1, 0, 2);
4058             }
4059           else
4060             return yyerror ("Register mismatch");
4061         }
4062     break;
4063
4064   case 65:
4065 #line 1561 "bfin-parse.y"
4066     {
4067           if (IS_DREG ((yyvsp[(1) - (9)].reg)) && IS_DREG ((yyvsp[(4) - (9)].reg)) && IS_DREG ((yyvsp[(6) - (9)].reg))
4068               && REG_SAME ((yyvsp[(1) - (9)].reg), (yyvsp[(4) - (9)].reg)))
4069             {
4070               if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 1)
4071                 {
4072                   notethat ("ALU2op: dregs = (dregs + dregs) << 1\n");
4073                   (yyval.instr) = ALU2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 4);
4074                 }
4075               else if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 2)
4076                 {
4077                   notethat ("ALU2op: dregs = (dregs + dregs) << 2\n");
4078                   (yyval.instr) = ALU2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 5);
4079                 }
4080               else
4081                 return yyerror ("Bad shift value");
4082             }
4083           else if (IS_PREG ((yyvsp[(1) - (9)].reg)) && IS_PREG ((yyvsp[(4) - (9)].reg)) && IS_PREG ((yyvsp[(6) - (9)].reg))
4084                    && REG_SAME ((yyvsp[(1) - (9)].reg), (yyvsp[(4) - (9)].reg)))
4085             {
4086               if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 1)
4087                 {
4088                   notethat ("PTR2op: pregs = (pregs + pregs) << 1\n");
4089                   (yyval.instr) = PTR2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 6);
4090                 }
4091               else if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 2)
4092                 {
4093                   notethat ("PTR2op: pregs = (pregs + pregs) << 2\n");
4094                   (yyval.instr) = PTR2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 7);
4095                 }
4096               else
4097                 return yyerror ("Bad shift value");
4098             }
4099           else
4100             return yyerror ("Register mismatch");
4101         }
4102     break;
4103
4104   case 66:
4105 #line 1600 "bfin-parse.y"
4106     {
4107           if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(3) - (5)].reg)) && IS_DREG ((yyvsp[(5) - (5)].reg)))
4108             {
4109               notethat ("COMP3op: dregs = dregs | dregs\n");
4110               (yyval.instr) = COMP3OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(3) - (5)].reg), &(yyvsp[(5) - (5)].reg), 3);
4111             }
4112           else
4113             return yyerror ("Dregs expected");
4114         }
4115     break;
4116
4117   case 67:
4118 #line 1610 "bfin-parse.y"
4119     {
4120           if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(3) - (5)].reg)) && IS_DREG ((yyvsp[(5) - (5)].reg)))
4121             {
4122               notethat ("COMP3op: dregs = dregs ^ dregs\n");
4123               (yyval.instr) = COMP3OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(3) - (5)].reg), &(yyvsp[(5) - (5)].reg), 4);
4124             }
4125           else
4126             return yyerror ("Dregs expected");
4127         }
4128     break;
4129
4130   case 68:
4131 #line 1620 "bfin-parse.y"
4132     {
4133           if (IS_PREG ((yyvsp[(1) - (9)].reg)) && IS_PREG ((yyvsp[(3) - (9)].reg)) && IS_PREG ((yyvsp[(6) - (9)].reg)))
4134             {
4135               if (EXPR_VALUE ((yyvsp[(8) - (9)].expr)) == 1)
4136                 {
4137                   notethat ("COMP3op: pregs = pregs + (pregs << 1)\n");
4138                   (yyval.instr) = COMP3OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(3) - (9)].reg), &(yyvsp[(6) - (9)].reg), 6);
4139                 }
4140               else if (EXPR_VALUE ((yyvsp[(8) - (9)].expr)) == 2)
4141                 {
4142                   notethat ("COMP3op: pregs = pregs + (pregs << 2)\n");
4143                   (yyval.instr) = COMP3OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(3) - (9)].reg), &(yyvsp[(6) - (9)].reg), 7);
4144                 }
4145               else
4146                   return yyerror ("Bad shift value");
4147             }
4148           else
4149             return yyerror ("Dregs expected");
4150         }
4151     break;
4152
4153   case 69:
4154 #line 1640 "bfin-parse.y"
4155     {
4156           if ((yyvsp[(3) - (5)].reg).regno == REG_A0 && (yyvsp[(5) - (5)].reg).regno == REG_A1)
4157             {
4158               notethat ("CCflag: CC = A0 == A1\n");
4159               (yyval.instr) = CCFLAG (0, 0, 5, 0, 0);
4160             }
4161           else
4162             return yyerror ("AREGs are in bad order or same");
4163         }
4164     break;
4165
4166   case 70:
4167 #line 1650 "bfin-parse.y"
4168     {
4169           if ((yyvsp[(3) - (5)].reg).regno == REG_A0 && (yyvsp[(5) - (5)].reg).regno == REG_A1)
4170             {
4171               notethat ("CCflag: CC = A0 < A1\n");
4172               (yyval.instr) = CCFLAG (0, 0, 6, 0, 0);
4173             }
4174           else
4175             return yyerror ("AREGs are in bad order or same");
4176         }
4177     break;
4178
4179   case 71:
4180 #line 1660 "bfin-parse.y"
4181     {
4182           if ((IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
4183               || (IS_PREG ((yyvsp[(3) - (6)].reg)) && IS_PREG ((yyvsp[(5) - (6)].reg))))
4184             {
4185               notethat ("CCflag: CC = dpregs < dpregs\n");
4186               (yyval.instr) = CCFLAG (&(yyvsp[(3) - (6)].reg), (yyvsp[(5) - (6)].reg).regno & CODE_MASK, (yyvsp[(6) - (6)].r0).r0, 0, IS_PREG ((yyvsp[(3) - (6)].reg)) ? 1 : 0);
4187             }
4188           else
4189             return yyerror ("Bad register in comparison");
4190         }
4191     break;
4192
4193   case 72:
4194 #line 1671 "bfin-parse.y"
4195     {
4196           if (!IS_DREG ((yyvsp[(3) - (6)].reg)) && !IS_PREG ((yyvsp[(3) - (6)].reg)))
4197             return yyerror ("Bad register in comparison");
4198
4199           if (((yyvsp[(6) - (6)].r0).r0 == 1 && IS_IMM ((yyvsp[(5) - (6)].expr), 3))
4200               || ((yyvsp[(6) - (6)].r0).r0 == 3 && IS_UIMM ((yyvsp[(5) - (6)].expr), 3)))
4201             {
4202               notethat ("CCflag: CC = dpregs < (u)imm3\n");
4203               (yyval.instr) = CCFLAG (&(yyvsp[(3) - (6)].reg), imm3 ((yyvsp[(5) - (6)].expr)), (yyvsp[(6) - (6)].r0).r0, 1, IS_PREG ((yyvsp[(3) - (6)].reg)) ? 1 : 0);
4204             }
4205           else
4206             return yyerror ("Bad constant value");
4207         }
4208     break;
4209
4210   case 73:
4211 #line 1685 "bfin-parse.y"
4212     {
4213           if ((IS_DREG ((yyvsp[(3) - (5)].reg)) && IS_DREG ((yyvsp[(5) - (5)].reg)))
4214               || (IS_PREG ((yyvsp[(3) - (5)].reg)) && IS_PREG ((yyvsp[(5) - (5)].reg))))
4215             {
4216               notethat ("CCflag: CC = dpregs == dpregs\n");
4217               (yyval.instr) = CCFLAG (&(yyvsp[(3) - (5)].reg), (yyvsp[(5) - (5)].reg).regno & CODE_MASK, 0, 0, IS_PREG ((yyvsp[(3) - (5)].reg)) ? 1 : 0);
4218             }
4219           else
4220             return yyerror ("Bad register in comparison");
4221         }
4222     break;
4223
4224   case 74:
4225 #line 1696 "bfin-parse.y"
4226     {
4227           if (!IS_DREG ((yyvsp[(3) - (5)].reg)) && !IS_PREG ((yyvsp[(3) - (5)].reg)))
4228             return yyerror ("Bad register in comparison");
4229
4230           if (IS_IMM ((yyvsp[(5) - (5)].expr), 3))
4231             {
4232               notethat ("CCflag: CC = dpregs == imm3\n");
4233               (yyval.instr) = CCFLAG (&(yyvsp[(3) - (5)].reg), imm3 ((yyvsp[(5) - (5)].expr)), 0, 1, IS_PREG ((yyvsp[(3) - (5)].reg)) ? 1 : 0);
4234             }
4235           else
4236             return yyerror ("Bad constant range");
4237         }
4238     break;
4239
4240   case 75:
4241 #line 1709 "bfin-parse.y"
4242     {
4243           if ((yyvsp[(3) - (5)].reg).regno == REG_A0 && (yyvsp[(5) - (5)].reg).regno == REG_A1)
4244             {
4245               notethat ("CCflag: CC = A0 <= A1\n");
4246               (yyval.instr) = CCFLAG (0, 0, 7, 0, 0);
4247             }
4248           else
4249             return yyerror ("AREGs are in bad order or same");
4250         }
4251     break;
4252
4253   case 76:
4254 #line 1719 "bfin-parse.y"
4255     {
4256           if ((IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
4257               || (IS_PREG ((yyvsp[(3) - (6)].reg)) && IS_PREG ((yyvsp[(5) - (6)].reg))))
4258             {
4259               notethat ("CCflag: CC = dpregs <= dpregs (..)\n");
4260               (yyval.instr) = CCFLAG (&(yyvsp[(3) - (6)].reg), (yyvsp[(5) - (6)].reg).regno & CODE_MASK,
4261                            1 + (yyvsp[(6) - (6)].r0).r0, 0, IS_PREG ((yyvsp[(3) - (6)].reg)) ? 1 : 0);
4262             }
4263           else
4264             return yyerror ("Bad register in comparison");
4265         }
4266     break;
4267
4268   case 77:
4269 #line 1731 "bfin-parse.y"
4270     {
4271           if (!IS_DREG ((yyvsp[(3) - (6)].reg)) && !IS_PREG ((yyvsp[(3) - (6)].reg)))
4272             return yyerror ("Bad register in comparison");
4273
4274           if (((yyvsp[(6) - (6)].r0).r0 == 1 && IS_IMM ((yyvsp[(5) - (6)].expr), 3))
4275               || ((yyvsp[(6) - (6)].r0).r0 == 3 && IS_UIMM ((yyvsp[(5) - (6)].expr), 3)))
4276             {
4277               notethat ("CCflag: CC = dpregs <= (u)imm3\n");
4278               (yyval.instr) = CCFLAG (&(yyvsp[(3) - (6)].reg), imm3 ((yyvsp[(5) - (6)].expr)), 1 + (yyvsp[(6) - (6)].r0).r0, 1, IS_PREG ((yyvsp[(3) - (6)].reg)) ? 1 : 0);
4279             }
4280           else
4281             return yyerror ("Bad constant value");
4282         }
4283     break;
4284
4285   case 78:
4286 #line 1746 "bfin-parse.y"
4287     {
4288           if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(3) - (5)].reg)) && IS_DREG ((yyvsp[(5) - (5)].reg)))
4289             {
4290               notethat ("COMP3op: dregs = dregs & dregs\n");
4291               (yyval.instr) = COMP3OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(3) - (5)].reg), &(yyvsp[(5) - (5)].reg), 2);
4292             }
4293           else
4294             return yyerror ("Dregs expected");
4295         }
4296     break;
4297
4298   case 79:
4299 #line 1757 "bfin-parse.y"
4300     {
4301           notethat ("CC2stat operation\n");
4302           (yyval.instr) = bfin_gen_cc2stat ((yyvsp[(1) - (1)].modcodes).r0, (yyvsp[(1) - (1)].modcodes).x0, (yyvsp[(1) - (1)].modcodes).s0);
4303         }
4304     break;
4305
4306   case 80:
4307 #line 1763 "bfin-parse.y"
4308     {
4309           if ((IS_GENREG ((yyvsp[(1) - (3)].reg)) && IS_GENREG ((yyvsp[(3) - (3)].reg)))
4310               || (IS_GENREG ((yyvsp[(1) - (3)].reg)) && IS_DAGREG ((yyvsp[(3) - (3)].reg)))
4311               || (IS_DAGREG ((yyvsp[(1) - (3)].reg)) && IS_GENREG ((yyvsp[(3) - (3)].reg)))
4312               || (IS_DAGREG ((yyvsp[(1) - (3)].reg)) && IS_DAGREG ((yyvsp[(3) - (3)].reg)))
4313               || (IS_GENREG ((yyvsp[(1) - (3)].reg)) && (yyvsp[(3) - (3)].reg).regno == REG_USP)
4314               || ((yyvsp[(1) - (3)].reg).regno == REG_USP && IS_GENREG ((yyvsp[(3) - (3)].reg)))
4315               || ((yyvsp[(1) - (3)].reg).regno == REG_USP && (yyvsp[(3) - (3)].reg).regno == REG_USP)
4316               || (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_SYSREG ((yyvsp[(3) - (3)].reg)))
4317               || (IS_PREG ((yyvsp[(1) - (3)].reg)) && IS_SYSREG ((yyvsp[(3) - (3)].reg)))
4318               || (IS_SYSREG ((yyvsp[(1) - (3)].reg)) && IS_GENREG ((yyvsp[(3) - (3)].reg)))
4319               || (IS_ALLREG ((yyvsp[(1) - (3)].reg)) && IS_EMUDAT ((yyvsp[(3) - (3)].reg)))
4320               || (IS_EMUDAT ((yyvsp[(1) - (3)].reg)) && IS_ALLREG ((yyvsp[(3) - (3)].reg)))
4321               || (IS_SYSREG ((yyvsp[(1) - (3)].reg)) && (yyvsp[(3) - (3)].reg).regno == REG_USP))
4322             {
4323               (yyval.instr) = bfin_gen_regmv (&(yyvsp[(3) - (3)].reg), &(yyvsp[(1) - (3)].reg));
4324             }
4325           else
4326             return yyerror ("Unsupported register move");
4327         }
4328     break;
4329
4330   case 81:
4331 #line 1785 "bfin-parse.y"
4332     {
4333           if (IS_DREG ((yyvsp[(3) - (3)].reg)))
4334             {
4335               notethat ("CC2dreg: CC = dregs\n");
4336               (yyval.instr) = bfin_gen_cc2dreg (1, &(yyvsp[(3) - (3)].reg));
4337             }
4338           else
4339             return yyerror ("Only 'CC = Dreg' supported");
4340         }
4341     break;
4342
4343   case 82:
4344 #line 1796 "bfin-parse.y"
4345     {
4346           if (IS_DREG ((yyvsp[(1) - (3)].reg)))
4347             {
4348               notethat ("CC2dreg: dregs = CC\n");
4349               (yyval.instr) = bfin_gen_cc2dreg (0, &(yyvsp[(1) - (3)].reg));
4350             }
4351           else
4352             return yyerror ("Only 'Dreg = CC' supported");
4353         }
4354     break;
4355
4356   case 83:
4357 #line 1807 "bfin-parse.y"
4358     {
4359           notethat ("CC2dreg: CC =! CC\n");
4360           (yyval.instr) = bfin_gen_cc2dreg (3, 0);
4361         }
4362     break;
4363
4364   case 84:
4365 #line 1815 "bfin-parse.y"
4366     {
4367           notethat ("dsp32mult: dregs_half = multiply_halfregs (opt_mode)\n");
4368
4369           if (!IS_H ((yyvsp[(1) - (4)].reg)) && (yyvsp[(4) - (4)].mod).MM)
4370             return yyerror ("(M) not allowed with MAC0");
4371
4372           if ((yyvsp[(4) - (4)].mod).mod != 0 && (yyvsp[(4) - (4)].mod).mod != M_FU && (yyvsp[(4) - (4)].mod).mod != M_IS
4373               && (yyvsp[(4) - (4)].mod).mod != M_IU && (yyvsp[(4) - (4)].mod).mod != M_T && (yyvsp[(4) - (4)].mod).mod != M_TFU
4374               && (yyvsp[(4) - (4)].mod).mod != M_S2RND && (yyvsp[(4) - (4)].mod).mod != M_ISS2 && (yyvsp[(4) - (4)].mod).mod != M_IH)
4375             return yyerror ("bad option.");
4376
4377           if (IS_H ((yyvsp[(1) - (4)].reg)))
4378             {
4379               (yyval.instr) = DSP32MULT (0, (yyvsp[(4) - (4)].mod).MM, (yyvsp[(4) - (4)].mod).mod, 1, 0,
4380                               IS_H ((yyvsp[(3) - (4)].macfunc).s0), IS_H ((yyvsp[(3) - (4)].macfunc).s1), 0, 0,
4381                               &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(3) - (4)].macfunc).s0, &(yyvsp[(3) - (4)].macfunc).s1, 0);
4382             }
4383           else
4384             {
4385               (yyval.instr) = DSP32MULT (0, 0, (yyvsp[(4) - (4)].mod).mod, 0, 0,
4386                               0, 0, IS_H ((yyvsp[(3) - (4)].macfunc).s0), IS_H ((yyvsp[(3) - (4)].macfunc).s1),
4387                               &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(3) - (4)].macfunc).s0, &(yyvsp[(3) - (4)].macfunc).s1, 1);
4388             }
4389         }
4390     break;
4391
4392   case 85:
4393 #line 1841 "bfin-parse.y"
4394     {
4395           /* Odd registers can use (M).  */
4396           if (!IS_DREG ((yyvsp[(1) - (4)].reg)))
4397             return yyerror ("Dreg expected");
4398
4399           if (IS_EVEN ((yyvsp[(1) - (4)].reg)) && (yyvsp[(4) - (4)].mod).MM)
4400             return yyerror ("(M) not allowed with MAC0");
4401
4402           if ((yyvsp[(4) - (4)].mod).mod != 0 && (yyvsp[(4) - (4)].mod).mod != M_FU && (yyvsp[(4) - (4)].mod).mod != M_IS
4403               && (yyvsp[(4) - (4)].mod).mod != M_S2RND && (yyvsp[(4) - (4)].mod).mod != M_ISS2)
4404             return yyerror ("bad option");
4405
4406           if (!IS_EVEN ((yyvsp[(1) - (4)].reg)))
4407             {
4408               notethat ("dsp32mult: dregs = multiply_halfregs (opt_mode)\n");
4409
4410               (yyval.instr) = DSP32MULT (0, (yyvsp[(4) - (4)].mod).MM, (yyvsp[(4) - (4)].mod).mod, 1, 1,
4411                               IS_H ((yyvsp[(3) - (4)].macfunc).s0), IS_H ((yyvsp[(3) - (4)].macfunc).s1), 0, 0,
4412                               &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(3) - (4)].macfunc).s0, &(yyvsp[(3) - (4)].macfunc).s1, 0);
4413             }
4414           else
4415             {
4416               notethat ("dsp32mult: dregs = multiply_halfregs opt_mode\n");
4417               (yyval.instr) = DSP32MULT (0, 0, (yyvsp[(4) - (4)].mod).mod, 0, 1,
4418                               0, 0, IS_H ((yyvsp[(3) - (4)].macfunc).s0), IS_H ((yyvsp[(3) - (4)].macfunc).s1),
4419                               &(yyvsp[(1) - (4)].reg),  0, &(yyvsp[(3) - (4)].macfunc).s0, &(yyvsp[(3) - (4)].macfunc).s1, 1);
4420             }
4421         }
4422     break;
4423
4424   case 86:
4425 #line 1872 "bfin-parse.y"
4426     {
4427           if (!IS_DREG ((yyvsp[(1) - (9)].reg)) || !IS_DREG ((yyvsp[(6) - (9)].reg)))
4428             return yyerror ("Dregs expected");
4429
4430           if (!IS_HCOMPL((yyvsp[(1) - (9)].reg), (yyvsp[(6) - (9)].reg)))
4431             return yyerror ("Dest registers mismatch");
4432
4433           if (check_multiply_halfregs (&(yyvsp[(3) - (9)].macfunc), &(yyvsp[(8) - (9)].macfunc)) < 0)
4434             return -1;
4435
4436           if ((!IS_H ((yyvsp[(1) - (9)].reg)) && (yyvsp[(4) - (9)].mod).MM)
4437               || (!IS_H ((yyvsp[(6) - (9)].reg)) && (yyvsp[(9) - (9)].mod).MM))
4438             return yyerror ("(M) not allowed with MAC0");
4439
4440           notethat ("dsp32mult: dregs_hi = multiply_halfregs mxd_mod, "
4441                     "dregs_lo = multiply_halfregs opt_mode\n");
4442
4443           if (IS_H ((yyvsp[(1) - (9)].reg)))
4444             (yyval.instr) = DSP32MULT (0, (yyvsp[(4) - (9)].mod).MM, (yyvsp[(9) - (9)].mod).mod, 1, 0,
4445                             IS_H ((yyvsp[(3) - (9)].macfunc).s0), IS_H ((yyvsp[(3) - (9)].macfunc).s1), IS_H ((yyvsp[(8) - (9)].macfunc).s0), IS_H ((yyvsp[(8) - (9)].macfunc).s1),
4446                             &(yyvsp[(1) - (9)].reg), 0, &(yyvsp[(3) - (9)].macfunc).s0, &(yyvsp[(3) - (9)].macfunc).s1, 1);
4447           else
4448             (yyval.instr) = DSP32MULT (0, (yyvsp[(9) - (9)].mod).MM, (yyvsp[(9) - (9)].mod).mod, 1, 0,
4449                             IS_H ((yyvsp[(8) - (9)].macfunc).s0), IS_H ((yyvsp[(8) - (9)].macfunc).s1), IS_H ((yyvsp[(3) - (9)].macfunc).s0), IS_H ((yyvsp[(3) - (9)].macfunc).s1),
4450                             &(yyvsp[(1) - (9)].reg), 0, &(yyvsp[(3) - (9)].macfunc).s0, &(yyvsp[(3) - (9)].macfunc).s1, 1);
4451         }
4452     break;
4453
4454   case 87:
4455 #line 1900 "bfin-parse.y"
4456     {
4457           if (!IS_DREG ((yyvsp[(1) - (9)].reg)) || !IS_DREG ((yyvsp[(6) - (9)].reg)))
4458             return yyerror ("Dregs expected");
4459
4460           if ((IS_EVEN ((yyvsp[(1) - (9)].reg)) && (yyvsp[(6) - (9)].reg).regno - (yyvsp[(1) - (9)].reg).regno != 1)
4461               || (IS_EVEN ((yyvsp[(6) - (9)].reg)) && (yyvsp[(1) - (9)].reg).regno - (yyvsp[(6) - (9)].reg).regno != 1))
4462             return yyerror ("Dest registers mismatch");
4463
4464           if (check_multiply_halfregs (&(yyvsp[(3) - (9)].macfunc), &(yyvsp[(8) - (9)].macfunc)) < 0)
4465             return -1;
4466
4467           if ((IS_EVEN ((yyvsp[(1) - (9)].reg)) && (yyvsp[(4) - (9)].mod).MM)
4468               || (IS_EVEN ((yyvsp[(6) - (9)].reg)) && (yyvsp[(9) - (9)].mod).MM))
4469             return yyerror ("(M) not allowed with MAC0");
4470
4471           notethat ("dsp32mult: dregs = multiply_halfregs mxd_mod, "
4472                    "dregs = multiply_halfregs opt_mode\n");
4473
4474           if (IS_EVEN ((yyvsp[(1) - (9)].reg)))
4475             (yyval.instr) = DSP32MULT (0, (yyvsp[(9) - (9)].mod).MM, (yyvsp[(9) - (9)].mod).mod, 1, 1,
4476                             IS_H ((yyvsp[(8) - (9)].macfunc).s0), IS_H ((yyvsp[(8) - (9)].macfunc).s1), IS_H ((yyvsp[(3) - (9)].macfunc).s0), IS_H ((yyvsp[(3) - (9)].macfunc).s1),
4477                             &(yyvsp[(1) - (9)].reg), 0, &(yyvsp[(3) - (9)].macfunc).s0, &(yyvsp[(3) - (9)].macfunc).s1, 1);
4478           else
4479             (yyval.instr) = DSP32MULT (0, (yyvsp[(4) - (9)].mod).MM, (yyvsp[(9) - (9)].mod).mod, 1, 1,
4480                             IS_H ((yyvsp[(3) - (9)].macfunc).s0), IS_H ((yyvsp[(3) - (9)].macfunc).s1), IS_H ((yyvsp[(8) - (9)].macfunc).s0), IS_H ((yyvsp[(8) - (9)].macfunc).s1),
4481                             &(yyvsp[(1) - (9)].reg), 0, &(yyvsp[(3) - (9)].macfunc).s0, &(yyvsp[(3) - (9)].macfunc).s1, 1);
4482         }
4483     break;
4484
4485   case 88:
4486 #line 1931 "bfin-parse.y"
4487     {
4488           if (!REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(3) - (5)].reg)))
4489             return yyerror ("Aregs must be same");
4490
4491           if (IS_DREG ((yyvsp[(5) - (5)].reg)) && !IS_H ((yyvsp[(5) - (5)].reg)))
4492             {
4493               notethat ("dsp32shift: A0 = ASHIFT A0 BY dregs_lo\n");
4494               (yyval.instr) = DSP32SHIFT (3, 0, &(yyvsp[(5) - (5)].reg), 0, 0, IS_A1 ((yyvsp[(1) - (5)].reg)));
4495             }
4496           else
4497             return yyerror ("Dregs expected");
4498         }
4499     break;
4500
4501   case 89:
4502 #line 1945 "bfin-parse.y"
4503     {
4504           if (IS_DREG ((yyvsp[(6) - (7)].reg)) && !IS_H ((yyvsp[(6) - (7)].reg)))
4505             {
4506               notethat ("dsp32shift: dregs_half = ASHIFT dregs_half BY dregs_lo\n");
4507               (yyval.instr) = DSP32SHIFT (0, &(yyvsp[(1) - (7)].reg), &(yyvsp[(6) - (7)].reg), &(yyvsp[(4) - (7)].reg), (yyvsp[(7) - (7)].modcodes).s0, HL2 ((yyvsp[(1) - (7)].reg), (yyvsp[(4) - (7)].reg)));
4508             }
4509           else
4510             return yyerror ("Dregs expected");
4511         }
4512     break;
4513
4514   case 90:
4515 #line 1956 "bfin-parse.y"
4516     {
4517           if (!REG_SAME ((yyvsp[(1) - (4)].reg), (yyvsp[(2) - (4)].reg)))
4518             return yyerror ("Aregs must be same");
4519
4520           if (IS_UIMM ((yyvsp[(4) - (4)].expr), 5))
4521             {
4522               notethat ("dsp32shiftimm: A0 = A0 << uimm5\n");
4523               (yyval.instr) = DSP32SHIFTIMM (3, 0, imm5 ((yyvsp[(4) - (4)].expr)), 0, 0, IS_A1 ((yyvsp[(1) - (4)].reg)));
4524             }
4525           else
4526             return yyerror ("Bad shift value");
4527         }
4528     break;
4529
4530   case 91:
4531 #line 1970 "bfin-parse.y"
4532     {
4533           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
4534             {
4535               if ((yyvsp[(6) - (6)].modcodes).r0)
4536                 {
4537                   /*  Vector?  */
4538                   notethat ("dsp32shiftimm: dregs = dregs << expr (V, .)\n");
4539                   (yyval.instr) = DSP32SHIFTIMM (1, &(yyvsp[(1) - (6)].reg), imm4 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), (yyvsp[(6) - (6)].modcodes).s0 ? 1 : 2, 0);
4540                 }
4541               else
4542                 {
4543                   notethat ("dsp32shiftimm: dregs =  dregs << uimm5 (.)\n");
4544                   (yyval.instr) = DSP32SHIFTIMM (2, &(yyvsp[(1) - (6)].reg), imm6 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), (yyvsp[(6) - (6)].modcodes).s0 ? 1 : 2, 0);
4545                 }
4546             }
4547           else if ((yyvsp[(6) - (6)].modcodes).s0 == 0 && IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)))
4548             {
4549               if (EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 2)
4550                 {
4551                   notethat ("PTR2op: pregs = pregs << 2\n");
4552                   (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 1);
4553                 }
4554               else if (EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 1)
4555                 {
4556                   notethat ("COMP3op: pregs = pregs << 1\n");
4557                   (yyval.instr) = COMP3OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(3) - (6)].reg), 5);
4558                 }
4559               else
4560                 return yyerror ("Bad shift value");
4561             }
4562           else
4563             return yyerror ("Bad shift value or register");
4564         }
4565     break;
4566
4567   case 92:
4568 #line 2004 "bfin-parse.y"
4569     {
4570           if (IS_UIMM ((yyvsp[(5) - (6)].expr), 4))
4571             {
4572               if ((yyvsp[(6) - (6)].modcodes).s0)
4573                 {
4574                   notethat ("dsp32shiftimm: dregs_half = dregs_half << uimm4 (S)\n");
4575                   (yyval.instr) = DSP32SHIFTIMM (0x0, &(yyvsp[(1) - (6)].reg), imm5 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), (yyvsp[(6) - (6)].modcodes).s0, HL2 ((yyvsp[(1) - (6)].reg), (yyvsp[(3) - (6)].reg)));
4576                 }
4577               else
4578                 {
4579                   notethat ("dsp32shiftimm: dregs_half = dregs_half << uimm4\n");
4580                   (yyval.instr) = DSP32SHIFTIMM (0x0, &(yyvsp[(1) - (6)].reg), imm5 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), 2, HL2 ((yyvsp[(1) - (6)].reg), (yyvsp[(3) - (6)].reg)));
4581                 }
4582             }
4583           else
4584             return yyerror ("Bad shift value");
4585         }
4586     break;
4587
4588   case 93:
4589 #line 2022 "bfin-parse.y"
4590     {
4591           int op;
4592
4593           if (IS_DREG ((yyvsp[(1) - (7)].reg)) && IS_DREG ((yyvsp[(4) - (7)].reg)) && IS_DREG ((yyvsp[(6) - (7)].reg)) && !IS_H ((yyvsp[(6) - (7)].reg)))
4594             {
4595               if ((yyvsp[(7) - (7)].modcodes).r0)
4596                 {
4597                   op = 1;
4598                   notethat ("dsp32shift: dregs = ASHIFT dregs BY "
4599                            "dregs_lo (V, .)\n");
4600                 }
4601               else
4602                 {
4603
4604                   op = 2;
4605                   notethat ("dsp32shift: dregs = ASHIFT dregs BY dregs_lo (.)\n");
4606                 }
4607               (yyval.instr) = DSP32SHIFT (op, &(yyvsp[(1) - (7)].reg), &(yyvsp[(6) - (7)].reg), &(yyvsp[(4) - (7)].reg), (yyvsp[(7) - (7)].modcodes).s0, 0);
4608             }
4609           else
4610             return yyerror ("Dregs expected");
4611         }
4612     break;
4613
4614   case 94:
4615 #line 2047 "bfin-parse.y"
4616     {
4617           if (IS_DREG_L ((yyvsp[(1) - (9)].reg)) && IS_DREG_L ((yyvsp[(5) - (9)].reg)) && IS_DREG_L ((yyvsp[(7) - (9)].reg)))
4618             {
4619               notethat ("dsp32shift: dregs_lo = EXPADJ (dregs , dregs_lo )\n");
4620               (yyval.instr) = DSP32SHIFT (7, &(yyvsp[(1) - (9)].reg), &(yyvsp[(7) - (9)].reg), &(yyvsp[(5) - (9)].reg), (yyvsp[(9) - (9)].r0).r0, 0);
4621             }
4622           else
4623             return yyerror ("Bad shift value or register");
4624         }
4625     break;
4626
4627   case 95:
4628 #line 2059 "bfin-parse.y"
4629     {
4630           if (IS_DREG_L ((yyvsp[(1) - (8)].reg)) && IS_DREG_L ((yyvsp[(5) - (8)].reg)) && IS_DREG_L ((yyvsp[(7) - (8)].reg)))
4631             {
4632               notethat ("dsp32shift: dregs_lo = EXPADJ (dregs_lo, dregs_lo)\n");
4633               (yyval.instr) = DSP32SHIFT (7, &(yyvsp[(1) - (8)].reg), &(yyvsp[(7) - (8)].reg), &(yyvsp[(5) - (8)].reg), 2, 0);
4634             }
4635           else if (IS_DREG_L ((yyvsp[(1) - (8)].reg)) && IS_DREG_H ((yyvsp[(5) - (8)].reg)) && IS_DREG_L ((yyvsp[(7) - (8)].reg)))
4636             {
4637               notethat ("dsp32shift: dregs_lo = EXPADJ (dregs_hi, dregs_lo)\n");
4638               (yyval.instr) = DSP32SHIFT (7, &(yyvsp[(1) - (8)].reg), &(yyvsp[(7) - (8)].reg), &(yyvsp[(5) - (8)].reg), 3, 0);
4639             }
4640           else
4641             return yyerror ("Bad shift value or register");
4642         }
4643     break;
4644
4645   case 96:
4646 #line 2077 "bfin-parse.y"
4647     {
4648           if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
4649             {
4650               notethat ("dsp32shift: dregs = DEPOSIT (dregs , dregs )\n");
4651               (yyval.instr) = DSP32SHIFT (10, &(yyvsp[(1) - (8)].reg), &(yyvsp[(7) - (8)].reg), &(yyvsp[(5) - (8)].reg), 2, 0);
4652             }
4653           else
4654             return yyerror ("Register mismatch");
4655         }
4656     break;
4657
4658   case 97:
4659 #line 2088 "bfin-parse.y"
4660     {
4661           if (IS_DREG ((yyvsp[(1) - (11)].reg)) && IS_DREG ((yyvsp[(5) - (11)].reg)) && IS_DREG ((yyvsp[(7) - (11)].reg)))
4662             {
4663               notethat ("dsp32shift: dregs = DEPOSIT (dregs , dregs ) (X)\n");
4664               (yyval.instr) = DSP32SHIFT (10, &(yyvsp[(1) - (11)].reg), &(yyvsp[(7) - (11)].reg), &(yyvsp[(5) - (11)].reg), 3, 0);
4665             }
4666           else
4667             return yyerror ("Register mismatch");
4668         }
4669     break;
4670
4671   case 98:
4672 #line 2099 "bfin-parse.y"
4673     {
4674           if (IS_DREG ((yyvsp[(1) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && IS_DREG_L ((yyvsp[(7) - (9)].reg)))
4675             {
4676               notethat ("dsp32shift: dregs = EXTRACT (dregs, dregs_lo ) (.)\n");
4677               (yyval.instr) = DSP32SHIFT (10, &(yyvsp[(1) - (9)].reg), &(yyvsp[(7) - (9)].reg), &(yyvsp[(5) - (9)].reg), (yyvsp[(9) - (9)].r0).r0, 0);
4678             }
4679           else
4680             return yyerror ("Register mismatch");
4681         }
4682     break;
4683
4684   case 99:
4685 #line 2110 "bfin-parse.y"
4686     {
4687           if (!REG_SAME ((yyvsp[(1) - (4)].reg), (yyvsp[(2) - (4)].reg)))
4688             return yyerror ("Aregs must be same");
4689
4690           if (IS_UIMM ((yyvsp[(4) - (4)].expr), 5))
4691             {
4692               notethat ("dsp32shiftimm: Ax = Ax >>> uimm5\n");
4693               (yyval.instr) = DSP32SHIFTIMM (3, 0, -imm6 ((yyvsp[(4) - (4)].expr)), 0, 0, IS_A1 ((yyvsp[(1) - (4)].reg)));
4694             }
4695           else
4696             return yyerror ("Shift value range error");
4697         }
4698     break;
4699
4700   case 100:
4701 #line 2123 "bfin-parse.y"
4702     {
4703           if (REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(3) - (5)].reg)) && IS_DREG_L ((yyvsp[(5) - (5)].reg)))
4704             {
4705               notethat ("dsp32shift: Ax = LSHIFT Ax BY dregs_lo\n");
4706               (yyval.instr) = DSP32SHIFT (3, 0, &(yyvsp[(5) - (5)].reg), 0, 1, IS_A1 ((yyvsp[(1) - (5)].reg)));
4707             }
4708           else
4709             return yyerror ("Register mismatch");
4710         }
4711     break;
4712
4713   case 101:
4714 #line 2134 "bfin-parse.y"
4715     {
4716           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_DREG_L ((yyvsp[(6) - (6)].reg)))
4717             {
4718               notethat ("dsp32shift: dregs_lo = LSHIFT dregs_hi BY dregs_lo\n");
4719               (yyval.instr) = DSP32SHIFT (0, &(yyvsp[(1) - (6)].reg), &(yyvsp[(6) - (6)].reg), &(yyvsp[(4) - (6)].reg), 2, HL2 ((yyvsp[(1) - (6)].reg), (yyvsp[(4) - (6)].reg)));
4720             }
4721           else
4722             return yyerror ("Register mismatch");
4723         }
4724     break;
4725
4726   case 102:
4727 #line 2145 "bfin-parse.y"
4728     {
4729           if (IS_DREG ((yyvsp[(1) - (7)].reg)) && IS_DREG ((yyvsp[(4) - (7)].reg)) && IS_DREG_L ((yyvsp[(6) - (7)].reg)))
4730             {
4731               notethat ("dsp32shift: dregs = LSHIFT dregs BY dregs_lo (V )\n");
4732               (yyval.instr) = DSP32SHIFT ((yyvsp[(7) - (7)].r0).r0 ? 1: 2, &(yyvsp[(1) - (7)].reg), &(yyvsp[(6) - (7)].reg), &(yyvsp[(4) - (7)].reg), 2, 0);
4733             }
4734           else
4735             return yyerror ("Register mismatch");
4736         }
4737     break;
4738
4739   case 103:
4740 #line 2156 "bfin-parse.y"
4741     {
4742           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_DREG_L ((yyvsp[(6) - (6)].reg)))
4743             {
4744               notethat ("dsp32shift: dregs = SHIFT dregs BY dregs_lo\n");
4745               (yyval.instr) = DSP32SHIFT (2, &(yyvsp[(1) - (6)].reg), &(yyvsp[(6) - (6)].reg), &(yyvsp[(4) - (6)].reg), 2, 0);
4746             }
4747           else
4748             return yyerror ("Register mismatch");
4749         }
4750     break;
4751
4752   case 104:
4753 #line 2167 "bfin-parse.y"
4754     {
4755           if (REG_SAME ((yyvsp[(1) - (4)].reg), (yyvsp[(2) - (4)].reg)) && IS_IMM ((yyvsp[(4) - (4)].expr), 6) >= 0)
4756             {
4757               notethat ("dsp32shiftimm: Ax = Ax >> imm6\n");
4758               (yyval.instr) = DSP32SHIFTIMM (3, 0, -imm6 ((yyvsp[(4) - (4)].expr)), 0, 1, IS_A1 ((yyvsp[(1) - (4)].reg)));
4759             }
4760           else
4761             return yyerror ("Accu register expected");
4762         }
4763     break;
4764
4765   case 105:
4766 #line 2178 "bfin-parse.y"
4767     {
4768           if ((yyvsp[(6) - (6)].r0).r0 == 1)
4769             {
4770               if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
4771                 {
4772                   notethat ("dsp32shiftimm: dregs = dregs >> uimm5 (V)\n");
4773                   (yyval.instr) = DSP32SHIFTIMM (1, &(yyvsp[(1) - (6)].reg), -uimm5 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), 2, 0);
4774                 }
4775               else
4776                 return yyerror ("Register mismatch");
4777             }
4778           else
4779             {
4780               if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
4781                 {
4782                   notethat ("dsp32shiftimm: dregs = dregs >> uimm5\n");
4783                   (yyval.instr) = DSP32SHIFTIMM (2, &(yyvsp[(1) - (6)].reg), -imm6 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), 2, 0);
4784                 }
4785               else if (IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)) && EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 2)
4786                 {
4787                   notethat ("PTR2op: pregs = pregs >> 2\n");
4788                   (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 3);
4789                 }
4790               else if (IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)) && EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 1)
4791                 {
4792                   notethat ("PTR2op: pregs = pregs >> 1\n");
4793                   (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 4);
4794                 }
4795               else
4796                 return yyerror ("Register mismatch");
4797             }
4798         }
4799     break;
4800
4801   case 106:
4802 #line 2211 "bfin-parse.y"
4803     {
4804           if (IS_UIMM ((yyvsp[(5) - (5)].expr), 5))
4805             {
4806               notethat ("dsp32shiftimm:  dregs_half =  dregs_half >> uimm5\n");
4807               (yyval.instr) = DSP32SHIFTIMM (0, &(yyvsp[(1) - (5)].reg), -uimm5 ((yyvsp[(5) - (5)].expr)), &(yyvsp[(3) - (5)].reg), 2, HL2 ((yyvsp[(1) - (5)].reg), (yyvsp[(3) - (5)].reg)));
4808             }
4809           else
4810             return yyerror ("Register mismatch");
4811         }
4812     break;
4813
4814   case 107:
4815 #line 2221 "bfin-parse.y"
4816     {
4817           if (IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
4818             {
4819               notethat ("dsp32shiftimm: dregs_half = dregs_half >>> uimm5\n");
4820               (yyval.instr) = DSP32SHIFTIMM (0, &(yyvsp[(1) - (6)].reg), -uimm5 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg),
4821                                   (yyvsp[(6) - (6)].modcodes).s0, HL2 ((yyvsp[(1) - (6)].reg), (yyvsp[(3) - (6)].reg)));
4822             }
4823           else
4824             return yyerror ("Register or modifier mismatch");
4825         }
4826     break;
4827
4828   case 108:
4829 #line 2234 "bfin-parse.y"
4830     {
4831           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
4832             {
4833               if ((yyvsp[(6) - (6)].modcodes).r0)
4834                 {
4835                   /* Vector?  */
4836                   notethat ("dsp32shiftimm: dregs  =  dregs >>> uimm5 (V, .)\n");
4837                   (yyval.instr) = DSP32SHIFTIMM (1, &(yyvsp[(1) - (6)].reg), -uimm5 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), (yyvsp[(6) - (6)].modcodes).s0, 0);
4838                 }
4839               else
4840                 {
4841                   notethat ("dsp32shiftimm: dregs  =  dregs >>> uimm5 (.)\n");
4842                   (yyval.instr) = DSP32SHIFTIMM (2, &(yyvsp[(1) - (6)].reg), -uimm5 ((yyvsp[(5) - (6)].expr)), &(yyvsp[(3) - (6)].reg), (yyvsp[(6) - (6)].modcodes).s0, 0);
4843                 }
4844             }
4845           else
4846             return yyerror ("Register mismatch");
4847         }
4848     break;
4849
4850   case 109:
4851 #line 2254 "bfin-parse.y"
4852     {
4853           if (IS_DREG_L ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(4) - (4)].reg)))
4854             {
4855               notethat ("dsp32shift: dregs_lo = ONES dregs\n");
4856               (yyval.instr) = DSP32SHIFT (6, &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(4) - (4)].reg), 3, 0);
4857             }
4858           else
4859             return yyerror ("Register mismatch");
4860         }
4861     break;
4862
4863   case 110:
4864 #line 2265 "bfin-parse.y"
4865     {
4866           if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
4867             {
4868               notethat ("dsp32shift: dregs = PACK (dregs_hi , dregs_hi )\n");
4869               (yyval.instr) = DSP32SHIFT (4, &(yyvsp[(1) - (8)].reg), &(yyvsp[(7) - (8)].reg), &(yyvsp[(5) - (8)].reg), HL2 ((yyvsp[(5) - (8)].reg), (yyvsp[(7) - (8)].reg)), 0);
4870             }
4871           else
4872             return yyerror ("Register mismatch");
4873         }
4874     break;
4875
4876   case 111:
4877 #line 2276 "bfin-parse.y"
4878     {
4879           if (IS_DREG ((yyvsp[(1) - (10)].reg))
4880               && (yyvsp[(7) - (10)].reg).regno == REG_A0
4881               && IS_DREG ((yyvsp[(9) - (10)].reg)) && !IS_H ((yyvsp[(1) - (10)].reg)) && !IS_A1 ((yyvsp[(7) - (10)].reg)))
4882             {
4883               notethat ("dsp32shift: dregs_lo = CC = BXORSHIFT (A0 , dregs )\n");
4884               (yyval.instr) = DSP32SHIFT (11, &(yyvsp[(1) - (10)].reg), &(yyvsp[(9) - (10)].reg), 0, 0, 0);
4885             }
4886           else
4887             return yyerror ("Register mismatch");
4888         }
4889     break;
4890
4891   case 112:
4892 #line 2289 "bfin-parse.y"
4893     {
4894           if (IS_DREG ((yyvsp[(1) - (10)].reg))
4895               && (yyvsp[(7) - (10)].reg).regno == REG_A0
4896               && IS_DREG ((yyvsp[(9) - (10)].reg)) && !IS_H ((yyvsp[(1) - (10)].reg)) && !IS_A1 ((yyvsp[(7) - (10)].reg)))
4897             {
4898               notethat ("dsp32shift: dregs_lo = CC = BXOR (A0 , dregs)\n");
4899               (yyval.instr) = DSP32SHIFT (11, &(yyvsp[(1) - (10)].reg), &(yyvsp[(9) - (10)].reg), 0, 1, 0);
4900             }
4901           else
4902             return yyerror ("Register mismatch");
4903         }
4904     break;
4905
4906   case 113:
4907 #line 2302 "bfin-parse.y"
4908     {
4909           if (IS_DREG ((yyvsp[(1) - (12)].reg)) && !IS_H ((yyvsp[(1) - (12)].reg)) && !REG_SAME ((yyvsp[(7) - (12)].reg), (yyvsp[(9) - (12)].reg)))
4910             {
4911               notethat ("dsp32shift: dregs_lo = CC = BXOR (A0 , A1 , CC)\n");
4912               (yyval.instr) = DSP32SHIFT (12, &(yyvsp[(1) - (12)].reg), 0, 0, 1, 0);
4913             }
4914           else
4915             return yyerror ("Register mismatch");
4916         }
4917     break;
4918
4919   case 114:
4920 #line 2313 "bfin-parse.y"
4921     {
4922           if (REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(3) - (5)].reg)) && IS_DREG_L ((yyvsp[(5) - (5)].reg)))
4923             {
4924               notethat ("dsp32shift: Ax = ROT Ax BY dregs_lo\n");
4925               (yyval.instr) = DSP32SHIFT (3, 0, &(yyvsp[(5) - (5)].reg), 0, 2, IS_A1 ((yyvsp[(1) - (5)].reg)));
4926             }
4927           else
4928             return yyerror ("Register mismatch");
4929         }
4930     break;
4931
4932   case 115:
4933 #line 2324 "bfin-parse.y"
4934     {
4935           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_DREG_L ((yyvsp[(6) - (6)].reg)))
4936             {
4937               notethat ("dsp32shift: dregs = ROT dregs BY dregs_lo\n");
4938               (yyval.instr) = DSP32SHIFT (2, &(yyvsp[(1) - (6)].reg), &(yyvsp[(6) - (6)].reg), &(yyvsp[(4) - (6)].reg), 3, 0);
4939             }
4940           else
4941             return yyerror ("Register mismatch");
4942         }
4943     break;
4944
4945   case 116:
4946 #line 2335 "bfin-parse.y"
4947     {
4948           if (IS_IMM ((yyvsp[(5) - (5)].expr), 6))
4949             {
4950               notethat ("dsp32shiftimm: An = ROT An BY imm6\n");
4951               (yyval.instr) = DSP32SHIFTIMM (3, 0, imm6 ((yyvsp[(5) - (5)].expr)), 0, 2, IS_A1 ((yyvsp[(1) - (5)].reg)));
4952             }
4953           else
4954             return yyerror ("Register mismatch");
4955         }
4956     break;
4957
4958   case 117:
4959 #line 2346 "bfin-parse.y"
4960     {
4961           if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_IMM ((yyvsp[(6) - (6)].expr), 6))
4962             {
4963               (yyval.instr) = DSP32SHIFTIMM (2, &(yyvsp[(1) - (6)].reg), imm6 ((yyvsp[(6) - (6)].expr)), &(yyvsp[(4) - (6)].reg), 3, IS_A1 ((yyvsp[(1) - (6)].reg)));
4964             }
4965           else
4966             return yyerror ("Register mismatch");
4967         }
4968     break;
4969
4970   case 118:
4971 #line 2356 "bfin-parse.y"
4972     {
4973           if (IS_DREG_L ((yyvsp[(1) - (4)].reg)))
4974             {
4975               notethat ("dsp32shift: dregs_lo = SIGNBITS An\n");
4976               (yyval.instr) = DSP32SHIFT (6, &(yyvsp[(1) - (4)].reg), 0, 0, IS_A1 ((yyvsp[(4) - (4)].reg)), 0);
4977             }
4978           else
4979             return yyerror ("Register mismatch");
4980         }
4981     break;
4982
4983   case 119:
4984 #line 2367 "bfin-parse.y"
4985     {
4986           if (IS_DREG_L ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(4) - (4)].reg)))
4987             {
4988               notethat ("dsp32shift: dregs_lo = SIGNBITS dregs\n");
4989               (yyval.instr) = DSP32SHIFT (5, &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(4) - (4)].reg), 0, 0);
4990             }
4991           else
4992             return yyerror ("Register mismatch");
4993         }
4994     break;
4995
4996   case 120:
4997 #line 2378 "bfin-parse.y"
4998     {
4999           if (IS_DREG_L ((yyvsp[(1) - (4)].reg)))
5000             {
5001               notethat ("dsp32shift: dregs_lo = SIGNBITS dregs_lo\n");
5002               (yyval.instr) = DSP32SHIFT (5, &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(4) - (4)].reg), 1 + IS_H ((yyvsp[(4) - (4)].reg)), 0);
5003             }
5004           else
5005             return yyerror ("Register mismatch");
5006         }
5007     break;
5008
5009   case 121:
5010 #line 2390 "bfin-parse.y"
5011     {
5012           if (IS_DREG_L ((yyvsp[(1) - (7)].reg)) && IS_DREG ((yyvsp[(5) - (7)].reg)))
5013             {
5014               notethat ("dsp32shift: dregs_lo = VIT_MAX (dregs) (..)\n");
5015               (yyval.instr) = DSP32SHIFT (9, &(yyvsp[(1) - (7)].reg), 0, &(yyvsp[(5) - (7)].reg), ((yyvsp[(7) - (7)].r0).r0 ? 0 : 1), 0);
5016             }
5017           else
5018             return yyerror ("Register mismatch");
5019         }
5020     break;
5021
5022   case 122:
5023 #line 2401 "bfin-parse.y"
5024     {
5025           if (IS_DREG ((yyvsp[(1) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && IS_DREG ((yyvsp[(7) - (9)].reg)))
5026             {
5027               notethat ("dsp32shift: dregs = VIT_MAX (dregs, dregs) (ASR)\n");
5028               (yyval.instr) = DSP32SHIFT (9, &(yyvsp[(1) - (9)].reg), &(yyvsp[(7) - (9)].reg), &(yyvsp[(5) - (9)].reg), 2 | ((yyvsp[(9) - (9)].r0).r0 ? 0 : 1), 0);
5029             }
5030           else
5031             return yyerror ("Register mismatch");
5032         }
5033     break;
5034
5035   case 123:
5036 #line 2412 "bfin-parse.y"
5037     {
5038           if (REG_SAME ((yyvsp[(3) - (9)].reg), (yyvsp[(5) - (9)].reg)))
5039             return yyerror ("Illegal source register combination");
5040
5041           if (IS_DREG ((yyvsp[(3) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && !IS_A1 ((yyvsp[(7) - (9)].reg)))
5042             {
5043               notethat ("dsp32shift: BITMUX (dregs , dregs , A0) (ASR)\n");
5044               (yyval.instr) = DSP32SHIFT (8, 0, &(yyvsp[(3) - (9)].reg), &(yyvsp[(5) - (9)].reg), (yyvsp[(9) - (9)].r0).r0, 0);
5045             }
5046           else
5047             return yyerror ("Register mismatch");
5048         }
5049     break;
5050
5051   case 124:
5052 #line 2426 "bfin-parse.y"
5053     {
5054           if (!IS_A1 ((yyvsp[(1) - (9)].reg)) && !IS_A1 ((yyvsp[(4) - (9)].reg)) && IS_A1 ((yyvsp[(6) - (9)].reg)))
5055             {
5056               notethat ("dsp32shift: A0 = BXORSHIFT (A0 , A1 , CC )\n");
5057               (yyval.instr) = DSP32SHIFT (12, 0, 0, 0, 0, 0);
5058             }
5059           else
5060             return yyerror ("Dregs expected");
5061         }
5062     break;
5063
5064   case 125:
5065 #line 2439 "bfin-parse.y"
5066     {
5067           if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
5068             {
5069               notethat ("LOGI2op: BITCLR (dregs , uimm5 )\n");
5070               (yyval.instr) = LOGI2OP ((yyvsp[(3) - (6)].reg), uimm5 ((yyvsp[(5) - (6)].expr)), 4);
5071             }
5072           else
5073             return yyerror ("Register mismatch");
5074         }
5075     break;
5076
5077   case 126:
5078 #line 2451 "bfin-parse.y"
5079     {
5080           if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
5081             {
5082               notethat ("LOGI2op: BITCLR (dregs , uimm5 )\n");
5083               (yyval.instr) = LOGI2OP ((yyvsp[(3) - (6)].reg), uimm5 ((yyvsp[(5) - (6)].expr)), 2);
5084             }
5085           else
5086             return yyerror ("Register mismatch");
5087         }
5088     break;
5089
5090   case 127:
5091 #line 2463 "bfin-parse.y"
5092     {
5093           if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
5094             {
5095               notethat ("LOGI2op: BITCLR (dregs , uimm5 )\n");
5096               (yyval.instr) = LOGI2OP ((yyvsp[(3) - (6)].reg), uimm5 ((yyvsp[(5) - (6)].expr)), 3);
5097             }
5098           else
5099             return yyerror ("Register mismatch");
5100         }
5101     break;
5102
5103   case 128:
5104 #line 2474 "bfin-parse.y"
5105     {
5106           if (IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_UIMM ((yyvsp[(7) - (8)].expr), 5))
5107             {
5108               notethat ("LOGI2op: CC =! BITTST (dregs , uimm5 )\n");
5109               (yyval.instr) = LOGI2OP ((yyvsp[(5) - (8)].reg), uimm5 ((yyvsp[(7) - (8)].expr)), 0);
5110             }
5111           else
5112             return yyerror ("Register mismatch or value error");
5113         }
5114     break;
5115
5116   case 129:
5117 #line 2485 "bfin-parse.y"
5118     {
5119           if (IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_UIMM ((yyvsp[(7) - (8)].expr), 5))
5120             {
5121               notethat ("LOGI2op: CC = BITTST (dregs , uimm5 )\n");
5122               (yyval.instr) = LOGI2OP ((yyvsp[(5) - (8)].reg), uimm5 ((yyvsp[(7) - (8)].expr)), 1);
5123             }
5124           else
5125             return yyerror ("Register mismatch or value error");
5126         }
5127     break;
5128
5129   case 130:
5130 #line 2496 "bfin-parse.y"
5131     {
5132           if ((IS_DREG ((yyvsp[(4) - (6)].reg)) || IS_PREG ((yyvsp[(4) - (6)].reg)))
5133               && (IS_DREG ((yyvsp[(6) - (6)].reg)) || IS_PREG ((yyvsp[(6) - (6)].reg))))
5134             {
5135               notethat ("ccMV: IF ! CC gregs = gregs\n");
5136               (yyval.instr) = CCMV (&(yyvsp[(6) - (6)].reg), &(yyvsp[(4) - (6)].reg), 0);
5137             }
5138           else
5139             return yyerror ("Register mismatch");
5140         }
5141     break;
5142
5143   case 131:
5144 #line 2508 "bfin-parse.y"
5145     {
5146           if ((IS_DREG ((yyvsp[(5) - (5)].reg)) || IS_PREG ((yyvsp[(5) - (5)].reg)))
5147               && (IS_DREG ((yyvsp[(3) - (5)].reg)) || IS_PREG ((yyvsp[(3) - (5)].reg))))
5148             {
5149               notethat ("ccMV: IF CC gregs = gregs\n");
5150               (yyval.instr) = CCMV (&(yyvsp[(5) - (5)].reg), &(yyvsp[(3) - (5)].reg), 1);
5151             }
5152           else
5153             return yyerror ("Register mismatch");
5154         }
5155     break;
5156
5157   case 132:
5158 #line 2520 "bfin-parse.y"
5159     {
5160           if (IS_PCREL10 ((yyvsp[(5) - (5)].expr)))
5161             {
5162               notethat ("BRCC: IF !CC JUMP  pcrel11m2\n");
5163               (yyval.instr) = BRCC (0, 0, (yyvsp[(5) - (5)].expr));
5164             }
5165           else
5166             return yyerror ("Bad jump offset");
5167         }
5168     break;
5169
5170   case 133:
5171 #line 2531 "bfin-parse.y"
5172     {
5173           if (IS_PCREL10 ((yyvsp[(5) - (8)].expr)))
5174             {
5175               notethat ("BRCC: IF !CC JUMP  pcrel11m2\n");
5176               (yyval.instr) = BRCC (0, 1, (yyvsp[(5) - (8)].expr));
5177             }
5178           else
5179             return yyerror ("Bad jump offset");
5180         }
5181     break;
5182
5183   case 134:
5184 #line 2542 "bfin-parse.y"
5185     {
5186           if (IS_PCREL10 ((yyvsp[(4) - (4)].expr)))
5187             {
5188               notethat ("BRCC: IF CC JUMP  pcrel11m2\n");
5189               (yyval.instr) = BRCC (1, 0, (yyvsp[(4) - (4)].expr));
5190             }
5191           else
5192             return yyerror ("Bad jump offset");
5193         }
5194     break;
5195
5196   case 135:
5197 #line 2553 "bfin-parse.y"
5198     {
5199           if (IS_PCREL10 ((yyvsp[(4) - (7)].expr)))
5200             {
5201               notethat ("BRCC: IF !CC JUMP  pcrel11m2\n");
5202               (yyval.instr) = BRCC (1, 1, (yyvsp[(4) - (7)].expr));
5203             }
5204           else
5205             return yyerror ("Bad jump offset");
5206         }
5207     break;
5208
5209   case 136:
5210 #line 2563 "bfin-parse.y"
5211     {
5212           notethat ("ProgCtrl: NOP\n");
5213           (yyval.instr) = PROGCTRL (0, 0);
5214         }
5215     break;
5216
5217   case 137:
5218 #line 2569 "bfin-parse.y"
5219     {
5220           notethat ("ProgCtrl: RTS\n");
5221           (yyval.instr) = PROGCTRL (1, 0);
5222         }
5223     break;
5224
5225   case 138:
5226 #line 2575 "bfin-parse.y"
5227     {
5228           notethat ("ProgCtrl: RTI\n");
5229           (yyval.instr) = PROGCTRL (1, 1);
5230         }
5231     break;
5232
5233   case 139:
5234 #line 2581 "bfin-parse.y"
5235     {
5236           notethat ("ProgCtrl: RTX\n");
5237           (yyval.instr) = PROGCTRL (1, 2);
5238         }
5239     break;
5240
5241   case 140:
5242 #line 2587 "bfin-parse.y"
5243     {
5244           notethat ("ProgCtrl: RTN\n");
5245           (yyval.instr) = PROGCTRL (1, 3);
5246         }
5247     break;
5248
5249   case 141:
5250 #line 2593 "bfin-parse.y"
5251     {
5252           notethat ("ProgCtrl: RTE\n");
5253           (yyval.instr) = PROGCTRL (1, 4);
5254         }
5255     break;
5256
5257   case 142:
5258 #line 2599 "bfin-parse.y"
5259     {
5260           notethat ("ProgCtrl: IDLE\n");
5261           (yyval.instr) = PROGCTRL (2, 0);
5262         }
5263     break;
5264
5265   case 143:
5266 #line 2605 "bfin-parse.y"
5267     {
5268           notethat ("ProgCtrl: CSYNC\n");
5269           (yyval.instr) = PROGCTRL (2, 3);
5270         }
5271     break;
5272
5273   case 144:
5274 #line 2611 "bfin-parse.y"
5275     {
5276           notethat ("ProgCtrl: SSYNC\n");
5277           (yyval.instr) = PROGCTRL (2, 4);
5278         }
5279     break;
5280
5281   case 145:
5282 #line 2617 "bfin-parse.y"
5283     {
5284           notethat ("ProgCtrl: EMUEXCPT\n");
5285           (yyval.instr) = PROGCTRL (2, 5);
5286         }
5287     break;
5288
5289   case 146:
5290 #line 2623 "bfin-parse.y"
5291     {
5292           if (IS_DREG ((yyvsp[(2) - (2)].reg)))
5293             {
5294               notethat ("ProgCtrl: CLI dregs\n");
5295               (yyval.instr) = PROGCTRL (3, (yyvsp[(2) - (2)].reg).regno & CODE_MASK);
5296             }
5297           else
5298             return yyerror ("Dreg expected for CLI");
5299         }
5300     break;
5301
5302   case 147:
5303 #line 2634 "bfin-parse.y"
5304     {
5305           if (IS_DREG ((yyvsp[(2) - (2)].reg)))
5306             {
5307               notethat ("ProgCtrl: STI dregs\n");
5308               (yyval.instr) = PROGCTRL (4, (yyvsp[(2) - (2)].reg).regno & CODE_MASK);
5309             }
5310           else
5311             return yyerror ("Dreg expected for STI");
5312         }
5313     break;
5314
5315   case 148:
5316 #line 2645 "bfin-parse.y"
5317     {
5318           if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5319             {
5320               notethat ("ProgCtrl: JUMP (pregs )\n");
5321               (yyval.instr) = PROGCTRL (5, (yyvsp[(3) - (4)].reg).regno & CODE_MASK);
5322             }
5323           else
5324             return yyerror ("Bad register for indirect jump");
5325         }
5326     break;
5327
5328   case 149:
5329 #line 2656 "bfin-parse.y"
5330     {
5331           if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5332             {
5333               notethat ("ProgCtrl: CALL (pregs )\n");
5334               (yyval.instr) = PROGCTRL (6, (yyvsp[(3) - (4)].reg).regno & CODE_MASK);
5335             }
5336           else
5337             return yyerror ("Bad register for indirect call");
5338         }
5339     break;
5340
5341   case 150:
5342 #line 2667 "bfin-parse.y"
5343     {
5344           if (IS_PREG ((yyvsp[(5) - (6)].reg)))
5345             {
5346               notethat ("ProgCtrl: CALL (PC + pregs )\n");
5347               (yyval.instr) = PROGCTRL (7, (yyvsp[(5) - (6)].reg).regno & CODE_MASK);
5348             }
5349           else
5350             return yyerror ("Bad register for indirect call");
5351         }
5352     break;
5353
5354   case 151:
5355 #line 2678 "bfin-parse.y"
5356     {
5357           if (IS_PREG ((yyvsp[(5) - (6)].reg)))
5358             {
5359               notethat ("ProgCtrl: JUMP (PC + pregs )\n");
5360               (yyval.instr) = PROGCTRL (8, (yyvsp[(5) - (6)].reg).regno & CODE_MASK);
5361             }
5362           else
5363             return yyerror ("Bad register for indirect jump");
5364         }
5365     break;
5366
5367   case 152:
5368 #line 2689 "bfin-parse.y"
5369     {
5370           if (IS_UIMM ((yyvsp[(2) - (2)].expr), 4))
5371             {
5372               notethat ("ProgCtrl: RAISE uimm4\n");
5373               (yyval.instr) = PROGCTRL (9, uimm4 ((yyvsp[(2) - (2)].expr)));
5374             }
5375           else
5376             return yyerror ("Bad value for RAISE");
5377         }
5378     break;
5379
5380   case 153:
5381 #line 2700 "bfin-parse.y"
5382     {
5383                 notethat ("ProgCtrl: EMUEXCPT\n");
5384                 (yyval.instr) = PROGCTRL (10, uimm4 ((yyvsp[(2) - (2)].expr)));
5385         }
5386     break;
5387
5388   case 154:
5389 #line 2706 "bfin-parse.y"
5390     {
5391           if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5392             {
5393               if ((yyvsp[(3) - (4)].reg).regno == REG_SP || (yyvsp[(3) - (4)].reg).regno == REG_FP)
5394                 return yyerror ("Bad register for TESTSET");
5395
5396               notethat ("ProgCtrl: TESTSET (pregs )\n");
5397               (yyval.instr) = PROGCTRL (11, (yyvsp[(3) - (4)].reg).regno & CODE_MASK);
5398             }
5399           else
5400             return yyerror ("Preg expected");
5401         }
5402     break;
5403
5404   case 155:
5405 #line 2720 "bfin-parse.y"
5406     {
5407           if (IS_PCREL12 ((yyvsp[(2) - (2)].expr)))
5408             {
5409               notethat ("UJUMP: JUMP pcrel12\n");
5410               (yyval.instr) = UJUMP ((yyvsp[(2) - (2)].expr));
5411             }
5412           else
5413             return yyerror ("Bad value for relative jump");
5414         }
5415     break;
5416
5417   case 156:
5418 #line 2731 "bfin-parse.y"
5419     {
5420           if (IS_PCREL12 ((yyvsp[(2) - (2)].expr)))
5421             {
5422               notethat ("UJUMP: JUMP_DOT_S pcrel12\n");
5423               (yyval.instr) = UJUMP((yyvsp[(2) - (2)].expr));
5424             }
5425           else
5426             return yyerror ("Bad value for relative jump");
5427         }
5428     break;
5429
5430   case 157:
5431 #line 2742 "bfin-parse.y"
5432     {
5433           if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5434             {
5435               notethat ("CALLa: jump.l pcrel24\n");
5436               (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 0);
5437             }
5438           else
5439             return yyerror ("Bad value for long jump");
5440         }
5441     break;
5442
5443   case 158:
5444 #line 2753 "bfin-parse.y"
5445     {
5446           if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5447             {
5448               notethat ("CALLa: jump.l pcrel24\n");
5449               (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 2);
5450             }
5451           else
5452             return yyerror ("Bad value for long jump");
5453         }
5454     break;
5455
5456   case 159:
5457 #line 2764 "bfin-parse.y"
5458     {
5459           if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5460             {
5461               notethat ("CALLa: CALL pcrel25m2\n");
5462               (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 1);
5463             }
5464           else
5465             return yyerror ("Bad call address");
5466         }
5467     break;
5468
5469   case 160:
5470 #line 2774 "bfin-parse.y"
5471     {
5472           if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5473             {
5474               notethat ("CALLa: CALL pcrel25m2\n");
5475               (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 2);
5476             }
5477           else
5478             return yyerror ("Bad call address");
5479         }
5480     break;
5481
5482   case 161:
5483 #line 2787 "bfin-parse.y"
5484     {
5485           if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
5486             (yyval.instr) = ALU2OP (&(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg), 8);
5487           else
5488             return yyerror ("Bad registers for DIVQ");
5489         }
5490     break;
5491
5492   case 162:
5493 #line 2795 "bfin-parse.y"
5494     {
5495           if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
5496             (yyval.instr) = ALU2OP (&(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg), 9);
5497           else
5498             return yyerror ("Bad registers for DIVS");
5499         }
5500     break;
5501
5502   case 163:
5503 #line 2803 "bfin-parse.y"
5504     {
5505           if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(4) - (5)].reg)))
5506             {
5507               if ((yyvsp[(5) - (5)].modcodes).r0 == 0 && (yyvsp[(5) - (5)].modcodes).s0 == 0 && (yyvsp[(5) - (5)].modcodes).aop == 0)
5508                 {
5509                   notethat ("ALU2op: dregs = - dregs\n");
5510                   (yyval.instr) = ALU2OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(4) - (5)].reg), 14);
5511                 }
5512               else if ((yyvsp[(5) - (5)].modcodes).r0 == 1 && (yyvsp[(5) - (5)].modcodes).s0 == 0 && (yyvsp[(5) - (5)].modcodes).aop == 3)
5513                 {
5514                   notethat ("dsp32alu: dregs = - dregs (.)\n");
5515                   (yyval.instr) = DSP32ALU (15, 0, 0, &(yyvsp[(1) - (5)].reg), &(yyvsp[(4) - (5)].reg), 0, (yyvsp[(5) - (5)].modcodes).s0, 0, 3);
5516                 }
5517               else
5518                 {
5519                   notethat ("dsp32alu: dregs = - dregs (.)\n");
5520                   (yyval.instr) = DSP32ALU (7, 0, 0, &(yyvsp[(1) - (5)].reg), &(yyvsp[(4) - (5)].reg), 0, (yyvsp[(5) - (5)].modcodes).s0, 0, 3);
5521                 }
5522             }
5523           else
5524             return yyerror ("Dregs expected");
5525         }
5526     break;
5527
5528   case 164:
5529 #line 2827 "bfin-parse.y"
5530     {
5531           if (IS_DREG ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(4) - (4)].reg)))
5532             {
5533               notethat ("ALU2op: dregs = ~dregs\n");
5534               (yyval.instr) = ALU2OP (&(yyvsp[(1) - (4)].reg), &(yyvsp[(4) - (4)].reg), 15);
5535             }
5536           else
5537             return yyerror ("Dregs expected");
5538         }
5539     break;
5540
5541   case 165:
5542 #line 2838 "bfin-parse.y"
5543     {
5544           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
5545             {
5546               notethat ("ALU2op: dregs >>= dregs\n");
5547               (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 1);
5548             }
5549           else
5550             return yyerror ("Dregs expected");
5551         }
5552     break;
5553
5554   case 166:
5555 #line 2849 "bfin-parse.y"
5556     {
5557           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_UIMM ((yyvsp[(3) - (3)].expr), 5))
5558             {
5559               notethat ("LOGI2op: dregs >>= uimm5\n");
5560               (yyval.instr) = LOGI2OP ((yyvsp[(1) - (3)].reg), uimm5 ((yyvsp[(3) - (3)].expr)), 6);
5561             }
5562           else
5563             return yyerror ("Dregs expected or value error");
5564         }
5565     break;
5566
5567   case 167:
5568 #line 2860 "bfin-parse.y"
5569     {
5570           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
5571             {
5572               notethat ("ALU2op: dregs >>>= dregs\n");
5573               (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 0);
5574             }
5575           else
5576             return yyerror ("Dregs expected");
5577         }
5578     break;
5579
5580   case 168:
5581 #line 2871 "bfin-parse.y"
5582     {
5583           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
5584             {
5585               notethat ("ALU2op: dregs <<= dregs\n");
5586               (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 2);
5587             }
5588           else
5589             return yyerror ("Dregs expected");
5590         }
5591     break;
5592
5593   case 169:
5594 #line 2882 "bfin-parse.y"
5595     {
5596           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_UIMM ((yyvsp[(3) - (3)].expr), 5))
5597             {
5598               notethat ("LOGI2op: dregs <<= uimm5\n");
5599               (yyval.instr) = LOGI2OP ((yyvsp[(1) - (3)].reg), uimm5 ((yyvsp[(3) - (3)].expr)), 7);
5600             }
5601           else
5602             return yyerror ("Dregs expected or const value error");
5603         }
5604     break;
5605
5606   case 170:
5607 #line 2894 "bfin-parse.y"
5608     {
5609           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_UIMM ((yyvsp[(3) - (3)].expr), 5))
5610             {
5611               notethat ("LOGI2op: dregs >>>= uimm5\n");
5612               (yyval.instr) = LOGI2OP ((yyvsp[(1) - (3)].reg), uimm5 ((yyvsp[(3) - (3)].expr)), 5);
5613             }
5614           else
5615             return yyerror ("Dregs expected");
5616         }
5617     break;
5618
5619   case 171:
5620 #line 2907 "bfin-parse.y"
5621     {
5622           notethat ("CaCTRL: FLUSH [ pregs ]\n");
5623           if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5624             (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 2);
5625           else
5626             return yyerror ("Bad register(s) for FLUSH");
5627         }
5628     break;
5629
5630   case 172:
5631 #line 2916 "bfin-parse.y"
5632     {
5633           if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5634             {
5635               notethat ("CaCTRL: FLUSH [ pregs ++ ]\n");
5636               (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 2);
5637             }
5638           else
5639             return yyerror ("Bad register(s) for FLUSH");
5640         }
5641     break;
5642
5643   case 173:
5644 #line 2927 "bfin-parse.y"
5645     {
5646           if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5647             {
5648               notethat ("CaCTRL: FLUSHINV [ pregs ]\n");
5649               (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 1);
5650             }
5651           else
5652             return yyerror ("Bad register(s) for FLUSH");
5653         }
5654     break;
5655
5656   case 174:
5657 #line 2938 "bfin-parse.y"
5658     {
5659           if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5660             {
5661               notethat ("CaCTRL: FLUSHINV [ pregs ++ ]\n");
5662               (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 1);
5663             }
5664           else
5665             return yyerror ("Bad register(s) for FLUSH");
5666         }
5667     break;
5668
5669   case 175:
5670 #line 2950 "bfin-parse.y"
5671     {
5672           if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5673             {
5674               notethat ("CaCTRL: IFLUSH [ pregs ]\n");
5675               (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 3);
5676             }
5677           else
5678             return yyerror ("Bad register(s) for FLUSH");
5679         }
5680     break;
5681
5682   case 176:
5683 #line 2961 "bfin-parse.y"
5684     {
5685           if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5686             {
5687               notethat ("CaCTRL: IFLUSH [ pregs ++ ]\n");
5688               (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 3);
5689             }
5690           else
5691             return yyerror ("Bad register(s) for FLUSH");
5692         }
5693     break;
5694
5695   case 177:
5696 #line 2972 "bfin-parse.y"
5697     {
5698           if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5699             {
5700               notethat ("CaCTRL: PREFETCH [ pregs ]\n");
5701               (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 0);
5702             }
5703           else
5704             return yyerror ("Bad register(s) for PREFETCH");
5705         }
5706     break;
5707
5708   case 178:
5709 #line 2983 "bfin-parse.y"
5710     {
5711           if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5712             {
5713               notethat ("CaCTRL: PREFETCH [ pregs ++ ]\n");
5714               (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 0);
5715             }
5716           else
5717             return yyerror ("Bad register(s) for PREFETCH");
5718         }
5719     break;
5720
5721   case 179:
5722 #line 2997 "bfin-parse.y"
5723     {
5724           if (!IS_DREG ((yyvsp[(7) - (7)].reg)))
5725             return yyerror ("Dreg expected for source operand");
5726           if (!IS_PREG ((yyvsp[(3) - (7)].reg)))
5727             return yyerror ("Preg expected in address");
5728
5729           notethat ("LDST: B [ pregs <post_op> ] = dregs\n");
5730           (yyval.instr) = LDST (&(yyvsp[(3) - (7)].reg), &(yyvsp[(7) - (7)].reg), (yyvsp[(4) - (7)].modcodes).x0, 2, 0, 1);
5731         }
5732     break;
5733
5734   case 180:
5735 #line 3009 "bfin-parse.y"
5736     {
5737           Expr_Node *tmp = (yyvsp[(5) - (8)].expr);
5738
5739           if (!IS_DREG ((yyvsp[(8) - (8)].reg)))
5740             return yyerror ("Dreg expected for source operand");
5741           if (!IS_PREG ((yyvsp[(3) - (8)].reg)))
5742             return yyerror ("Preg expected in address");
5743
5744           if (IS_RELOC ((yyvsp[(5) - (8)].expr)))
5745             return yyerror ("Plain symbol used as offset");
5746
5747           if ((yyvsp[(4) - (8)].r0).r0)
5748             tmp = unary (Expr_Op_Type_NEG, tmp);
5749
5750           if (in_range_p (tmp, -32768, 32767, 0))
5751             {
5752               notethat ("LDST: B [ pregs + imm16 ] = dregs\n");
5753               (yyval.instr) = LDSTIDXI (&(yyvsp[(3) - (8)].reg), &(yyvsp[(8) - (8)].reg), 1, 2, 0, (yyvsp[(5) - (8)].expr));
5754             }
5755           else
5756             return yyerror ("Displacement out of range");
5757         }
5758     break;
5759
5760   case 181:
5761 #line 3035 "bfin-parse.y"
5762     {
5763           Expr_Node *tmp = (yyvsp[(5) - (8)].expr);
5764
5765           if (!IS_DREG ((yyvsp[(8) - (8)].reg)))
5766             return yyerror ("Dreg expected for source operand");
5767           if (!IS_PREG ((yyvsp[(3) - (8)].reg)))
5768             return yyerror ("Preg expected in address");
5769
5770           if ((yyvsp[(4) - (8)].r0).r0)
5771             tmp = unary (Expr_Op_Type_NEG, tmp);
5772
5773           if (IS_RELOC ((yyvsp[(5) - (8)].expr)))
5774             return yyerror ("Plain symbol used as offset");
5775
5776           if (in_range_p (tmp, 0, 30, 1))
5777             {
5778               notethat ("LDSTii: W [ pregs +- uimm5m2 ] = dregs\n");
5779               (yyval.instr) = LDSTII (&(yyvsp[(3) - (8)].reg), &(yyvsp[(8) - (8)].reg), tmp, 1, 1);
5780             }
5781           else if (in_range_p (tmp, -65536, 65535, 1))
5782             {
5783               notethat ("LDSTidxI: W [ pregs + imm17m2 ] = dregs\n");
5784               (yyval.instr) = LDSTIDXI (&(yyvsp[(3) - (8)].reg), &(yyvsp[(8) - (8)].reg), 1, 1, 0, tmp);
5785             }
5786           else
5787             return yyerror ("Displacement out of range");
5788         }
5789     break;
5790
5791   case 182:
5792 #line 3065 "bfin-parse.y"
5793     {
5794           if (!IS_DREG ((yyvsp[(7) - (7)].reg)))
5795             return yyerror ("Dreg expected for source operand");
5796           if (!IS_PREG ((yyvsp[(3) - (7)].reg)))
5797             return yyerror ("Preg expected in address");
5798
5799           notethat ("LDST: W [ pregs <post_op> ] = dregs\n");
5800           (yyval.instr) = LDST (&(yyvsp[(3) - (7)].reg), &(yyvsp[(7) - (7)].reg), (yyvsp[(4) - (7)].modcodes).x0, 1, 0, 1);
5801         }
5802     break;
5803
5804   case 183:
5805 #line 3076 "bfin-parse.y"
5806     {
5807           if (!IS_DREG ((yyvsp[(7) - (7)].reg)))
5808             return yyerror ("Dreg expected for source operand");
5809           if ((yyvsp[(4) - (7)].modcodes).x0 == 2)
5810             {
5811               if (!IS_IREG ((yyvsp[(3) - (7)].reg)) && !IS_PREG ((yyvsp[(3) - (7)].reg)))
5812                 return yyerror ("Ireg or Preg expected in address");
5813             }
5814           else if (!IS_IREG ((yyvsp[(3) - (7)].reg)))
5815             return yyerror ("Ireg expected in address");
5816
5817           if (IS_IREG ((yyvsp[(3) - (7)].reg)))
5818             {
5819               notethat ("dspLDST: W [ iregs <post_op> ] = dregs_half\n");
5820               (yyval.instr) = DSPLDST (&(yyvsp[(3) - (7)].reg), 1 + IS_H ((yyvsp[(7) - (7)].reg)), &(yyvsp[(7) - (7)].reg), (yyvsp[(4) - (7)].modcodes).x0, 1);
5821             }
5822           else
5823             {
5824               notethat ("LDSTpmod: W [ pregs ] = dregs_half\n");
5825               (yyval.instr) = LDSTPMOD (&(yyvsp[(3) - (7)].reg), &(yyvsp[(7) - (7)].reg), &(yyvsp[(3) - (7)].reg), 1 + IS_H ((yyvsp[(7) - (7)].reg)), 1);
5826             }
5827         }
5828     break;
5829
5830   case 184:
5831 #line 3101 "bfin-parse.y"
5832     {
5833           Expr_Node *tmp = (yyvsp[(4) - (7)].expr);
5834           int ispreg = IS_PREG ((yyvsp[(7) - (7)].reg));
5835
5836           if (!IS_PREG ((yyvsp[(2) - (7)].reg)))
5837             return yyerror ("Preg expected in address");
5838
5839           if (!IS_DREG ((yyvsp[(7) - (7)].reg)) && !ispreg)
5840             return yyerror ("Preg expected for source operand");
5841
5842           if ((yyvsp[(3) - (7)].r0).r0)
5843             tmp = unary (Expr_Op_Type_NEG, tmp);
5844
5845           if (IS_RELOC ((yyvsp[(4) - (7)].expr)))
5846             return yyerror ("Plain symbol used as offset");
5847
5848           if (in_range_p (tmp, 0, 63, 3))
5849             {
5850               notethat ("LDSTii: dpregs = [ pregs + uimm6m4 ]\n");
5851               (yyval.instr) = LDSTII (&(yyvsp[(2) - (7)].reg), &(yyvsp[(7) - (7)].reg), tmp, 1, ispreg ? 3 : 0);
5852             }
5853           else if ((yyvsp[(2) - (7)].reg).regno == REG_FP && in_range_p (tmp, -128, 0, 3))
5854             {
5855               notethat ("LDSTiiFP: dpregs = [ FP - uimm7m4 ]\n");
5856               tmp = unary (Expr_Op_Type_NEG, tmp);
5857               (yyval.instr) = LDSTIIFP (tmp, &(yyvsp[(7) - (7)].reg), 1);
5858             }
5859           else if (in_range_p (tmp, -131072, 131071, 3))
5860             {
5861               notethat ("LDSTidxI: [ pregs + imm18m4 ] = dpregs\n");
5862               (yyval.instr) = LDSTIDXI (&(yyvsp[(2) - (7)].reg), &(yyvsp[(7) - (7)].reg), 1, 0, ispreg ? 1 : 0, tmp);
5863             }
5864           else
5865             return yyerror ("Displacement out of range");
5866         }
5867     break;
5868
5869   case 185:
5870 #line 3138 "bfin-parse.y"
5871     {
5872           Expr_Node *tmp = (yyvsp[(7) - (9)].expr);
5873           if (!IS_DREG ((yyvsp[(1) - (9)].reg)))
5874             return yyerror ("Dreg expected for destination operand");
5875           if (!IS_PREG ((yyvsp[(5) - (9)].reg)))
5876             return yyerror ("Preg expected in address");
5877
5878           if ((yyvsp[(6) - (9)].r0).r0)
5879             tmp = unary (Expr_Op_Type_NEG, tmp);
5880
5881           if (IS_RELOC ((yyvsp[(7) - (9)].expr)))
5882             return yyerror ("Plain symbol used as offset");
5883
5884           if (in_range_p (tmp, 0, 30, 1))
5885             {
5886               notethat ("LDSTii: dregs = W [ pregs + uimm5m2 ] (.)\n");
5887               (yyval.instr) = LDSTII (&(yyvsp[(5) - (9)].reg), &(yyvsp[(1) - (9)].reg), tmp, 0, 1 << (yyvsp[(9) - (9)].r0).r0);
5888             }
5889           else if (in_range_p (tmp, -65536, 65535, 1))
5890             {
5891               notethat ("LDSTidxI: dregs = W [ pregs + imm17m2 ] (.)\n");
5892               (yyval.instr) = LDSTIDXI (&(yyvsp[(5) - (9)].reg), &(yyvsp[(1) - (9)].reg), 0, 1, (yyvsp[(9) - (9)].r0).r0, tmp);
5893             }
5894           else
5895             return yyerror ("Displacement out of range");
5896         }
5897     break;
5898
5899   case 186:
5900 #line 3166 "bfin-parse.y"
5901     {
5902           if (!IS_DREG ((yyvsp[(1) - (7)].reg)))
5903             return yyerror ("Dreg expected for source operand");
5904           if ((yyvsp[(6) - (7)].modcodes).x0 == 2)
5905             {
5906               if (!IS_IREG ((yyvsp[(5) - (7)].reg)) && !IS_PREG ((yyvsp[(5) - (7)].reg)))
5907                 return yyerror ("Ireg or Preg expected in address");
5908             }
5909           else if (!IS_IREG ((yyvsp[(5) - (7)].reg)))
5910             return yyerror ("Ireg expected in address");
5911
5912           if (IS_IREG ((yyvsp[(5) - (7)].reg)))
5913             {
5914               notethat ("dspLDST: dregs_half = W [ iregs <post_op> ]\n");
5915               (yyval.instr) = DSPLDST(&(yyvsp[(5) - (7)].reg), 1 + IS_H ((yyvsp[(1) - (7)].reg)), &(yyvsp[(1) - (7)].reg), (yyvsp[(6) - (7)].modcodes).x0, 0);
5916             }
5917           else
5918             {
5919               notethat ("LDSTpmod: dregs_half = W [ pregs <post_op> ]\n");
5920               (yyval.instr) = LDSTPMOD (&(yyvsp[(5) - (7)].reg), &(yyvsp[(1) - (7)].reg), &(yyvsp[(5) - (7)].reg), 1 + IS_H ((yyvsp[(1) - (7)].reg)), 0);
5921             }
5922         }
5923     break;
5924
5925   case 187:
5926 #line 3191 "bfin-parse.y"
5927     {
5928           if (!IS_DREG ((yyvsp[(1) - (8)].reg)))
5929             return yyerror ("Dreg expected for destination operand");
5930           if (!IS_PREG ((yyvsp[(5) - (8)].reg)))
5931             return yyerror ("Preg expected in address");
5932
5933           notethat ("LDST: dregs = W [ pregs <post_op> ] (.)\n");
5934           (yyval.instr) = LDST (&(yyvsp[(5) - (8)].reg), &(yyvsp[(1) - (8)].reg), (yyvsp[(6) - (8)].modcodes).x0, 1, (yyvsp[(8) - (8)].r0).r0, 0);
5935         }
5936     break;
5937
5938   case 188:
5939 #line 3202 "bfin-parse.y"
5940     {
5941           if (!IS_DREG ((yyvsp[(1) - (9)].reg)))
5942             return yyerror ("Dreg expected for destination operand");
5943           if (!IS_PREG ((yyvsp[(5) - (9)].reg)) || !IS_PREG ((yyvsp[(7) - (9)].reg)))
5944             return yyerror ("Preg expected in address");
5945
5946           notethat ("LDSTpmod: dregs = W [ pregs ++ pregs ] (.)\n");
5947           (yyval.instr) = LDSTPMOD (&(yyvsp[(5) - (9)].reg), &(yyvsp[(1) - (9)].reg), &(yyvsp[(7) - (9)].reg), 3, (yyvsp[(9) - (9)].r0).r0);
5948         }
5949     break;
5950
5951   case 189:
5952 #line 3213 "bfin-parse.y"
5953     {
5954           if (!IS_DREG ((yyvsp[(1) - (8)].reg)))
5955             return yyerror ("Dreg expected for destination operand");
5956           if (!IS_PREG ((yyvsp[(5) - (8)].reg)) || !IS_PREG ((yyvsp[(7) - (8)].reg)))
5957             return yyerror ("Preg expected in address");
5958
5959           notethat ("LDSTpmod: dregs_half = W [ pregs ++ pregs ]\n");
5960           (yyval.instr) = LDSTPMOD (&(yyvsp[(5) - (8)].reg), &(yyvsp[(1) - (8)].reg), &(yyvsp[(7) - (8)].reg), 1 + IS_H ((yyvsp[(1) - (8)].reg)), 0);
5961         }
5962     break;
5963
5964   case 190:
5965 #line 3224 "bfin-parse.y"
5966     {
5967           if (!IS_IREG ((yyvsp[(2) - (6)].reg)) && !IS_PREG ((yyvsp[(2) - (6)].reg)))
5968             return yyerror ("Ireg or Preg expected in address");
5969           else if (IS_IREG ((yyvsp[(2) - (6)].reg)) && !IS_DREG ((yyvsp[(6) - (6)].reg)))
5970             return yyerror ("Dreg expected for source operand");
5971           else if (IS_PREG ((yyvsp[(2) - (6)].reg)) && !IS_DREG ((yyvsp[(6) - (6)].reg)) && !IS_PREG ((yyvsp[(6) - (6)].reg)))
5972             return yyerror ("Dreg or Preg expected for source operand");
5973
5974           if (IS_IREG ((yyvsp[(2) - (6)].reg)))
5975             {
5976               notethat ("dspLDST: [ iregs <post_op> ] = dregs\n");
5977               (yyval.instr) = DSPLDST(&(yyvsp[(2) - (6)].reg), 0, &(yyvsp[(6) - (6)].reg), (yyvsp[(3) - (6)].modcodes).x0, 1);
5978             }
5979           else if (IS_DREG ((yyvsp[(6) - (6)].reg)))
5980             {
5981               notethat ("LDST: [ pregs <post_op> ] = dregs\n");
5982               (yyval.instr) = LDST (&(yyvsp[(2) - (6)].reg), &(yyvsp[(6) - (6)].reg), (yyvsp[(3) - (6)].modcodes).x0, 0, 0, 1);
5983             }
5984           else
5985             {
5986               notethat ("LDST: [ pregs <post_op> ] = pregs\n");
5987               (yyval.instr) = LDST (&(yyvsp[(2) - (6)].reg), &(yyvsp[(6) - (6)].reg), (yyvsp[(3) - (6)].modcodes).x0, 0, 1, 1);
5988             }
5989         }
5990     break;
5991
5992   case 191:
5993 #line 3250 "bfin-parse.y"
5994     {
5995           if (!IS_DREG ((yyvsp[(7) - (7)].reg)))
5996             return yyerror ("Dreg expected for source operand");
5997
5998           if (IS_IREG ((yyvsp[(2) - (7)].reg)) && IS_MREG ((yyvsp[(4) - (7)].reg)))
5999             {
6000               notethat ("dspLDST: [ iregs ++ mregs ] = dregs\n");
6001               (yyval.instr) = DSPLDST(&(yyvsp[(2) - (7)].reg), (yyvsp[(4) - (7)].reg).regno & CODE_MASK, &(yyvsp[(7) - (7)].reg), 3, 1);
6002             }
6003           else if (IS_PREG ((yyvsp[(2) - (7)].reg)) && IS_PREG ((yyvsp[(4) - (7)].reg)))
6004             {
6005               notethat ("LDSTpmod: [ pregs ++ pregs ] = dregs\n");
6006               (yyval.instr) = LDSTPMOD (&(yyvsp[(2) - (7)].reg), &(yyvsp[(7) - (7)].reg), &(yyvsp[(4) - (7)].reg), 0, 1);
6007             }
6008           else
6009             return yyerror ("Preg ++ Preg or Ireg ++ Mreg expected in address");
6010         }
6011     break;
6012
6013   case 192:
6014 #line 3269 "bfin-parse.y"
6015     {
6016           if (!IS_DREG ((yyvsp[(8) - (8)].reg)))
6017             return yyerror ("Dreg expected for source operand");
6018
6019           if (IS_PREG ((yyvsp[(3) - (8)].reg)) && IS_PREG ((yyvsp[(5) - (8)].reg)))
6020             {
6021               notethat ("LDSTpmod: W [ pregs ++ pregs ] = dregs_half\n");
6022               (yyval.instr) = LDSTPMOD (&(yyvsp[(3) - (8)].reg), &(yyvsp[(8) - (8)].reg), &(yyvsp[(5) - (8)].reg), 1 + IS_H ((yyvsp[(8) - (8)].reg)), 1);
6023             }
6024           else
6025             return yyerror ("Preg ++ Preg expected in address");
6026         }
6027     break;
6028
6029   case 193:
6030 #line 3283 "bfin-parse.y"
6031     {
6032           Expr_Node *tmp = (yyvsp[(7) - (9)].expr);
6033           if (!IS_DREG ((yyvsp[(1) - (9)].reg)))
6034             return yyerror ("Dreg expected for destination operand");
6035           if (!IS_PREG ((yyvsp[(5) - (9)].reg)))
6036             return yyerror ("Preg expected in address");
6037
6038           if ((yyvsp[(6) - (9)].r0).r0)
6039             tmp = unary (Expr_Op_Type_NEG, tmp);
6040
6041           if (IS_RELOC ((yyvsp[(7) - (9)].expr)))
6042             return yyerror ("Plain symbol used as offset");
6043
6044           if (in_range_p (tmp, -32768, 32767, 0))
6045             {
6046               notethat ("LDSTidxI: dregs = B [ pregs + imm16 ] (%c)\n",
6047                        (yyvsp[(9) - (9)].r0).r0 ? 'X' : 'Z');
6048               (yyval.instr) = LDSTIDXI (&(yyvsp[(5) - (9)].reg), &(yyvsp[(1) - (9)].reg), 0, 2, (yyvsp[(9) - (9)].r0).r0, tmp);
6049             }
6050           else
6051             return yyerror ("Displacement out of range");
6052         }
6053     break;
6054
6055   case 194:
6056 #line 3307 "bfin-parse.y"
6057     {
6058           if (!IS_DREG ((yyvsp[(1) - (8)].reg)))
6059             return yyerror ("Dreg expected for destination operand");
6060           if (!IS_PREG ((yyvsp[(5) - (8)].reg)))
6061             return yyerror ("Preg expected in address");
6062
6063           notethat ("LDST: dregs = B [ pregs <post_op> ] (%c)\n",
6064                     (yyvsp[(8) - (8)].r0).r0 ? 'X' : 'Z');
6065           (yyval.instr) = LDST (&(yyvsp[(5) - (8)].reg), &(yyvsp[(1) - (8)].reg), (yyvsp[(6) - (8)].modcodes).x0, 2, (yyvsp[(8) - (8)].r0).r0, 0);
6066         }
6067     break;
6068
6069   case 195:
6070 #line 3319 "bfin-parse.y"
6071     {
6072           if (!IS_DREG ((yyvsp[(1) - (7)].reg)))
6073             return yyerror ("Dreg expected for destination operand");
6074
6075           if (IS_IREG ((yyvsp[(4) - (7)].reg)) && IS_MREG ((yyvsp[(6) - (7)].reg)))
6076             {
6077               notethat ("dspLDST: dregs = [ iregs ++ mregs ]\n");
6078               (yyval.instr) = DSPLDST(&(yyvsp[(4) - (7)].reg), (yyvsp[(6) - (7)].reg).regno & CODE_MASK, &(yyvsp[(1) - (7)].reg), 3, 0);
6079             }
6080           else if (IS_PREG ((yyvsp[(4) - (7)].reg)) && IS_PREG ((yyvsp[(6) - (7)].reg)))
6081             {
6082               notethat ("LDSTpmod: dregs = [ pregs ++ pregs ]\n");
6083               (yyval.instr) = LDSTPMOD (&(yyvsp[(4) - (7)].reg), &(yyvsp[(1) - (7)].reg), &(yyvsp[(6) - (7)].reg), 0, 0);
6084             }
6085           else
6086             return yyerror ("Preg ++ Preg or Ireg ++ Mreg expected in address");
6087         }
6088     break;
6089
6090   case 196:
6091 #line 3338 "bfin-parse.y"
6092     {
6093           Expr_Node *tmp = (yyvsp[(6) - (7)].expr);
6094           int ispreg = IS_PREG ((yyvsp[(1) - (7)].reg));
6095           int isgot = IS_RELOC((yyvsp[(6) - (7)].expr));
6096
6097           if (!IS_PREG ((yyvsp[(4) - (7)].reg)))
6098             return yyerror ("Preg expected in address");
6099
6100           if (!IS_DREG ((yyvsp[(1) - (7)].reg)) && !ispreg)
6101             return yyerror ("Dreg or Preg expected for destination operand");
6102
6103           if (tmp->type == Expr_Node_Reloc
6104               && strcmp (tmp->value.s_value,
6105                          "_current_shared_library_p5_offset_") != 0)
6106             return yyerror ("Plain symbol used as offset");
6107
6108           if ((yyvsp[(5) - (7)].r0).r0)
6109             tmp = unary (Expr_Op_Type_NEG, tmp);
6110
6111           if (isgot)
6112             {
6113               notethat ("LDSTidxI: dpregs = [ pregs + sym@got ]\n");
6114               (yyval.instr) = LDSTIDXI (&(yyvsp[(4) - (7)].reg), &(yyvsp[(1) - (7)].reg), 0, 0, ispreg ? 1 : 0, tmp);
6115             }
6116           else if (in_range_p (tmp, 0, 63, 3))
6117             {
6118               notethat ("LDSTii: dpregs = [ pregs + uimm7m4 ]\n");
6119               (yyval.instr) = LDSTII (&(yyvsp[(4) - (7)].reg), &(yyvsp[(1) - (7)].reg), tmp, 0, ispreg ? 3 : 0);
6120             }
6121           else if ((yyvsp[(4) - (7)].reg).regno == REG_FP && in_range_p (tmp, -128, 0, 3))
6122             {
6123               notethat ("LDSTiiFP: dpregs = [ FP - uimm7m4 ]\n");
6124               tmp = unary (Expr_Op_Type_NEG, tmp);
6125               (yyval.instr) = LDSTIIFP (tmp, &(yyvsp[(1) - (7)].reg), 0);
6126             }
6127           else if (in_range_p (tmp, -131072, 131071, 3))
6128             {
6129               notethat ("LDSTidxI: dpregs = [ pregs + imm18m4 ]\n");
6130               (yyval.instr) = LDSTIDXI (&(yyvsp[(4) - (7)].reg), &(yyvsp[(1) - (7)].reg), 0, 0, ispreg ? 1 : 0, tmp);
6131
6132             }
6133           else
6134             return yyerror ("Displacement out of range");
6135         }
6136     break;
6137
6138   case 197:
6139 #line 3384 "bfin-parse.y"
6140     {
6141           if (!IS_IREG ((yyvsp[(4) - (6)].reg)) && !IS_PREG ((yyvsp[(4) - (6)].reg)))
6142             return yyerror ("Ireg or Preg expected in address");
6143           else if (IS_IREG ((yyvsp[(4) - (6)].reg)) && !IS_DREG ((yyvsp[(1) - (6)].reg)))
6144             return yyerror ("Dreg expected in destination operand");
6145           else if (IS_PREG ((yyvsp[(4) - (6)].reg)) && !IS_DREG ((yyvsp[(1) - (6)].reg)) && !IS_PREG ((yyvsp[(1) - (6)].reg))
6146                    && ((yyvsp[(4) - (6)].reg).regno != REG_SP || !IS_ALLREG ((yyvsp[(1) - (6)].reg)) || (yyvsp[(5) - (6)].modcodes).x0 != 0))
6147             return yyerror ("Dreg or Preg expected in destination operand");
6148
6149           if (IS_IREG ((yyvsp[(4) - (6)].reg)))
6150             {
6151               notethat ("dspLDST: dregs = [ iregs <post_op> ]\n");
6152               (yyval.instr) = DSPLDST (&(yyvsp[(4) - (6)].reg), 0, &(yyvsp[(1) - (6)].reg), (yyvsp[(5) - (6)].modcodes).x0, 0);
6153             }
6154           else if (IS_DREG ((yyvsp[(1) - (6)].reg)))
6155             {
6156               notethat ("LDST: dregs = [ pregs <post_op> ]\n");
6157               (yyval.instr) = LDST (&(yyvsp[(4) - (6)].reg), &(yyvsp[(1) - (6)].reg), (yyvsp[(5) - (6)].modcodes).x0, 0, 0, 0);
6158             }
6159           else if (IS_PREG ((yyvsp[(1) - (6)].reg)))
6160             {
6161               if (REG_SAME ((yyvsp[(1) - (6)].reg), (yyvsp[(4) - (6)].reg)) && (yyvsp[(5) - (6)].modcodes).x0 != 2)
6162                 return yyerror ("Pregs can't be same");
6163
6164               notethat ("LDST: pregs = [ pregs <post_op> ]\n");
6165               (yyval.instr) = LDST (&(yyvsp[(4) - (6)].reg), &(yyvsp[(1) - (6)].reg), (yyvsp[(5) - (6)].modcodes).x0, 0, 1, 0);
6166             }
6167           else
6168             {
6169               notethat ("PushPopReg: allregs = [ SP ++ ]\n");
6170               (yyval.instr) = PUSHPOPREG (&(yyvsp[(1) - (6)].reg), 0);
6171             }
6172         }
6173     break;
6174
6175   case 198:
6176 #line 3421 "bfin-parse.y"
6177     {
6178           if ((yyvsp[(1) - (11)].reg).regno != REG_SP)
6179             yyerror ("Stack Pointer expected");
6180           if ((yyvsp[(4) - (11)].reg).regno == REG_R7
6181               && IN_RANGE ((yyvsp[(6) - (11)].expr), 0, 7)
6182               && (yyvsp[(8) - (11)].reg).regno == REG_P5
6183               && IN_RANGE ((yyvsp[(10) - (11)].expr), 0, 5))
6184             {
6185               notethat ("PushPopMultiple: [ -- SP ] = (R7 : reglim , P5 : reglim )\n");
6186               (yyval.instr) = PUSHPOPMULTIPLE (imm5 ((yyvsp[(6) - (11)].expr)), imm5 ((yyvsp[(10) - (11)].expr)), 1, 1, 1);
6187             }
6188           else
6189             return yyerror ("Bad register for PushPopMultiple");
6190         }
6191     break;
6192
6193   case 199:
6194 #line 3437 "bfin-parse.y"
6195     {
6196           if ((yyvsp[(1) - (7)].reg).regno != REG_SP)
6197             yyerror ("Stack Pointer expected");
6198
6199           if ((yyvsp[(4) - (7)].reg).regno == REG_R7 && IN_RANGE ((yyvsp[(6) - (7)].expr), 0, 7))
6200             {
6201               notethat ("PushPopMultiple: [ -- SP ] = (R7 : reglim )\n");
6202               (yyval.instr) = PUSHPOPMULTIPLE (imm5 ((yyvsp[(6) - (7)].expr)), 0, 1, 0, 1);
6203             }
6204           else if ((yyvsp[(4) - (7)].reg).regno == REG_P5 && IN_RANGE ((yyvsp[(6) - (7)].expr), 0, 6))
6205             {
6206               notethat ("PushPopMultiple: [ -- SP ] = (P5 : reglim )\n");
6207               (yyval.instr) = PUSHPOPMULTIPLE (0, imm5 ((yyvsp[(6) - (7)].expr)), 0, 1, 1);
6208             }
6209           else
6210             return yyerror ("Bad register for PushPopMultiple");
6211         }
6212     break;
6213
6214   case 200:
6215 #line 3456 "bfin-parse.y"
6216     {
6217           if ((yyvsp[(11) - (11)].reg).regno != REG_SP)
6218             yyerror ("Stack Pointer expected");
6219           if ((yyvsp[(2) - (11)].reg).regno == REG_R7 && (IN_RANGE ((yyvsp[(4) - (11)].expr), 0, 7))
6220               && (yyvsp[(6) - (11)].reg).regno == REG_P5 && (IN_RANGE ((yyvsp[(8) - (11)].expr), 0, 6)))
6221             {
6222               notethat ("PushPopMultiple: (R7 : reglim , P5 : reglim ) = [ SP ++ ]\n");
6223               (yyval.instr) = PUSHPOPMULTIPLE (imm5 ((yyvsp[(4) - (11)].expr)), imm5 ((yyvsp[(8) - (11)].expr)), 1, 1, 0);
6224             }
6225           else
6226             return yyerror ("Bad register range for PushPopMultiple");
6227         }
6228     break;
6229
6230   case 201:
6231 #line 3470 "bfin-parse.y"
6232     {
6233           if ((yyvsp[(7) - (7)].reg).regno != REG_SP)
6234             yyerror ("Stack Pointer expected");
6235
6236           if ((yyvsp[(2) - (7)].reg).regno == REG_R7 && IN_RANGE ((yyvsp[(4) - (7)].expr), 0, 7))
6237             {
6238               notethat ("PushPopMultiple: (R7 : reglim ) = [ SP ++ ]\n");
6239               (yyval.instr) = PUSHPOPMULTIPLE (imm5 ((yyvsp[(4) - (7)].expr)), 0, 1, 0, 0);
6240             }
6241           else if ((yyvsp[(2) - (7)].reg).regno == REG_P5 && IN_RANGE ((yyvsp[(4) - (7)].expr), 0, 6))
6242             {
6243               notethat ("PushPopMultiple: (P5 : reglim ) = [ SP ++ ]\n");
6244               (yyval.instr) = PUSHPOPMULTIPLE (0, imm5 ((yyvsp[(4) - (7)].expr)), 0, 1, 0);
6245             }
6246           else
6247             return yyerror ("Bad register range for PushPopMultiple");
6248         }
6249     break;
6250
6251   case 202:
6252 #line 3489 "bfin-parse.y"
6253     {
6254           if ((yyvsp[(1) - (3)].reg).regno != REG_SP)
6255             yyerror ("Stack Pointer expected");
6256
6257           if (IS_ALLREG ((yyvsp[(3) - (3)].reg)))
6258             {
6259               notethat ("PushPopReg: [ -- SP ] = allregs\n");
6260               (yyval.instr) = PUSHPOPREG (&(yyvsp[(3) - (3)].reg), 1);
6261             }
6262           else
6263             return yyerror ("Bad register for PushPopReg");
6264         }
6265     break;
6266
6267   case 203:
6268 #line 3505 "bfin-parse.y"
6269     {
6270           if (IS_URANGE (16, (yyvsp[(2) - (2)].expr), 0, 4))
6271             (yyval.instr) = LINKAGE (0, uimm16s4 ((yyvsp[(2) - (2)].expr)));
6272           else
6273             return yyerror ("Bad constant for LINK");
6274         }
6275     break;
6276
6277   case 204:
6278 #line 3513 "bfin-parse.y"
6279     {
6280                 notethat ("linkage: UNLINK\n");
6281                 (yyval.instr) = LINKAGE (1, 0);
6282         }
6283     break;
6284
6285   case 205:
6286 #line 3522 "bfin-parse.y"
6287     {
6288           if (IS_PCREL4 ((yyvsp[(3) - (7)].expr)) && IS_LPPCREL10 ((yyvsp[(5) - (7)].expr)) && IS_CREG ((yyvsp[(7) - (7)].reg)))
6289             {
6290               notethat ("LoopSetup: LSETUP (pcrel4 , lppcrel10 ) counters\n");
6291               (yyval.instr) = LOOPSETUP ((yyvsp[(3) - (7)].expr), &(yyvsp[(7) - (7)].reg), 0, (yyvsp[(5) - (7)].expr), 0);
6292             }
6293           else
6294             return yyerror ("Bad register or values for LSETUP");
6295
6296         }
6297     break;
6298
6299   case 206:
6300 #line 3533 "bfin-parse.y"
6301     {
6302           if (IS_PCREL4 ((yyvsp[(3) - (9)].expr)) && IS_LPPCREL10 ((yyvsp[(5) - (9)].expr))
6303               && IS_PREG ((yyvsp[(9) - (9)].reg)) && IS_CREG ((yyvsp[(7) - (9)].reg)))
6304             {
6305               notethat ("LoopSetup: LSETUP (pcrel4 , lppcrel10 ) counters = pregs\n");
6306               (yyval.instr) = LOOPSETUP ((yyvsp[(3) - (9)].expr), &(yyvsp[(7) - (9)].reg), 1, (yyvsp[(5) - (9)].expr), &(yyvsp[(9) - (9)].reg));
6307             }
6308           else
6309             return yyerror ("Bad register or values for LSETUP");
6310         }
6311     break;
6312
6313   case 207:
6314 #line 3545 "bfin-parse.y"
6315     {
6316           if (IS_PCREL4 ((yyvsp[(3) - (11)].expr)) && IS_LPPCREL10 ((yyvsp[(5) - (11)].expr))
6317               && IS_PREG ((yyvsp[(9) - (11)].reg)) && IS_CREG ((yyvsp[(7) - (11)].reg))
6318               && EXPR_VALUE ((yyvsp[(11) - (11)].expr)) == 1)
6319             {
6320               notethat ("LoopSetup: LSETUP (pcrel4 , lppcrel10 ) counters = pregs >> 1\n");
6321               (yyval.instr) = LOOPSETUP ((yyvsp[(3) - (11)].expr), &(yyvsp[(7) - (11)].reg), 3, (yyvsp[(5) - (11)].expr), &(yyvsp[(9) - (11)].reg));
6322             }
6323           else
6324             return yyerror ("Bad register or values for LSETUP");
6325         }
6326     break;
6327
6328   case 208:
6329 #line 3559 "bfin-parse.y"
6330     {
6331           if (!IS_RELOC ((yyvsp[(2) - (3)].expr)))
6332             return yyerror ("Invalid expression in loop statement");
6333           if (!IS_CREG ((yyvsp[(3) - (3)].reg)))
6334             return yyerror ("Invalid loop counter register");
6335         (yyval.instr) = bfin_gen_loop ((yyvsp[(2) - (3)].expr), &(yyvsp[(3) - (3)].reg), 0, 0);
6336         }
6337     break;
6338
6339   case 209:
6340 #line 3567 "bfin-parse.y"
6341     {
6342           if (IS_RELOC ((yyvsp[(2) - (5)].expr)) && IS_PREG ((yyvsp[(5) - (5)].reg)) && IS_CREG ((yyvsp[(3) - (5)].reg)))
6343             {
6344               notethat ("Loop: LOOP expr counters = pregs\n");
6345               (yyval.instr) = bfin_gen_loop ((yyvsp[(2) - (5)].expr), &(yyvsp[(3) - (5)].reg), 1, &(yyvsp[(5) - (5)].reg));
6346             }
6347           else
6348             return yyerror ("Bad register or values for LOOP");
6349         }
6350     break;
6351
6352   case 210:
6353 #line 3577 "bfin-parse.y"
6354     {
6355           if (IS_RELOC ((yyvsp[(2) - (7)].expr)) && IS_PREG ((yyvsp[(5) - (7)].reg)) && IS_CREG ((yyvsp[(3) - (7)].reg)) && EXPR_VALUE ((yyvsp[(7) - (7)].expr)) == 1)
6356             {
6357               notethat ("Loop: LOOP expr counters = pregs >> 1\n");
6358               (yyval.instr) = bfin_gen_loop ((yyvsp[(2) - (7)].expr), &(yyvsp[(3) - (7)].reg), 3, &(yyvsp[(5) - (7)].reg));
6359             }
6360           else
6361             return yyerror ("Bad register or values for LOOP");
6362         }
6363     break;
6364
6365   case 211:
6366 #line 3589 "bfin-parse.y"
6367     {
6368           Expr_Node_Value val;
6369           val.i_value = (yyvsp[(2) - (2)].value);
6370           Expr_Node *tmp = Expr_Node_Create (Expr_Node_Constant, val, NULL, NULL);
6371           bfin_loop_attempt_create_label (tmp, 1);
6372           if (!IS_RELOC (tmp))
6373             return yyerror ("Invalid expression in LOOP_BEGIN statement");
6374           bfin_loop_beginend (tmp, 1);
6375           (yyval.instr) = 0;
6376         }
6377     break;
6378
6379   case 212:
6380 #line 3600 "bfin-parse.y"
6381     {
6382           if (!IS_RELOC ((yyvsp[(2) - (2)].expr)))
6383             return yyerror ("Invalid expression in LOOP_BEGIN statement");
6384
6385           bfin_loop_beginend ((yyvsp[(2) - (2)].expr), 1);
6386           (yyval.instr) = 0;
6387         }
6388     break;
6389
6390   case 213:
6391 #line 3610 "bfin-parse.y"
6392     {
6393           Expr_Node_Value val;
6394           val.i_value = (yyvsp[(2) - (2)].value);
6395           Expr_Node *tmp = Expr_Node_Create (Expr_Node_Constant, val, NULL, NULL);
6396           bfin_loop_attempt_create_label (tmp, 1);
6397           if (!IS_RELOC (tmp))
6398             return yyerror ("Invalid expression in LOOP_END statement");
6399           bfin_loop_beginend (tmp, 0);
6400           (yyval.instr) = 0;
6401         }
6402     break;
6403
6404   case 214:
6405 #line 3621 "bfin-parse.y"
6406     {
6407           if (!IS_RELOC ((yyvsp[(2) - (2)].expr)))
6408             return yyerror ("Invalid expression in LOOP_END statement");
6409
6410           bfin_loop_beginend ((yyvsp[(2) - (2)].expr), 0);
6411           (yyval.instr) = 0;
6412         }
6413     break;
6414
6415   case 215:
6416 #line 3632 "bfin-parse.y"
6417     {
6418           notethat ("psedoDEBUG: ABORT\n");
6419           (yyval.instr) = bfin_gen_pseudodbg (3, 3, 0);
6420         }
6421     break;
6422
6423   case 216:
6424 #line 3638 "bfin-parse.y"
6425     {
6426           notethat ("pseudoDEBUG: DBG\n");
6427           (yyval.instr) = bfin_gen_pseudodbg (3, 7, 0);
6428         }
6429     break;
6430
6431   case 217:
6432 #line 3643 "bfin-parse.y"
6433     {
6434           notethat ("pseudoDEBUG: DBG REG_A\n");
6435           (yyval.instr) = bfin_gen_pseudodbg (3, IS_A1 ((yyvsp[(2) - (2)].reg)), 0);
6436         }
6437     break;
6438
6439   case 218:
6440 #line 3648 "bfin-parse.y"
6441     {
6442           notethat ("pseudoDEBUG: DBG allregs\n");
6443           (yyval.instr) = bfin_gen_pseudodbg (0, (yyvsp[(2) - (2)].reg).regno & CODE_MASK, ((yyvsp[(2) - (2)].reg).regno & CLASS_MASK) >> 4);
6444         }
6445     break;
6446
6447   case 219:
6448 #line 3654 "bfin-parse.y"
6449     {
6450           if (!IS_DREG ((yyvsp[(3) - (4)].reg)))
6451             return yyerror ("Dregs expected");
6452           notethat ("pseudoDEBUG: DBGCMPLX (dregs )\n");
6453           (yyval.instr) = bfin_gen_pseudodbg (3, 6, ((yyvsp[(3) - (4)].reg).regno & CODE_MASK) >> 4);
6454         }
6455     break;
6456
6457   case 220:
6458 #line 3662 "bfin-parse.y"
6459     {
6460           notethat ("psedoDEBUG: DBGHALT\n");
6461           (yyval.instr) = bfin_gen_pseudodbg (3, 5, 0);
6462         }
6463     break;
6464
6465   case 221:
6466 #line 3668 "bfin-parse.y"
6467     {
6468           notethat ("psedoDEBUG: HLT\n");
6469           (yyval.instr) = bfin_gen_pseudodbg (3, 4, 0);
6470         }
6471     break;
6472
6473   case 222:
6474 #line 3674 "bfin-parse.y"
6475     {
6476           notethat ("pseudodbg_assert: DBGA (regs_lo/hi , uimm16 )\n");
6477           (yyval.instr) = bfin_gen_pseudodbg_assert (IS_H ((yyvsp[(3) - (6)].reg)), &(yyvsp[(3) - (6)].reg), uimm16 ((yyvsp[(5) - (6)].expr)));
6478         }
6479     break;
6480
6481   case 223:
6482 #line 3680 "bfin-parse.y"
6483     {
6484           notethat ("pseudodbg_assert: DBGAH (regs , uimm16 )\n");
6485           (yyval.instr) = bfin_gen_pseudodbg_assert (3, &(yyvsp[(3) - (6)].reg), uimm16 ((yyvsp[(5) - (6)].expr)));
6486         }
6487     break;
6488
6489   case 224:
6490 #line 3686 "bfin-parse.y"
6491     {
6492           notethat ("psedodbg_assert: DBGAL (regs , uimm16 )\n");
6493           (yyval.instr) = bfin_gen_pseudodbg_assert (2, &(yyvsp[(3) - (6)].reg), uimm16 ((yyvsp[(5) - (6)].expr)));
6494         }
6495     break;
6496
6497   case 225:
6498 #line 3692 "bfin-parse.y"
6499     {
6500           if (!IS_UIMM ((yyvsp[(2) - (2)].expr), 8))
6501             return yyerror ("Constant out of range");
6502           notethat ("psedodbg_assert: OUTC uimm8\n");
6503           (yyval.instr) = bfin_gen_pseudochr (uimm8 ((yyvsp[(2) - (2)].expr)));
6504         }
6505     break;
6506
6507   case 226:
6508 #line 3700 "bfin-parse.y"
6509     {
6510           if (!IS_DREG ((yyvsp[(2) - (2)].reg)))
6511             return yyerror ("Dregs expected");
6512           notethat ("psedodbg_assert: OUTC dreg\n");
6513           (yyval.instr) = bfin_gen_pseudodbg (2, (yyvsp[(2) - (2)].reg).regno & CODE_MASK, 0);
6514         }
6515     break;
6516
6517   case 227:
6518 #line 3714 "bfin-parse.y"
6519     {
6520         (yyval.reg) = (yyvsp[(1) - (1)].reg);
6521         }
6522     break;
6523
6524   case 228:
6525 #line 3718 "bfin-parse.y"
6526     {
6527         (yyval.reg) = (yyvsp[(1) - (1)].reg);
6528         }
6529     break;
6530
6531   case 229:
6532 #line 3727 "bfin-parse.y"
6533     {
6534         (yyval.mod).MM = 0;
6535         (yyval.mod).mod = 0;
6536         }
6537     break;
6538
6539   case 230:
6540 #line 3732 "bfin-parse.y"
6541     {
6542         (yyval.mod).MM = 1;
6543         (yyval.mod).mod = (yyvsp[(4) - (5)].value);
6544         }
6545     break;
6546
6547   case 231:
6548 #line 3737 "bfin-parse.y"
6549     {
6550         (yyval.mod).MM = 1;
6551         (yyval.mod).mod = (yyvsp[(2) - (5)].value);
6552         }
6553     break;
6554
6555   case 232:
6556 #line 3742 "bfin-parse.y"
6557     {
6558         (yyval.mod).MM = 0;
6559         (yyval.mod).mod = (yyvsp[(2) - (3)].value);
6560         }
6561     break;
6562
6563   case 233:
6564 #line 3747 "bfin-parse.y"
6565     {
6566         (yyval.mod).MM = 1;
6567         (yyval.mod).mod = 0;
6568         }
6569     break;
6570
6571   case 234:
6572 #line 3754 "bfin-parse.y"
6573     {
6574         (yyval.r0).r0 = 1;
6575         }
6576     break;
6577
6578   case 235:
6579 #line 3758 "bfin-parse.y"
6580     {
6581         (yyval.r0).r0 = 0;
6582         }
6583     break;
6584
6585   case 236:
6586 #line 3764 "bfin-parse.y"
6587     {
6588         (yyval.modcodes).s0 = 0;
6589         (yyval.modcodes).x0 = 0;
6590         }
6591     break;
6592
6593   case 237:
6594 #line 3769 "bfin-parse.y"
6595     {
6596         (yyval.modcodes).s0 = 1;
6597         (yyval.modcodes).x0 = 0;
6598         }
6599     break;
6600
6601   case 238:
6602 #line 3774 "bfin-parse.y"
6603     {
6604         (yyval.modcodes).s0 = 0;
6605         (yyval.modcodes).x0 = 1;
6606         }
6607     break;
6608
6609   case 239:
6610 #line 3779 "bfin-parse.y"
6611     {
6612         (yyval.modcodes).s0 = 1;
6613         (yyval.modcodes).x0 = 1;
6614         }
6615     break;
6616
6617   case 240:
6618 #line 3787 "bfin-parse.y"
6619     {
6620         (yyval.r0).r0 = 1;
6621         }
6622     break;
6623
6624   case 241:
6625 #line 3791 "bfin-parse.y"
6626     {
6627         (yyval.r0).r0 = 0;
6628         }
6629     break;
6630
6631   case 242:
6632 #line 3797 "bfin-parse.y"
6633     {
6634         (yyval.modcodes).s0 = 0;
6635         (yyval.modcodes).x0 = 0;
6636         }
6637     break;
6638
6639   case 243:
6640 #line 3802 "bfin-parse.y"
6641     {
6642         (yyval.modcodes).s0 = (yyvsp[(2) - (3)].modcodes).s0;
6643         (yyval.modcodes).x0 = (yyvsp[(2) - (3)].modcodes).x0;
6644         }
6645     break;
6646
6647   case 244:
6648 #line 3809 "bfin-parse.y"
6649     {
6650         (yyval.modcodes).s0 = 0;
6651         (yyval.modcodes).x0 = 0;
6652         (yyval.modcodes).aop = 0;
6653         }
6654     break;
6655
6656   case 245:
6657 #line 3815 "bfin-parse.y"
6658     {
6659         (yyval.modcodes).s0 = 0;
6660         (yyval.modcodes).x0 = 0;
6661         (yyval.modcodes).aop = 1;
6662         }
6663     break;
6664
6665   case 246:
6666 #line 3821 "bfin-parse.y"
6667     {
6668         (yyval.modcodes).s0 = 1;
6669         (yyval.modcodes).x0 = 0;
6670         (yyval.modcodes).aop = 1;
6671         }
6672     break;
6673
6674   case 247:
6675 #line 3829 "bfin-parse.y"
6676     {
6677         (yyval.modcodes).r0 = 0;
6678         (yyval.modcodes).s0 = 0;
6679         (yyval.modcodes).x0 = 0;
6680         }
6681     break;
6682
6683   case 248:
6684 #line 3835 "bfin-parse.y"
6685     {
6686         (yyval.modcodes).r0 = 2 + (yyvsp[(2) - (3)].r0).r0;
6687         (yyval.modcodes).s0 = 0;
6688         (yyval.modcodes).x0 = 0;
6689         }
6690     break;
6691
6692   case 249:
6693 #line 3841 "bfin-parse.y"
6694     {
6695         (yyval.modcodes).r0 = 0;
6696         (yyval.modcodes).s0 = (yyvsp[(2) - (3)].modcodes).s0;
6697         (yyval.modcodes).x0 = (yyvsp[(2) - (3)].modcodes).x0;
6698         }
6699     break;
6700
6701   case 250:
6702 #line 3847 "bfin-parse.y"
6703     {
6704         (yyval.modcodes).r0 = 2 + (yyvsp[(2) - (5)].r0).r0;
6705         (yyval.modcodes).s0 = (yyvsp[(4) - (5)].modcodes).s0;
6706         (yyval.modcodes).x0 = (yyvsp[(4) - (5)].modcodes).x0;
6707         }
6708     break;
6709
6710   case 251:
6711 #line 3853 "bfin-parse.y"
6712     {
6713         (yyval.modcodes).r0 = 2 + (yyvsp[(4) - (5)].r0).r0;
6714         (yyval.modcodes).s0 = (yyvsp[(2) - (5)].modcodes).s0;
6715         (yyval.modcodes).x0 = (yyvsp[(2) - (5)].modcodes).x0;
6716         }
6717     break;
6718
6719   case 252:
6720 #line 3861 "bfin-parse.y"
6721     {
6722         (yyval.r0).r0 = 0;
6723         }
6724     break;
6725
6726   case 253:
6727 #line 3865 "bfin-parse.y"
6728     {
6729         (yyval.r0).r0 = 0;
6730         }
6731     break;
6732
6733   case 254:
6734 #line 3869 "bfin-parse.y"
6735     {
6736         (yyval.r0).r0 = 1;
6737         }
6738     break;
6739
6740   case 255:
6741 #line 3875 "bfin-parse.y"
6742     {
6743         (yyval.r0).r0 = 0;
6744         }
6745     break;
6746
6747   case 256:
6748 #line 3879 "bfin-parse.y"
6749     {
6750         (yyval.r0).r0 = 0;
6751         }
6752     break;
6753
6754   case 257:
6755 #line 3883 "bfin-parse.y"
6756     {
6757         (yyval.r0).r0 = 1;
6758         }
6759     break;
6760
6761   case 258:
6762 #line 3889 "bfin-parse.y"
6763     {
6764         (yyval.modcodes).r0 = 0;
6765         (yyval.modcodes).s0 = 0;
6766         (yyval.modcodes).aop = 0;
6767         }
6768     break;
6769
6770   case 259:
6771 #line 3895 "bfin-parse.y"
6772     {
6773         (yyval.modcodes).r0 = 0;
6774         (yyval.modcodes).s0 = 0;
6775         (yyval.modcodes).aop = 3;
6776         }
6777     break;
6778
6779   case 260:
6780 #line 3901 "bfin-parse.y"
6781     {
6782         (yyval.modcodes).r0 = 0;
6783         (yyval.modcodes).s0 = 1;
6784         (yyval.modcodes).aop = 3;
6785         }
6786     break;
6787
6788   case 261:
6789 #line 3907 "bfin-parse.y"
6790     {
6791         (yyval.modcodes).r0 = 1;
6792         (yyval.modcodes).s0 = 0;
6793         (yyval.modcodes).aop = 3;
6794         }
6795     break;
6796
6797   case 262:
6798 #line 3913 "bfin-parse.y"
6799     {
6800         (yyval.modcodes).r0 = 1;
6801         (yyval.modcodes).s0 = 1;
6802         }
6803     break;
6804
6805   case 263:
6806 #line 3918 "bfin-parse.y"
6807     {
6808         (yyval.modcodes).r0 = 1;
6809         (yyval.modcodes).s0 = 1;
6810         }
6811     break;
6812
6813   case 264:
6814 #line 3925 "bfin-parse.y"
6815     {
6816         (yyval.r0).r0 = 0;
6817         }
6818     break;
6819
6820   case 265:
6821 #line 3929 "bfin-parse.y"
6822     {
6823         (yyval.r0).r0 = 1;
6824         }
6825     break;
6826
6827   case 266:
6828 #line 3935 "bfin-parse.y"
6829     {
6830         (yyval.modcodes).s0 = 0;
6831         }
6832     break;
6833
6834   case 267:
6835 #line 3939 "bfin-parse.y"
6836     {
6837         (yyval.modcodes).s0 = 1;
6838         }
6839     break;
6840
6841   case 268:
6842 #line 3946 "bfin-parse.y"
6843     {
6844         (yyval.r0).r0 = 1;
6845         }
6846     break;
6847
6848   case 269:
6849 #line 3950 "bfin-parse.y"
6850     {
6851         (yyval.r0).r0 = 0;
6852         }
6853     break;
6854
6855   case 270:
6856 #line 3954 "bfin-parse.y"
6857     {
6858         (yyval.r0).r0 = 3;
6859         }
6860     break;
6861
6862   case 271:
6863 #line 3958 "bfin-parse.y"
6864     {
6865         (yyval.r0).r0 = 2;
6866         }
6867     break;
6868
6869   case 272:
6870 #line 3964 "bfin-parse.y"
6871     {
6872         (yyval.r0).r0 = 0;
6873         }
6874     break;
6875
6876   case 273:
6877 #line 3968 "bfin-parse.y"
6878     {
6879         (yyval.r0).r0 = 1;
6880         }
6881     break;
6882
6883   case 274:
6884 #line 3975 "bfin-parse.y"
6885     {
6886         (yyval.modcodes).r0 = 0;
6887         (yyval.modcodes).s0 = 1;
6888         }
6889     break;
6890
6891   case 275:
6892 #line 3980 "bfin-parse.y"
6893     {
6894         if ((yyvsp[(2) - (3)].value) != M_T)
6895           return yyerror ("Bad modifier");
6896         (yyval.modcodes).r0 = 1;
6897         (yyval.modcodes).s0 = 0;
6898         }
6899     break;
6900
6901   case 276:
6902 #line 3987 "bfin-parse.y"
6903     {
6904         if ((yyvsp[(2) - (5)].value) != M_T)
6905           return yyerror ("Bad modifier");
6906         (yyval.modcodes).r0 = 1;
6907         (yyval.modcodes).s0 = 1;
6908         }
6909     break;
6910
6911   case 277:
6912 #line 3994 "bfin-parse.y"
6913     {
6914         if ((yyvsp[(4) - (5)].value) != M_T)
6915           return yyerror ("Bad modifier");
6916         (yyval.modcodes).r0 = 1;
6917         (yyval.modcodes).s0 = 1;
6918         }
6919     break;
6920
6921   case 278:
6922 #line 4006 "bfin-parse.y"
6923     {
6924         (yyval.r0).r0 = 0;
6925         }
6926     break;
6927
6928   case 279:
6929 #line 4010 "bfin-parse.y"
6930     {
6931         (yyval.r0).r0 = 1;
6932         }
6933     break;
6934
6935   case 280:
6936 #line 4014 "bfin-parse.y"
6937     {
6938         (yyval.r0).r0 = 2;
6939         }
6940     break;
6941
6942   case 281:
6943 #line 4020 "bfin-parse.y"
6944     {
6945         (yyval.r0).r0 = 0;
6946         }
6947     break;
6948
6949   case 282:
6950 #line 4024 "bfin-parse.y"
6951     {
6952           if ((yyvsp[(2) - (3)].value) == M_W32)
6953             (yyval.r0).r0 = 1;
6954           else
6955             return yyerror ("Only (W32) allowed");
6956         }
6957     break;
6958
6959   case 283:
6960 #line 4033 "bfin-parse.y"
6961     {
6962         (yyval.r0).r0 = 1;
6963         }
6964     break;
6965
6966   case 284:
6967 #line 4037 "bfin-parse.y"
6968     {
6969           if ((yyvsp[(2) - (3)].value) == M_IU)
6970             (yyval.r0).r0 = 3;
6971           else
6972             return yyerror ("(IU) expected");
6973         }
6974     break;
6975
6976   case 285:
6977 #line 4046 "bfin-parse.y"
6978     {
6979         (yyval.reg) = (yyvsp[(3) - (4)].reg);
6980         }
6981     break;
6982
6983   case 286:
6984 #line 4052 "bfin-parse.y"
6985     {
6986         (yyval.reg) = (yyvsp[(2) - (4)].reg);
6987         }
6988     break;
6989
6990   case 287:
6991 #line 4061 "bfin-parse.y"
6992     {
6993         (yyval.r0).r0 = 1;
6994         }
6995     break;
6996
6997   case 288:
6998 #line 4065 "bfin-parse.y"
6999     {
7000         (yyval.r0).r0 = 0;
7001         }
7002     break;
7003
7004   case 289:
7005 #line 4072 "bfin-parse.y"
7006     {
7007         (yyval.r0).r0 = 0;
7008         }
7009     break;
7010
7011   case 290:
7012 #line 4076 "bfin-parse.y"
7013     {
7014         (yyval.r0).r0 = 1;
7015         }
7016     break;
7017
7018   case 291:
7019 #line 4080 "bfin-parse.y"
7020     {
7021         (yyval.r0).r0 = 2;
7022         }
7023     break;
7024
7025   case 292:
7026 #line 4084 "bfin-parse.y"
7027     {
7028         (yyval.r0).r0 = 3;
7029         }
7030     break;
7031
7032   case 293:
7033 #line 4091 "bfin-parse.y"
7034     {
7035         (yyval.r0).r0 = 0;
7036         }
7037     break;
7038
7039   case 294:
7040 #line 4095 "bfin-parse.y"
7041     {
7042         (yyval.r0).r0 = 1;
7043         }
7044     break;
7045
7046   case 295:
7047 #line 4102 "bfin-parse.y"
7048     {
7049           (yyval.modcodes).r0 = 1;      /* HL.  */
7050           (yyval.modcodes).s0 = 0;      /* s.  */
7051           (yyval.modcodes).x0 = 0;      /* x.  */
7052           (yyval.modcodes).aop = 0;     /* aop.  */
7053         }
7054     break;
7055
7056   case 296:
7057 #line 4110 "bfin-parse.y"
7058     {
7059           (yyval.modcodes).r0 = 1;      /* HL.  */
7060           (yyval.modcodes).s0 = 0;      /* s.  */
7061           (yyval.modcodes).x0 = 0;      /* x.  */
7062           (yyval.modcodes).aop = 1;     /* aop.  */
7063         }
7064     break;
7065
7066   case 297:
7067 #line 4118 "bfin-parse.y"
7068     {
7069           (yyval.modcodes).r0 = 0;      /* HL.  */
7070           (yyval.modcodes).s0 = 0;      /* s.  */
7071           (yyval.modcodes).x0 = 0;      /* x.  */
7072           (yyval.modcodes).aop = 0;     /* aop.  */
7073         }
7074     break;
7075
7076   case 298:
7077 #line 4126 "bfin-parse.y"
7078     {
7079           (yyval.modcodes).r0 = 0;      /* HL.  */
7080           (yyval.modcodes).s0 = 0;      /* s.  */
7081           (yyval.modcodes).x0 = 0;      /* x.  */
7082           (yyval.modcodes).aop = 1;
7083         }
7084     break;
7085
7086   case 299:
7087 #line 4134 "bfin-parse.y"
7088     {
7089           (yyval.modcodes).r0 = 1;      /* HL.  */
7090           (yyval.modcodes).s0 = 1;      /* s.  */
7091           (yyval.modcodes).x0 = 0;      /* x.  */
7092           (yyval.modcodes).aop = 0;     /* aop.  */
7093         }
7094     break;
7095
7096   case 300:
7097 #line 4141 "bfin-parse.y"
7098     {
7099           (yyval.modcodes).r0 = 1;      /* HL.  */
7100           (yyval.modcodes).s0 = 1;      /* s.  */
7101           (yyval.modcodes).x0 = 0;      /* x.  */
7102           (yyval.modcodes).aop = 1;     /* aop.  */
7103         }
7104     break;
7105
7106   case 301:
7107 #line 4148 "bfin-parse.y"
7108     {
7109           (yyval.modcodes).r0 = 0;      /* HL.  */
7110           (yyval.modcodes).s0 = 1;      /* s.  */
7111           (yyval.modcodes).x0 = 0;      /* x.  */
7112           (yyval.modcodes).aop = 0;     /* aop.  */
7113         }
7114     break;
7115
7116   case 302:
7117 #line 4156 "bfin-parse.y"
7118     {
7119           (yyval.modcodes).r0 = 0;      /* HL.  */
7120           (yyval.modcodes).s0 = 1;      /* s.  */
7121           (yyval.modcodes).x0 = 0;      /* x.  */
7122           (yyval.modcodes).aop = 1;     /* aop.  */
7123         }
7124     break;
7125
7126   case 303:
7127 #line 4166 "bfin-parse.y"
7128     {
7129           (yyval.modcodes).s0 = 0;      /* s.  */
7130           (yyval.modcodes).x0 = 0;      /* HL.  */
7131         }
7132     break;
7133
7134   case 304:
7135 #line 4171 "bfin-parse.y"
7136     {
7137           (yyval.modcodes).s0 = 0;      /* s.  */
7138           (yyval.modcodes).x0 = 1;      /* HL.  */
7139         }
7140     break;
7141
7142   case 305:
7143 #line 4176 "bfin-parse.y"
7144     {
7145           (yyval.modcodes).s0 = 1;      /* s.  */
7146           (yyval.modcodes).x0 = 0;      /* HL.  */
7147         }
7148     break;
7149
7150   case 306:
7151 #line 4181 "bfin-parse.y"
7152     {
7153           (yyval.modcodes).s0 = 1;      /* s.  */
7154           (yyval.modcodes).x0 = 1;      /* HL.  */
7155         }
7156     break;
7157
7158   case 307:
7159 #line 4188 "bfin-parse.y"
7160     {
7161         (yyval.modcodes).x0 = 2;
7162         }
7163     break;
7164
7165   case 308:
7166 #line 4192 "bfin-parse.y"
7167     {
7168         (yyval.modcodes).x0 = 0;
7169         }
7170     break;
7171
7172   case 309:
7173 #line 4196 "bfin-parse.y"
7174     {
7175         (yyval.modcodes).x0 = 1;
7176         }
7177     break;
7178
7179   case 310:
7180 #line 4205 "bfin-parse.y"
7181     {
7182         (yyval.reg) = (yyvsp[(1) - (2)].reg);
7183         }
7184     break;
7185
7186   case 311:
7187 #line 4212 "bfin-parse.y"
7188     {
7189         (yyval.reg) = (yyvsp[(1) - (2)].reg);
7190         }
7191     break;
7192
7193   case 312:
7194 #line 4219 "bfin-parse.y"
7195     {
7196         (yyval.reg) = (yyvsp[(1) - (2)].reg);
7197         }
7198     break;
7199
7200   case 313:
7201 #line 4226 "bfin-parse.y"
7202     {
7203           if (IS_A1 ((yyvsp[(3) - (3)].reg)) && IS_EVEN ((yyvsp[(1) - (3)].reg)))
7204             return yyerror ("Cannot move A1 to even register");
7205           else if (!IS_A1 ((yyvsp[(3) - (3)].reg)) && !IS_EVEN ((yyvsp[(1) - (3)].reg)))
7206             return yyerror ("Cannot move A0 to odd register");
7207
7208           (yyval.macfunc).w = 1;
7209           (yyval.macfunc).P = 1;
7210           (yyval.macfunc).n = IS_A1 ((yyvsp[(3) - (3)].reg));
7211           (yyval.macfunc).op = 3;
7212           (yyval.macfunc).dst = (yyvsp[(1) - (3)].reg);
7213           (yyval.macfunc).s0.regno = 0;
7214           (yyval.macfunc).s1.regno = 0;
7215         }
7216     break;
7217
7218   case 314:
7219 #line 4241 "bfin-parse.y"
7220     {
7221           (yyval.macfunc) = (yyvsp[(1) - (1)].macfunc);
7222           (yyval.macfunc).w = 0; (yyval.macfunc).P = 0;
7223           (yyval.macfunc).dst.regno = 0;
7224         }
7225     break;
7226
7227   case 315:
7228 #line 4247 "bfin-parse.y"
7229     {
7230           if ((yyvsp[(4) - (5)].macfunc).n && IS_EVEN ((yyvsp[(1) - (5)].reg)))
7231             return yyerror ("Cannot move A1 to even register");
7232           else if (!(yyvsp[(4) - (5)].macfunc).n && !IS_EVEN ((yyvsp[(1) - (5)].reg)))
7233             return yyerror ("Cannot move A0 to odd register");
7234
7235           (yyval.macfunc) = (yyvsp[(4) - (5)].macfunc);
7236           (yyval.macfunc).w = 1;
7237           (yyval.macfunc).P = 1;
7238           (yyval.macfunc).dst = (yyvsp[(1) - (5)].reg);
7239         }
7240     break;
7241
7242   case 316:
7243 #line 4260 "bfin-parse.y"
7244     {
7245           if ((yyvsp[(4) - (5)].macfunc).n && !IS_H ((yyvsp[(1) - (5)].reg)))
7246             return yyerror ("Cannot move A1 to low half of register");
7247           else if (!(yyvsp[(4) - (5)].macfunc).n && IS_H ((yyvsp[(1) - (5)].reg)))
7248             return yyerror ("Cannot move A0 to high half of register");
7249
7250           (yyval.macfunc) = (yyvsp[(4) - (5)].macfunc);
7251           (yyval.macfunc).w = 1;
7252           (yyval.macfunc).P = 0;
7253           (yyval.macfunc).dst = (yyvsp[(1) - (5)].reg);
7254         }
7255     break;
7256
7257   case 317:
7258 #line 4273 "bfin-parse.y"
7259     {
7260           if (IS_A1 ((yyvsp[(3) - (3)].reg)) && !IS_H ((yyvsp[(1) - (3)].reg)))
7261             return yyerror ("Cannot move A1 to low half of register");
7262           else if (!IS_A1 ((yyvsp[(3) - (3)].reg)) && IS_H ((yyvsp[(1) - (3)].reg)))
7263             return yyerror ("Cannot move A0 to high half of register");
7264
7265           (yyval.macfunc).w = 1;
7266           (yyval.macfunc).P = 0;
7267           (yyval.macfunc).n = IS_A1 ((yyvsp[(3) - (3)].reg));
7268           (yyval.macfunc).op = 3;
7269           (yyval.macfunc).dst = (yyvsp[(1) - (3)].reg);
7270           (yyval.macfunc).s0.regno = 0;
7271           (yyval.macfunc).s1.regno = 0;
7272         }
7273     break;
7274
7275   case 318:
7276 #line 4291 "bfin-parse.y"
7277     {
7278           (yyval.macfunc).n = IS_A1 ((yyvsp[(1) - (2)].reg));
7279           (yyval.macfunc).op = 0;
7280           (yyval.macfunc).s0 = (yyvsp[(2) - (2)].macfunc).s0;
7281           (yyval.macfunc).s1 = (yyvsp[(2) - (2)].macfunc).s1;
7282         }
7283     break;
7284
7285   case 319:
7286 #line 4298 "bfin-parse.y"
7287     {
7288           (yyval.macfunc).n = IS_A1 ((yyvsp[(1) - (2)].reg));
7289           (yyval.macfunc).op = 1;
7290           (yyval.macfunc).s0 = (yyvsp[(2) - (2)].macfunc).s0;
7291           (yyval.macfunc).s1 = (yyvsp[(2) - (2)].macfunc).s1;
7292         }
7293     break;
7294
7295   case 320:
7296 #line 4305 "bfin-parse.y"
7297     {
7298           (yyval.macfunc).n = IS_A1 ((yyvsp[(1) - (2)].reg));
7299           (yyval.macfunc).op = 2;
7300           (yyval.macfunc).s0 = (yyvsp[(2) - (2)].macfunc).s0;
7301           (yyval.macfunc).s1 = (yyvsp[(2) - (2)].macfunc).s1;
7302         }
7303     break;
7304
7305   case 321:
7306 #line 4315 "bfin-parse.y"
7307     {
7308           if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
7309             {
7310               (yyval.macfunc).s0 = (yyvsp[(1) - (3)].reg);
7311               (yyval.macfunc).s1 = (yyvsp[(3) - (3)].reg);
7312             }
7313           else
7314             return yyerror ("Dregs expected");
7315         }
7316     break;
7317
7318   case 322:
7319 #line 4328 "bfin-parse.y"
7320     {
7321         (yyval.r0).r0 = 0;
7322         }
7323     break;
7324
7325   case 323:
7326 #line 4332 "bfin-parse.y"
7327     {
7328         (yyval.r0).r0 = 1;
7329         }
7330     break;
7331
7332   case 324:
7333 #line 4336 "bfin-parse.y"
7334     {
7335         (yyval.r0).r0 = 2;
7336         }
7337     break;
7338
7339   case 325:
7340 #line 4340 "bfin-parse.y"
7341     {
7342         (yyval.r0).r0 = 3;
7343         }
7344     break;
7345
7346   case 326:
7347 #line 4347 "bfin-parse.y"
7348     {
7349           (yyval.modcodes).r0 = (yyvsp[(3) - (3)].reg).regno;
7350           (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7351           (yyval.modcodes).s0 = 0;
7352         }
7353     break;
7354
7355   case 327:
7356 #line 4353 "bfin-parse.y"
7357     {
7358           (yyval.modcodes).r0 = 0x18;
7359           (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7360           (yyval.modcodes).s0 = 0;
7361         }
7362     break;
7363
7364   case 328:
7365 #line 4359 "bfin-parse.y"
7366     {
7367           (yyval.modcodes).r0 = (yyvsp[(1) - (3)].reg).regno;
7368           (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7369           (yyval.modcodes).s0 = 1;
7370         }
7371     break;
7372
7373   case 329:
7374 #line 4365 "bfin-parse.y"
7375     {
7376           (yyval.modcodes).r0 = 0x18;
7377           (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7378           (yyval.modcodes).s0 = 1;
7379         }
7380     break;
7381
7382   case 330:
7383 #line 4375 "bfin-parse.y"
7384     {
7385         Expr_Node_Value val;
7386         val.s_value = S_GET_NAME((yyvsp[(1) - (1)].symbol));
7387         (yyval.expr) = Expr_Node_Create (Expr_Node_Reloc, val, NULL, NULL);
7388         }
7389     break;
7390
7391   case 331:
7392 #line 4384 "bfin-parse.y"
7393     { (yyval.value) = BFD_RELOC_BFIN_GOT; }
7394     break;
7395
7396   case 332:
7397 #line 4386 "bfin-parse.y"
7398     { (yyval.value) = BFD_RELOC_BFIN_GOT17M4; }
7399     break;
7400
7401   case 333:
7402 #line 4388 "bfin-parse.y"
7403     { (yyval.value) = BFD_RELOC_BFIN_FUNCDESC_GOT17M4; }
7404     break;
7405
7406   case 334:
7407 #line 4392 "bfin-parse.y"
7408     {
7409         Expr_Node_Value val;
7410         val.i_value = (yyvsp[(3) - (3)].value);
7411         (yyval.expr) = Expr_Node_Create (Expr_Node_GOT_Reloc, val, (yyvsp[(1) - (3)].expr), NULL);
7412         }
7413     break;
7414
7415   case 335:
7416 #line 4400 "bfin-parse.y"
7417     {
7418         (yyval.expr) = (yyvsp[(1) - (1)].expr);
7419         }
7420     break;
7421
7422   case 336:
7423 #line 4404 "bfin-parse.y"
7424     {
7425         (yyval.expr) = (yyvsp[(1) - (1)].expr);
7426         }
7427     break;
7428
7429   case 337:
7430 #line 4411 "bfin-parse.y"
7431     {
7432         (yyval.expr) = (yyvsp[(1) - (3)].expr);
7433         }
7434     break;
7435
7436   case 338:
7437 #line 4417 "bfin-parse.y"
7438     {
7439         Expr_Node_Value val;
7440         val.i_value = (yyvsp[(1) - (1)].value);
7441         (yyval.expr) = Expr_Node_Create (Expr_Node_Constant, val, NULL, NULL);
7442         }
7443     break;
7444
7445   case 339:
7446 #line 4423 "bfin-parse.y"
7447     {
7448         (yyval.expr) = (yyvsp[(1) - (1)].expr);
7449         }
7450     break;
7451
7452   case 340:
7453 #line 4427 "bfin-parse.y"
7454     {
7455         (yyval.expr) = (yyvsp[(2) - (3)].expr);
7456         }
7457     break;
7458
7459   case 341:
7460 #line 4431 "bfin-parse.y"
7461     {
7462         (yyval.expr) = unary (Expr_Op_Type_COMP, (yyvsp[(2) - (2)].expr));
7463         }
7464     break;
7465
7466   case 342:
7467 #line 4435 "bfin-parse.y"
7468     {
7469         (yyval.expr) = unary (Expr_Op_Type_NEG, (yyvsp[(2) - (2)].expr));
7470         }
7471     break;
7472
7473   case 343:
7474 #line 4441 "bfin-parse.y"
7475     {
7476         (yyval.expr) = (yyvsp[(1) - (1)].expr);
7477         }
7478     break;
7479
7480   case 344:
7481 #line 4447 "bfin-parse.y"
7482     {
7483         (yyval.expr) = binary (Expr_Op_Type_Mult, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7484         }
7485     break;
7486
7487   case 345:
7488 #line 4451 "bfin-parse.y"
7489     {
7490         (yyval.expr) = binary (Expr_Op_Type_Div, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7491         }
7492     break;
7493
7494   case 346:
7495 #line 4455 "bfin-parse.y"
7496     {
7497         (yyval.expr) = binary (Expr_Op_Type_Mod, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7498         }
7499     break;
7500
7501   case 347:
7502 #line 4459 "bfin-parse.y"
7503     {
7504         (yyval.expr) = binary (Expr_Op_Type_Add, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7505         }
7506     break;
7507
7508   case 348:
7509 #line 4463 "bfin-parse.y"
7510     {
7511         (yyval.expr) = binary (Expr_Op_Type_Sub, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7512         }
7513     break;
7514
7515   case 349:
7516 #line 4467 "bfin-parse.y"
7517     {
7518         (yyval.expr) = binary (Expr_Op_Type_Lshift, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7519         }
7520     break;
7521
7522   case 350:
7523 #line 4471 "bfin-parse.y"
7524     {
7525         (yyval.expr) = binary (Expr_Op_Type_Rshift, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7526         }
7527     break;
7528
7529   case 351:
7530 #line 4475 "bfin-parse.y"
7531     {
7532         (yyval.expr) = binary (Expr_Op_Type_BAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7533         }
7534     break;
7535
7536   case 352:
7537 #line 4479 "bfin-parse.y"
7538     {
7539         (yyval.expr) = binary (Expr_Op_Type_LOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7540         }
7541     break;
7542
7543   case 353:
7544 #line 4483 "bfin-parse.y"
7545     {
7546         (yyval.expr) = binary (Expr_Op_Type_BOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7547         }
7548     break;
7549
7550   case 354:
7551 #line 4487 "bfin-parse.y"
7552     {
7553         (yyval.expr) = (yyvsp[(1) - (1)].expr);
7554         }
7555     break;
7556
7557
7558 /* Line 1267 of yacc.c.  */
7559 #line 7560 "bfin-parse.c"
7560       default: break;
7561     }
7562   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
7563
7564   YYPOPSTACK (yylen);
7565   yylen = 0;
7566   YY_STACK_PRINT (yyss, yyssp);
7567
7568   *++yyvsp = yyval;
7569
7570
7571   /* Now `shift' the result of the reduction.  Determine what state
7572      that goes to, based on the state we popped back to and the rule
7573      number reduced by.  */
7574
7575   yyn = yyr1[yyn];
7576
7577   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
7578   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
7579     yystate = yytable[yystate];
7580   else
7581     yystate = yydefgoto[yyn - YYNTOKENS];
7582
7583   goto yynewstate;
7584
7585
7586 /*------------------------------------.
7587 | yyerrlab -- here on detecting error |
7588 `------------------------------------*/
7589 yyerrlab:
7590   /* If not already recovering from an error, report this error.  */
7591   if (!yyerrstatus)
7592     {
7593       ++yynerrs;
7594 #if ! YYERROR_VERBOSE
7595       yyerror (YY_("syntax error"));
7596 #else
7597       {
7598         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
7599         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
7600           {
7601             YYSIZE_T yyalloc = 2 * yysize;
7602             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
7603               yyalloc = YYSTACK_ALLOC_MAXIMUM;
7604             if (yymsg != yymsgbuf)
7605               YYSTACK_FREE (yymsg);
7606             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
7607             if (yymsg)
7608               yymsg_alloc = yyalloc;
7609             else
7610               {
7611                 yymsg = yymsgbuf;
7612                 yymsg_alloc = sizeof yymsgbuf;
7613               }
7614           }
7615
7616         if (0 < yysize && yysize <= yymsg_alloc)
7617           {
7618             (void) yysyntax_error (yymsg, yystate, yychar);
7619             yyerror (yymsg);
7620           }
7621         else
7622           {
7623             yyerror (YY_("syntax error"));
7624             if (yysize != 0)
7625               goto yyexhaustedlab;
7626           }
7627       }
7628 #endif
7629     }
7630
7631
7632
7633   if (yyerrstatus == 3)
7634     {
7635       /* If just tried and failed to reuse look-ahead token after an
7636          error, discard it.  */
7637
7638       if (yychar <= YYEOF)
7639         {
7640           /* Return failure if at end of input.  */
7641           if (yychar == YYEOF)
7642             YYABORT;
7643         }
7644       else
7645         {
7646           yydestruct ("Error: discarding",
7647                       yytoken, &yylval);
7648           yychar = YYEMPTY;
7649         }
7650     }
7651
7652   /* Else will try to reuse look-ahead token after shifting the error
7653      token.  */
7654   goto yyerrlab1;
7655
7656
7657 /*---------------------------------------------------.
7658 | yyerrorlab -- error raised explicitly by YYERROR.  |
7659 `---------------------------------------------------*/
7660 yyerrorlab:
7661
7662   /* Pacify compilers like GCC when the user code never invokes
7663      YYERROR and the label yyerrorlab therefore never appears in user
7664      code.  */
7665   if (/*CONSTCOND*/ 0)
7666      goto yyerrorlab;
7667
7668   /* Do not reclaim the symbols of the rule which action triggered
7669      this YYERROR.  */
7670   YYPOPSTACK (yylen);
7671   yylen = 0;
7672   YY_STACK_PRINT (yyss, yyssp);
7673   yystate = *yyssp;
7674   goto yyerrlab1;
7675
7676
7677 /*-------------------------------------------------------------.
7678 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
7679 `-------------------------------------------------------------*/
7680 yyerrlab1:
7681   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
7682
7683   for (;;)
7684     {
7685       yyn = yypact[yystate];
7686       if (yyn != YYPACT_NINF)
7687         {
7688           yyn += YYTERROR;
7689           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
7690             {
7691               yyn = yytable[yyn];
7692               if (0 < yyn)
7693                 break;
7694             }
7695         }
7696
7697       /* Pop the current state because it cannot handle the error token.  */
7698       if (yyssp == yyss)
7699         YYABORT;
7700
7701
7702       yydestruct ("Error: popping",
7703                   yystos[yystate], yyvsp);
7704       YYPOPSTACK (1);
7705       yystate = *yyssp;
7706       YY_STACK_PRINT (yyss, yyssp);
7707     }
7708
7709   if (yyn == YYFINAL)
7710     YYACCEPT;
7711
7712   *++yyvsp = yylval;
7713
7714
7715   /* Shift the error token.  */
7716   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7717
7718   yystate = yyn;
7719   goto yynewstate;
7720
7721
7722 /*-------------------------------------.
7723 | yyacceptlab -- YYACCEPT comes here.  |
7724 `-------------------------------------*/
7725 yyacceptlab:
7726   yyresult = 0;
7727   goto yyreturn;
7728
7729 /*-----------------------------------.
7730 | yyabortlab -- YYABORT comes here.  |
7731 `-----------------------------------*/
7732 yyabortlab:
7733   yyresult = 1;
7734   goto yyreturn;
7735
7736 #ifndef yyoverflow
7737 /*-------------------------------------------------.
7738 | yyexhaustedlab -- memory exhaustion comes here.  |
7739 `-------------------------------------------------*/
7740 yyexhaustedlab:
7741   yyerror (YY_("memory exhausted"));
7742   yyresult = 2;
7743   /* Fall through.  */
7744 #endif
7745
7746 yyreturn:
7747   if (yychar != YYEOF && yychar != YYEMPTY)
7748      yydestruct ("Cleanup: discarding lookahead",
7749                  yytoken, &yylval);
7750   /* Do not reclaim the symbols of the rule which action triggered
7751      this YYABORT or YYACCEPT.  */
7752   YYPOPSTACK (yylen);
7753   YY_STACK_PRINT (yyss, yyssp);
7754   while (yyssp != yyss)
7755     {
7756       yydestruct ("Cleanup: popping",
7757                   yystos[*yyssp], yyvsp);
7758       YYPOPSTACK (1);
7759     }
7760 #ifndef yyoverflow
7761   if (yyss != yyssa)
7762     YYSTACK_FREE (yyss);
7763 #endif
7764 #if YYERROR_VERBOSE
7765   if (yymsg != yymsgbuf)
7766     YYSTACK_FREE (yymsg);
7767 #endif
7768   /* Make sure YYID is used.  */
7769   return YYID (yyresult);
7770 }
7771
7772
7773 #line 4493 "bfin-parse.y"
7774
7775
7776 EXPR_T
7777 mkexpr (int x, SYMBOL_T s)
7778 {
7779   EXPR_T e = (EXPR_T) ALLOCATE (sizeof (struct expression_cell));
7780   e->value = x;
7781   EXPR_SYMBOL(e) = s;
7782   return e;
7783 }
7784
7785 static int
7786 value_match (Expr_Node *exp, int sz, int sign, int mul, int issigned)
7787 {
7788   int umax = (1 << sz) - 1;
7789   int min = -1 << (sz - 1);
7790   int max = (1 << (sz - 1)) - 1;
7791
7792   int v = (EXPR_VALUE (exp)) & 0xffffffff;
7793
7794   if ((v % mul) != 0)
7795     {
7796       error ("%s:%d: Value Error -- Must align to %d\n", __FILE__, __LINE__, mul);
7797       return 0;
7798     }
7799
7800   v /= mul;
7801
7802   if (sign)
7803     v = -v;
7804
7805   if (issigned)
7806     {
7807       if (v >= min && v <= max) return 1;
7808
7809 #ifdef DEBUG
7810       fprintf(stderr, "signed value %lx out of range\n", v * mul);
7811 #endif
7812       return 0;
7813     }
7814   if (v <= umax && v >= 0)
7815     return 1;
7816 #ifdef DEBUG
7817   fprintf(stderr, "unsigned value %lx out of range\n", v * mul);
7818 #endif
7819   return 0;
7820 }
7821
7822 /* Return the expression structure that allows symbol operations.
7823    If the left and right children are constants, do the operation.  */
7824 static Expr_Node *
7825 binary (Expr_Op_Type op, Expr_Node *x, Expr_Node *y)
7826 {
7827   Expr_Node_Value val;
7828
7829   if (x->type == Expr_Node_Constant && y->type == Expr_Node_Constant)
7830     {
7831       switch (op)
7832         {
7833         case Expr_Op_Type_Add:
7834           x->value.i_value += y->value.i_value;
7835           break;
7836         case Expr_Op_Type_Sub:
7837           x->value.i_value -= y->value.i_value;
7838           break;
7839         case Expr_Op_Type_Mult:
7840           x->value.i_value *= y->value.i_value;
7841           break;
7842         case Expr_Op_Type_Div:
7843           if (y->value.i_value == 0)
7844             error ("Illegal Expression:  Division by zero.");
7845           else
7846             x->value.i_value /= y->value.i_value;
7847           break;
7848         case Expr_Op_Type_Mod:
7849           x->value.i_value %= y->value.i_value;
7850           break;
7851         case Expr_Op_Type_Lshift:
7852           x->value.i_value <<= y->value.i_value;
7853           break;
7854         case Expr_Op_Type_Rshift:
7855           x->value.i_value >>= y->value.i_value;
7856           break;
7857         case Expr_Op_Type_BAND:
7858           x->value.i_value &= y->value.i_value;
7859           break;
7860         case Expr_Op_Type_BOR:
7861           x->value.i_value |= y->value.i_value;
7862           break;
7863         case Expr_Op_Type_BXOR:
7864           x->value.i_value ^= y->value.i_value;
7865           break;
7866         case Expr_Op_Type_LAND:
7867           x->value.i_value = x->value.i_value && y->value.i_value;
7868           break;
7869         case Expr_Op_Type_LOR:
7870           x->value.i_value = x->value.i_value || y->value.i_value;
7871           break;
7872
7873         default:
7874           error ("%s:%d: Internal assembler error\n", __FILE__, __LINE__);
7875         }
7876       return x;
7877     }
7878   /* Canonicalize order to EXPR OP CONSTANT.  */
7879   if (x->type == Expr_Node_Constant)
7880     {
7881       Expr_Node *t = x;
7882       x = y;
7883       y = t;
7884     }
7885   /* Canonicalize subtraction of const to addition of negated const.  */
7886   if (op == Expr_Op_Type_Sub && y->type == Expr_Node_Constant)
7887     {
7888       op = Expr_Op_Type_Add;
7889       y->value.i_value = -y->value.i_value;
7890     }
7891   if (y->type == Expr_Node_Constant && x->type == Expr_Node_Binop
7892       && x->Right_Child->type == Expr_Node_Constant)
7893     {
7894       if (op == x->value.op_value && x->value.op_value == Expr_Op_Type_Add)
7895         {
7896           x->Right_Child->value.i_value += y->value.i_value;
7897           return x;
7898         }
7899     }
7900
7901   /* Create a new expression structure.  */
7902   val.op_value = op;
7903   return Expr_Node_Create (Expr_Node_Binop, val, x, y);
7904 }
7905
7906 static Expr_Node *
7907 unary (Expr_Op_Type op, Expr_Node *x)
7908 {
7909   if (x->type == Expr_Node_Constant)
7910     {
7911       switch (op)
7912         {
7913         case Expr_Op_Type_NEG:
7914           x->value.i_value = -x->value.i_value;
7915           break;
7916         case Expr_Op_Type_COMP:
7917           x->value.i_value = ~x->value.i_value;
7918           break;
7919         default:
7920           error ("%s:%d: Internal assembler error\n", __FILE__, __LINE__);
7921         }
7922       return x;
7923     }
7924   else
7925     {
7926       /* Create a new expression structure.  */
7927       Expr_Node_Value val;
7928       val.op_value = op;
7929       return Expr_Node_Create (Expr_Node_Unop, val, x, NULL);
7930     }
7931 }
7932
7933 int debug_codeselection = 0;
7934 static void
7935 notethat (char *format, ...)
7936 {
7937   va_list ap;
7938   va_start (ap, format);
7939   if (debug_codeselection)
7940     {
7941       vfprintf (errorf, format, ap);
7942     }
7943   va_end (ap);
7944 }
7945
7946 #ifdef TEST
7947 main (int argc, char **argv)
7948 {
7949   yyparse();
7950 }
7951 #endif
7952
7953