1 /* A Bison parser, made by GNU Bison 2.3. */
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
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)
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.
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. */
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.
33 This special exception was added by the Free Software Foundation in
34 version 2.2 of Bison. */
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37 simplifying the original so-called "semantic" parser. */
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. */
46 /* Identify Bison output. */
50 #define YYBISON_VERSION "2.3"
53 #define YYSKELETON_NAME "yacc.c"
58 /* Using locations. */
59 #define YYLSP_NEEDED 0
66 /* Put the tokens into the symbol table, so that GDB and other debuggers
95 REG_A_DOUBLE_ZERO = 284,
96 REG_A_DOUBLE_ONE = 285,
144 _PLUS_BAR_PLUS = 333,
145 _PLUS_BAR_MINUS = 334,
146 _MINUS_BAR_PLUS = 335,
147 _MINUS_BAR_MINUS = 336,
154 _GREATER_GREATER_GREATER_THAN_ASSIGN = 343,
157 GREATER_GREATER = 346,
158 _GREATER_GREATER_GREATER = 347,
159 _LESS_LESS_ASSIGN = 348,
160 _GREATER_GREATER_ASSIGN = 349,
167 _AMPERSAND_ASSIGN = 356,
171 _LESS_THAN_ASSIGN = 360,
172 _ASSIGN_ASSIGN = 361,
237 FUNCDESC_GOT17M4 = 426,
243 #define BYTEOP16P 258
244 #define BYTEOP16M 259
248 #define BYTEUNPACK 263
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
293 #define LOOP_BEGIN 308
295 #define DISALGNEXCPT 310
297 #define JUMP_DOT_S 312
298 #define JUMP_DOT_L 313
304 #define AMPERSAND 319
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
327 #define BXORSHIFT 342
328 #define _GREATER_GREATER_GREATER_THAN_ASSIGN 343
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
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
351 #define LESS_THAN 366
400 #define SEMICOLON 415
405 #define STATUS_REG 420
411 #define FUNCDESC_GOT17M4 426
418 /* Copy the first part of user declarations. */
419 #line 20 "bfin-parse.y"
424 #include "bfin-aux.h" /* Opcode generating auxiliaries. */
426 #include "elf/common.h"
427 #include "elf/bfin.h"
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)
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, \
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, \
440 #define DSP32SHIFT(sopcde, dst0, src0, src1, sop, hls) \
441 bfin_gen_dsp32shift (sopcde, dst0, src0, src1, sop, hls)
443 #define DSP32SHIFTIMM(sopcde, dst0, immag, src1, sop, hls) \
444 bfin_gen_dsp32shiftimm (sopcde, dst0, immag, src1, sop, hls)
446 #define LDIMMHALF_R(reg, h, s, z, hword) \
447 bfin_gen_ldimmhalf (reg, h, s, z, hword, 1)
449 #define LDIMMHALF_R5(reg, h, s, z, hword) \
450 bfin_gen_ldimmhalf (reg, h, s, z, hword, 2)
452 #define LDSTIDXI(ptr, reg, w, sz, z, offset) \
453 bfin_gen_ldstidxi (ptr, reg, w, sz, z, offset)
455 #define LDST(ptr, reg, aop, sz, z, w) \
456 bfin_gen_ldst (ptr, reg, aop, sz, z, w)
458 #define LDSTII(ptr, reg, offset, w, op) \
459 bfin_gen_ldstii (ptr, reg, offset, w, op)
461 #define DSPLDST(i, m, reg, aop, w) \
462 bfin_gen_dspldst (i, reg, aop, w, m)
464 #define LDSTPMOD(ptr, reg, idx, aop, w) \
465 bfin_gen_ldstpmod (ptr, reg, aop, w, idx)
467 #define LDSTIIFP(offset, reg, w) \
468 bfin_gen_ldstiifp (reg, offset, w)
470 #define LOGI2OP(dst, src, opc) \
471 bfin_gen_logi2op (opc, src, dst.regno & CODE_MASK)
473 #define ALU2OP(dst, src, opc) \
474 bfin_gen_alu2op (dst, src, opc)
476 #define BRCC(t, b, offset) \
477 bfin_gen_brcc (t, b, offset)
479 #define UJUMP(offset) \
480 bfin_gen_ujump (offset)
482 #define PROGCTRL(prgfunc, poprnd) \
483 bfin_gen_progctrl (prgfunc, poprnd)
485 #define PUSHPOPMULTIPLE(dr, pr, d, p, w) \
486 bfin_gen_pushpopmultiple (dr, pr, d, p, w)
488 #define PUSHPOPREG(reg, w) \
489 bfin_gen_pushpopreg (reg, w)
491 #define CALLA(addr, s) \
492 bfin_gen_calla (addr, s)
494 #define LINKAGE(r, framesize) \
495 bfin_gen_linkage (r, framesize)
497 #define COMPI2OPD(dst, src, op) \
498 bfin_gen_compi2opd (dst, src, op)
500 #define COMPI2OPP(dst, src, op) \
501 bfin_gen_compi2opp (dst, src, op)
503 #define DAGMODIK(i, op) \
504 bfin_gen_dagmodik (i, op)
506 #define DAGMODIM(i, m, op, br) \
507 bfin_gen_dagmodim (i, m, op, br)
509 #define COMP3OP(dst, src0, src1, opc) \
510 bfin_gen_comp3op (src0, src1, dst, opc)
512 #define PTR2OP(dst, src, opc) \
513 bfin_gen_ptr2op (dst, src, opc)
515 #define CCFLAG(x, y, opc, i, g) \
516 bfin_gen_ccflag (x, y, opc, i, g)
518 #define CCMV(src, dst, t) \
519 bfin_gen_ccmv (src, dst, t)
521 #define CACTRL(reg, a, op) \
522 bfin_gen_cactrl (reg, a, op)
524 #define LOOPSETUP(soffset, c, rop, eoffset, reg) \
525 bfin_gen_loopsetup (soffset, c, rop, eoffset, reg)
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)
537 #define IS_PCREL4(expr) \
538 (value_match (expr, 4, 0, 2, 0))
540 #define IS_LPPCREL10(expr) \
541 (value_match (expr, 10, 0, 2, 0))
543 #define IS_PCREL10(expr) \
544 (value_match (expr, 10, 0, 2, 1))
546 #define IS_PCREL12(expr) \
547 (value_match (expr, 12, 0, 2, 1))
549 #define IS_PCREL24(expr) \
550 (value_match (expr, 24, 0, 2, 1))
553 static int value_match (Expr_Node *, int, int, int, int);
558 static Expr_Node *binary (Expr_Op_Type, Expr_Node *, Expr_Node *);
559 static Expr_Node *unary (Expr_Op_Type, Expr_Node *);
561 static void notethat (char *, ...);
563 char *current_inputline;
565 int yyerror (char *);
567 /* Used to set SRCx fields to all 1s as described in the PRM. */
568 static Register reg7 = {REG_R7, 0};
570 void error (char *format, ...)
573 static char buffer[2000];
575 va_start (ap, format);
576 vsprintf (buffer, format, ap);
579 as_bad ("%s", buffer);
588 else if (yytext[0] != ';')
589 error ("%s. Input text was %s.", msg, yytext);
597 in_range_p (Expr_Node *exp, int from, int to, unsigned int mask)
599 int val = EXPR_VALUE (exp);
600 if (exp->type != Expr_Node_Constant)
602 if (val < from || val > to)
604 return (val & mask) == 0;
607 extern int yylex (void);
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)
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)))
625 /* Auxiliary functions. */
628 valid_dreg_pair (Register *reg1, Expr_Node *reg2)
630 if (!IS_DREG (*reg1))
632 yyerror ("Dregs expected");
636 if (reg1->regno != 1 && reg1->regno != 3)
638 yyerror ("Bad register pair");
642 if (imm7 (reg2) != reg1->regno - 1)
644 yyerror ("Bad register pair");
653 check_multiply_halfregs (Macfunc *aa, Macfunc *ab)
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");
663 /* Check mac option. */
666 check_macfunc_option (Macfunc *a, Opt_mode *opt)
668 /* Default option is always valid. */
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))
686 /* Check (vector) mac funcs and ops. */
689 check_macfuncs (Macfunc *aa, Opt_mode *opa,
690 Macfunc *ab, Opt_mode *opb)
692 /* Variables for swapping. */
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. */
699 return yyerror ("Bad opt mode");
701 /* If a0macfunc comes before a1macfunc, swap them. */
705 /* (M) is not allowed here. */
707 return yyerror ("(M) not allowed with A0MAC");
709 return yyerror ("Vector AxMACs can't be same");
711 mtmp = *aa; *aa = *ab; *ab = mtmp;
712 otmp = *opa; *opa = *opb; *opb = otmp;
717 return yyerror ("(M) not allowed with A0MAC");
719 return yyerror ("Vector AxMACs can't be same");
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))
727 if (check_multiply_halfregs (aa, ab) < 0)
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);
740 if (aa->w == ab->w && aa->P != ab->P)
741 return yyerror ("Destination Dreg sizes (full or half) must match");
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");
751 /* Make sure mod flags get ORed, too. */
752 opb->mod |= opa->mod;
755 if (check_macfunc_option (aa, opb) < 0
756 && check_macfunc_option (ab, opb) < 0)
757 return yyerror ("bad option");
759 /* Make sure first macfunc has got both P flags ORed. */
767 is_group1 (INSTR_T x)
769 /* Group1 is dpsLDST, LDSTpmod, LDST, LDSTiiFP, LDSTii. */
770 if ((x->value & 0xc000) == 0x8000 || (x->value == 0x0000))
777 is_group2 (INSTR_T x)
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))
794 if ((x->value & 0xf000) == 0x8000)
796 int aop = ((x->value >> 9) & 0x3);
797 int w = ((x->value >> 11) & 0x1);
803 if (((x->value & 0xFF60) == 0x9E60) || /* dagMODim_0 */
804 ((x->value & 0xFFF0) == 0x9F60)) /* dagMODik_0 */
807 /* decode_dspLDST_0 */
808 if ((x->value & 0xFC00) == 0x9C00)
810 int w = ((x->value >> 9) & 0x1);
819 gen_multi_instr_1 (INSTR_T dsp32, INSTR_T dsp16_grp1, INSTR_T dsp16_grp2)
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;
825 if ((mask1 & mask2) || (mask1 & mask3) || (mask2 & mask3))
826 yyerror ("resource conflict in multi-issue instruction");
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");
838 if (is_store (dsp16_grp1) && is_store (dsp16_grp2))
839 yyerror ("Only one instruction in multi-issue instruction can be a store");
841 return bfin_gen_multi_instr (dsp32, dsp16_grp1, dsp16_grp2);
846 /* Enabling traces. */
851 /* Enabling verbose error messages. */
852 #ifdef YYERROR_VERBOSE
853 # undef YYERROR_VERBOSE
854 # define YYERROR_VERBOSE 1
856 # define YYERROR_VERBOSE 0
859 /* Enabling the token table. */
860 #ifndef YYTOKEN_TABLE
861 # define YYTOKEN_TABLE 0
864 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
865 typedef union YYSTYPE
866 #line 446 "bfin-parse.y"
874 struct { int r0; int s0; int x0; int aop; } modcodes;
875 struct { int r0; } r0;
878 /* Line 193 of yacc.c. */
879 #line 880 "bfin-parse.c"
881 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
882 # define YYSTYPE_IS_DECLARED 1
883 # define YYSTYPE_IS_TRIVIAL 1
888 /* Copy the second part of user declarations. */
891 /* Line 216 of yacc.c. */
892 #line 893 "bfin-parse.c"
899 typedef YYTYPE_UINT8 yytype_uint8;
901 typedef unsigned char yytype_uint8;
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;
910 typedef short int yytype_int8;
914 typedef YYTYPE_UINT16 yytype_uint16;
916 typedef unsigned short int yytype_uint16;
920 typedef YYTYPE_INT16 yytype_int16;
922 typedef short int yytype_int16;
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
935 # define YYSIZE_T unsigned int
939 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
942 # if defined YYENABLE_NLS && YYENABLE_NLS
944 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
945 # define YY_(msgid) dgettext ("bison-runtime", msgid)
949 # define YY_(msgid) msgid
953 /* Suppress unused-variable warnings by "using" E. */
954 #if ! defined lint || defined __GNUC__
955 # define YYUSE(e) ((void) (e))
957 # define YYUSE(e) /* empty */
960 /* Identity function, used to suppress warnings about constant conditions. */
964 #if (defined __STDC__ || defined __C99__FUNC__ \
965 || defined __cplusplus || defined _MSC_VER)
978 #if ! defined yyoverflow || YYERROR_VERBOSE
980 /* The parser invokes alloca or malloc; define the necessary symbols. */
982 # ifdef YYSTACK_USE_ALLOCA
983 # if YYSTACK_USE_ALLOCA
985 # define YYSTACK_ALLOC __builtin_alloca
986 # elif defined __BUILTIN_VA_ARG_INCR
987 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
989 # define YYSTACK_ALLOC __alloca
990 # elif defined _MSC_VER
991 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
992 # define alloca _alloca
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 */
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 */
1017 # define YYSTACK_ALLOC YYMALLOC
1018 # define YYSTACK_FREE YYFREE
1019 # ifndef YYSTACK_ALLOC_MAXIMUM
1020 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
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 */
1027 # define _STDLIB_H 1
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 */
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 */
1045 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
1048 #if (! defined yyoverflow \
1049 && (! defined __cplusplus \
1050 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1052 /* A type that is properly aligned for any stack member. */
1059 /* The size of the maximum gap between one aligned stack and the next. */
1060 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
1062 /* The size of an array large to enough to hold all stacks, each with
1064 # define YYSTACK_BYTES(N) \
1065 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
1066 + YYSTACK_GAP_MAXIMUM)
1068 /* Copy COUNT objects from FROM to TO. The source and destination do
1071 # if defined __GNUC__ && 1 < __GNUC__
1072 # define YYCOPY(To, From, Count) \
1073 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
1075 # define YYCOPY(To, From, Count) \
1079 for (yyi = 0; yyi < (Count); yyi++) \
1080 (To)[yyi] = (From)[yyi]; \
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
1091 # define YYSTACK_RELOCATE(Stack) \
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); \
1104 /* YYFINAL -- State number of the termination state. */
1106 /* YYLAST -- Last index in YYTABLE. */
1109 /* YYNTOKENS -- Number of terminals. */
1110 #define YYNTOKENS 174
1111 /* YYNNTS -- Number of nonterminals. */
1113 /* YYNRULES -- Number of rules. */
1114 #define YYNRULES 354
1115 /* YYNRULES -- Number of states. */
1116 #define YYNSTATES 1021
1118 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1119 #define YYUNDEFTOK 2
1120 #define YYMAXUTOK 428
1122 #define YYTRANSLATE(YYX) \
1123 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
1125 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
1126 static const yytype_uint8 yytranslate[] =
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
1174 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1176 static const yytype_uint16 yyprhs[] =
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
1216 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1217 static const yytype_int16 yyrhs[] =
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
1407 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1408 static const yytype_uint16 yyrline[] =
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
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[] =
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
1493 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1495 static const yytype_uint16 yytoknum[] =
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,
1518 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1519 static const yytype_uint8 yyr1[] =
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
1559 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1560 static const yytype_uint8 yyr2[] =
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,
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[] =
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,
1710 /* YYDEFGOTO[NTERM-NUM]. */
1711 static const yytype_int16 yydefgoto[] =
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
1720 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1722 #define YYPACT_NINF -869
1723 static const yytype_int16 yypact[] =
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,
1830 /* YYPGOTO[NTERM-NUM]. */
1831 static const yytype_int16 yypgoto[] =
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
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[] =
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
1980 static const yytype_int16 yycheck[] =
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
2115 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2116 symbol of state STATE-NUM. */
2117 static const yytype_uint8 yystos[] =
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,
2224 #define yyerrok (yyerrstatus = 0)
2225 #define yyclearin (yychar = YYEMPTY)
2226 #define YYEMPTY (-2)
2229 #define YYACCEPT goto yyacceptlab
2230 #define YYABORT goto yyabortlab
2231 #define YYERROR goto yyerrorlab
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. */
2238 #define YYFAIL goto yyerrlab
2240 #define YYRECOVERING() (!!yyerrstatus)
2242 #define YYBACKUP(Token, Value) \
2244 if (yychar == YYEMPTY && yylen == 1) \
2248 yytoken = YYTRANSLATE (yychar); \
2254 yyerror (YY_("syntax error: cannot back up")); \
2261 #define YYERRCODE 256
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). */
2268 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2269 #ifndef YYLLOC_DEFAULT
2270 # define YYLLOC_DEFAULT(Current, Rhs, N) \
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; \
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; \
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. */
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)
2301 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2306 /* YYLEX -- calling `yylex' with the right arguments. */
2309 # define YYLEX yylex (YYLEX_PARAM)
2311 # define YYLEX yylex ()
2314 /* Enable debugging if requested. */
2318 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2319 # define YYFPRINTF fprintf
2322 # define YYDPRINTF(Args) \
2328 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
2332 YYFPRINTF (stderr, "%s ", Title); \
2333 yy_symbol_print (stderr, \
2335 YYFPRINTF (stderr, "\n"); \
2340 /*--------------------------------.
2341 | Print this symbol on YYOUTPUT. |
2342 `--------------------------------*/
2345 #if (defined __STDC__ || defined __C99__FUNC__ \
2346 || defined __cplusplus || defined _MSC_VER)
2348 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2351 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
2354 YYSTYPE const * const yyvaluep;
2360 if (yytype < YYNTOKENS)
2361 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2373 /*--------------------------------.
2374 | Print this symbol on YYOUTPUT. |
2375 `--------------------------------*/
2377 #if (defined __STDC__ || defined __C99__FUNC__ \
2378 || defined __cplusplus || defined _MSC_VER)
2380 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2383 yy_symbol_print (yyoutput, yytype, yyvaluep)
2386 YYSTYPE const * const yyvaluep;
2389 if (yytype < YYNTOKENS)
2390 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2392 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2394 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
2395 YYFPRINTF (yyoutput, ")");
2398 /*------------------------------------------------------------------.
2399 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2401 `------------------------------------------------------------------*/
2403 #if (defined __STDC__ || defined __C99__FUNC__ \
2404 || defined __cplusplus || defined _MSC_VER)
2406 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
2409 yy_stack_print (bottom, top)
2410 yytype_int16 *bottom;
2414 YYFPRINTF (stderr, "Stack now");
2415 for (; bottom <= top; ++bottom)
2416 YYFPRINTF (stderr, " %d", *bottom);
2417 YYFPRINTF (stderr, "\n");
2420 # define YY_STACK_PRINT(Bottom, Top) \
2423 yy_stack_print ((Bottom), (Top)); \
2427 /*------------------------------------------------.
2428 | Report that the YYRULE is going to be reduced. |
2429 `------------------------------------------------*/
2431 #if (defined __STDC__ || defined __C99__FUNC__ \
2432 || defined __cplusplus || defined _MSC_VER)
2434 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
2437 yy_reduce_print (yyvsp, yyrule)
2442 int yynrhs = yyr2[yyrule];
2444 unsigned long int yylno = yyrline[yyrule];
2445 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2447 /* The symbols being reduced. */
2448 for (yyi = 0; yyi < yynrhs; yyi++)
2450 fprintf (stderr, " $%d = ", yyi + 1);
2451 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
2452 &(yyvsp[(yyi + 1) - (yynrhs)])
2454 fprintf (stderr, "\n");
2458 # define YY_REDUCE_PRINT(Rule) \
2461 yy_reduce_print (yyvsp, Rule); \
2464 /* Nonzero means print parse trace. It is left uninitialized so that
2465 multiple parsers can coexist. */
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 */
2475 /* YYINITDEPTH -- initial size of the parser's stacks. */
2477 # define YYINITDEPTH 200
2480 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2481 if the built-in stack extension method is used).
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. */
2488 # define YYMAXDEPTH 10000
2496 # if defined __GLIBC__ && defined _STRING_H
2497 # define yystrlen strlen
2499 /* Return the length of YYSTR. */
2500 #if (defined __STDC__ || defined __C99__FUNC__ \
2501 || defined __cplusplus || defined _MSC_VER)
2503 yystrlen (const char *yystr)
2511 for (yylen = 0; yystr[yylen]; yylen++)
2519 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2520 # define yystpcpy stpcpy
2522 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2524 #if (defined __STDC__ || defined __C99__FUNC__ \
2525 || defined __cplusplus || defined _MSC_VER)
2527 yystpcpy (char *yydest, const char *yysrc)
2530 yystpcpy (yydest, yysrc)
2536 const char *yys = yysrc;
2538 while ((*yyd++ = *yys++) != '\0')
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
2555 yytnamerr (char *yyres, const char *yystr)
2560 char const *yyp = yystr;
2567 goto do_not_strip_quotes;
2571 goto do_not_strip_quotes;
2584 do_not_strip_quotes: ;
2588 return yystrlen (yystr);
2590 return yystpcpy (yyres, yystr) - yyres;
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. */
2602 yysyntax_error (char *yyresult, int yystate, int yychar)
2604 int yyn = yypact[yystate];
2606 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
2610 int yytype = YYTRANSLATE (yychar);
2611 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2612 YYSIZE_T yysize = yysize0;
2614 int yysize_overflow = 0;
2615 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2616 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
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");
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;
2639 /* Start YYX at -YYN if negative to avoid negative indexes in
2641 int yyxbegin = yyn < 0 ? -yyn : 0;
2643 /* Stay within bounds of both yycheck and yytname. */
2644 int yychecklim = YYLAST - yyn + 1;
2645 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2648 yyarg[0] = yytname[yytype];
2649 yyfmt = yystpcpy (yyformat, yyunexpected);
2651 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2652 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2654 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2658 yyformat[sizeof yyunexpected - 1] = '\0';
2661 yyarg[yycount++] = yytname[yyx];
2662 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2663 yysize_overflow |= (yysize1 < yysize);
2665 yyfmt = yystpcpy (yyfmt, yyprefix);
2669 yyf = YY_(yyformat);
2670 yysize1 = yysize + yystrlen (yyf);
2671 yysize_overflow |= (yysize1 < yysize);
2674 if (yysize_overflow)
2675 return YYSIZE_MAXIMUM;
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;
2684 while ((*yyp = *yyf) != '\0')
2686 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2688 yyp += yytnamerr (yyp, yyarg[yyi++]);
2701 #endif /* YYERROR_VERBOSE */
2704 /*-----------------------------------------------.
2705 | Release the memory associated to this symbol. |
2706 `-----------------------------------------------*/
2709 #if (defined __STDC__ || defined __C99__FUNC__ \
2710 || defined __cplusplus || defined _MSC_VER)
2712 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2715 yydestruct (yymsg, yytype, yyvaluep)
2725 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2736 /* Prevent warnings from -Wmissing-prototypes. */
2738 #ifdef YYPARSE_PARAM
2739 #if defined __STDC__ || defined __cplusplus
2740 int yyparse (void *YYPARSE_PARAM);
2744 #else /* ! YYPARSE_PARAM */
2745 #if defined __STDC__ || defined __cplusplus
2750 #endif /* ! YYPARSE_PARAM */
2754 /* The look-ahead symbol. */
2757 /* The semantic value of the look-ahead symbol. */
2760 /* Number of syntax errors so far. */
2769 #ifdef YYPARSE_PARAM
2770 #if (defined __STDC__ || defined __C99__FUNC__ \
2771 || defined __cplusplus || defined _MSC_VER)
2773 yyparse (void *YYPARSE_PARAM)
2776 yyparse (YYPARSE_PARAM)
2777 void *YYPARSE_PARAM;
2779 #else /* ! YYPARSE_PARAM */
2780 #if (defined __STDC__ || defined __C99__FUNC__ \
2781 || defined __cplusplus || defined _MSC_VER)
2795 /* Number of tokens to shift before error messages enabled. */
2797 /* Look-ahead token as an internal (translated) token number. */
2800 /* Buffer for error messages, and its allocated size. */
2802 char *yymsg = yymsgbuf;
2803 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2806 /* Three stacks and their tools:
2807 `yyss': related to states,
2808 `yyvs': related to semantic values,
2809 `yyls': related to locations.
2811 Refer to the stacks thru separate pointers, to allow yyoverflow
2812 to reallocate them elsewhere. */
2814 /* The state stack. */
2815 yytype_int16 yyssa[YYINITDEPTH];
2816 yytype_int16 *yyss = yyssa;
2817 yytype_int16 *yyssp;
2819 /* The semantic value stack. */
2820 YYSTYPE yyvsa[YYINITDEPTH];
2821 YYSTYPE *yyvs = yyvsa;
2826 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2828 YYSIZE_T yystacksize = YYINITDEPTH;
2830 /* The variables used to return semantic value and location from the
2835 /* The number of symbols on the RHS of the reduced rule.
2836 Keep to zero when no symbol should be popped. */
2839 YYDPRINTF ((stderr, "Starting parse\n"));
2844 yychar = YYEMPTY; /* Cause a token to be read. */
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. */
2856 /*------------------------------------------------------------.
2857 | yynewstate -- Push a new state, which is found in yystate. |
2858 `------------------------------------------------------------*/
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. */
2867 if (yyss + yystacksize - 1 <= yyssp)
2869 /* Get the current used size of the three stacks, in elements. */
2870 YYSIZE_T yysize = yyssp - yyss + 1;
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
2877 YYSTYPE *yyvs1 = yyvs;
2878 yytype_int16 *yyss1 = yyss;
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),
2894 #else /* no yyoverflow */
2895 # ifndef YYSTACK_RELOCATE
2896 goto yyexhaustedlab;
2898 /* Extend the stack our own way. */
2899 if (YYMAXDEPTH <= yystacksize)
2900 goto yyexhaustedlab;
2902 if (YYMAXDEPTH < yystacksize)
2903 yystacksize = YYMAXDEPTH;
2906 yytype_int16 *yyss1 = yyss;
2907 union yyalloc *yyptr =
2908 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2910 goto yyexhaustedlab;
2911 YYSTACK_RELOCATE (yyss);
2912 YYSTACK_RELOCATE (yyvs);
2914 # undef YYSTACK_RELOCATE
2916 YYSTACK_FREE (yyss1);
2919 #endif /* no yyoverflow */
2921 yyssp = yyss + yysize - 1;
2922 yyvsp = yyvs + yysize - 1;
2925 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2926 (unsigned long int) yystacksize));
2928 if (yyss + yystacksize - 1 <= yyssp)
2932 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2941 /* Do appropriate processing given the current state. Read a
2942 look-ahead token if we need one and don't already have one. */
2944 /* First try to decide what to do without reference to look-ahead token. */
2945 yyn = yypact[yystate];
2946 if (yyn == YYPACT_NINF)
2949 /* Not known => get a look-ahead token if don't already have one. */
2951 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2952 if (yychar == YYEMPTY)
2954 YYDPRINTF ((stderr, "Reading a token: "));
2958 if (yychar <= YYEOF)
2960 yychar = yytoken = YYEOF;
2961 YYDPRINTF ((stderr, "Now at end of input.\n"));
2965 yytoken = YYTRANSLATE (yychar);
2966 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2969 /* If the proper action on seeing token YYTOKEN is to reduce or to
2970 detect an error, take that action. */
2972 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2977 if (yyn == 0 || yyn == YYTABLE_NINF)
2986 /* Count tokens shifted since error; after three, turn off error
2991 /* Shift the look-ahead token. */
2992 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2994 /* Discard the shifted token unless it is eof. */
2995 if (yychar != YYEOF)
3004 /*-----------------------------------------------------------.
3005 | yydefault -- do the default action for the current state. |
3006 `-----------------------------------------------------------*/
3008 yyn = yydefact[yystate];
3014 /*-----------------------------.
3015 | yyreduce -- Do a reduction. |
3016 `-----------------------------*/
3018 /* yyn is the number of a rule to reduce with. */
3021 /* If YYLEN is nonzero, implement the default value of the action:
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];
3032 YY_REDUCE_PRINT (yyn);
3036 #line 649 "bfin-parse.y"
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;
3044 return INSN_GENERATED;
3049 #line 663 "bfin-parse.y"
3051 if (((yyvsp[(1) - (6)].instr)->value & 0xf800) == 0xc000)
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));
3058 return yyerror ("Wrong 16 bit instructions groups, slot 2 and slot 3 must be 16-bit instrution group");
3060 else if (((yyvsp[(3) - (6)].instr)->value & 0xf800) == 0xc000)
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));
3067 return yyerror ("Wrong 16 bit instructions groups, slot 1 and slot 3 must be 16-bit instrution group");
3069 else if (((yyvsp[(5) - (6)].instr)->value & 0xf800) == 0xc000)
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));
3076 return yyerror ("Wrong 16 bit instructions groups, slot 1 and slot 2 must be 16-bit instrution group");
3079 error ("\nIllegal Multi Issue Construct, at least any one of the slot must be DSP32 instruction group\n");
3084 #line 696 "bfin-parse.y"
3086 if (((yyvsp[(1) - (4)].instr)->value & 0xf800) == 0xc000)
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));
3093 return yyerror ("Wrong 16 bit instructions groups, slot 2 must be the 16-bit instruction group");
3095 else if (((yyvsp[(3) - (4)].instr)->value & 0xf800) == 0xc000)
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));
3102 return yyerror ("Wrong 16 bit instructions groups, slot 1 must be the 16-bit instruction group");
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));
3109 return yyerror ("Wrong 16 bit instructions groups, slot 1 and slot 2 must be the 16-bit instruction group");
3114 #line 723 "bfin-parse.y"
3123 #line 734 "bfin-parse.y"
3125 (yyval.instr) = DSP32MAC (3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0);
3130 #line 738 "bfin-parse.y"
3134 int h00, h10, h01, h11;
3136 if (check_macfunc_option (&(yyvsp[(1) - (2)].macfunc), &(yyvsp[(2) - (2)].mod)) < 0)
3137 return yyerror ("bad option");
3139 if ((yyvsp[(1) - (2)].macfunc).n == 0)
3141 if ((yyvsp[(2) - (2)].mod).MM)
3142 return yyerror ("(m) not allowed with a0 unit");
3144 op0 = (yyvsp[(1) - (2)].macfunc).op;
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);
3153 op1 = (yyvsp[(1) - (2)].macfunc).op;
3155 w1 = (yyvsp[(1) - (2)].macfunc).w;
3158 h01 = IS_H ((yyvsp[(1) - (2)].macfunc).s0);
3159 h11 = IS_H ((yyvsp[(1) - (2)].macfunc).s1);
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);
3167 #line 776 "bfin-parse.y"
3171 if (check_macfuncs (&(yyvsp[(1) - (5)].macfunc), &(yyvsp[(2) - (5)].mod), &(yyvsp[(4) - (5)].macfunc), &(yyvsp[(5) - (5)].mod)) < 0)
3173 notethat ("assign_macfunc (.), assign_macfunc (.)\n");
3175 if ((yyvsp[(1) - (5)].macfunc).w)
3176 dst = &(yyvsp[(1) - (5)].macfunc).dst;
3178 dst = &(yyvsp[(4) - (5)].macfunc).dst;
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);
3187 #line 796 "bfin-parse.y"
3189 notethat ("dsp32alu: DISALGNEXCPT\n");
3190 (yyval.instr) = DSP32ALU (18, 0, 0, 0, 0, 0, 0, 0, 3);
3195 #line 801 "bfin-parse.y"
3197 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && !IS_A1 ((yyvsp[(4) - (6)].reg)) && IS_A1 ((yyvsp[(5) - (6)].reg)))
3199 notethat ("dsp32alu: dregs = ( A0 += A1 )\n");
3200 (yyval.instr) = DSP32ALU (11, 0, 0, &(yyvsp[(1) - (6)].reg), ®7, ®7, 0, 0, 0);
3203 return yyerror ("Register mismatch");
3208 #line 811 "bfin-parse.y"
3210 if (!IS_A1 ((yyvsp[(4) - (6)].reg)) && IS_A1 ((yyvsp[(5) - (6)].reg)))
3212 notethat ("dsp32alu: dregs_half = ( A0 += A1 )\n");
3213 (yyval.instr) = DSP32ALU (11, IS_H ((yyvsp[(1) - (6)].reg)), 0, &(yyvsp[(1) - (6)].reg), ®7, ®7, 0, 0, 1);
3216 return yyerror ("Register mismatch");
3221 #line 821 "bfin-parse.y"
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);
3229 #line 826 "bfin-parse.y"
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);
3237 #line 832 "bfin-parse.y"
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");
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);
3256 #line 850 "bfin-parse.y"
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");
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);
3275 #line 867 "bfin-parse.y"
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");
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);
3292 #line 881 "bfin-parse.y"
3294 if (REG_SAME ((yyvsp[(2) - (11)].reg), (yyvsp[(4) - (11)].reg)))
3295 return yyerror ("Illegal dest register combination");
3297 if (IS_DREG ((yyvsp[(2) - (11)].reg)) && IS_DREG ((yyvsp[(4) - (11)].reg)) && IS_DREG ((yyvsp[(8) - (11)].reg)))
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);
3303 return yyerror ("Register mismatch");
3308 #line 895 "bfin-parse.y"
3310 if (REG_SAME ((yyvsp[(1) - (11)].reg), (yyvsp[(7) - (11)].reg)))
3311 return yyerror ("Illegal dest register combination");
3313 if (IS_DREG ((yyvsp[(1) - (11)].reg)) && IS_DREG ((yyvsp[(7) - (11)].reg)))
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), ®7, ®7, 0, 0, 1);
3319 return yyerror ("Register mismatch");
3324 #line 910 "bfin-parse.y"
3326 if (REG_SAME ((yyvsp[(1) - (12)].reg), (yyvsp[(7) - (12)].reg)))
3327 return yyerror ("Resource conflict in dest reg");
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)))
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), ®7, ®7, (yyvsp[(12) - (12)].modcodes).s0, (yyvsp[(12) - (12)].modcodes).x0, 0);
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)))
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), ®7, ®7, (yyvsp[(12) - (12)].modcodes).s0, (yyvsp[(12) - (12)].modcodes).x0, 1);
3343 return yyerror ("Register mismatch");
3348 #line 932 "bfin-parse.y"
3350 if ((yyvsp[(4) - (12)].r0).r0 == (yyvsp[(10) - (12)].r0).r0)
3351 return yyerror ("Operators must differ");
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)))
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);
3361 return yyerror ("Register mismatch");
3366 #line 950 "bfin-parse.y"
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");
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");
3374 if (REG_SAME ((yyvsp[(1) - (12)].reg), (yyvsp[(7) - (12)].reg)))
3375 return yyerror ("Resource conflict in dest reg");
3377 if ((yyvsp[(4) - (12)].r0).r0 == 1 && (yyvsp[(10) - (12)].r0).r0 == 2)
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);
3382 else if ((yyvsp[(4) - (12)].r0).r0 == 0 && (yyvsp[(10) - (12)].r0).r0 == 3)
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);
3388 return yyerror ("Bar operand mismatch");
3393 #line 975 "bfin-parse.y"
3397 if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(4) - (5)].reg)))
3399 if ((yyvsp[(5) - (5)].r0).r0)
3401 notethat ("dsp32alu: dregs = ABS dregs (v)\n");
3406 /* Vector version of ABS. */
3407 notethat ("dsp32alu: dregs = ABS dregs\n");
3410 (yyval.instr) = DSP32ALU (op, 0, 0, &(yyvsp[(1) - (5)].reg), &(yyvsp[(4) - (5)].reg), 0, 0, 0, 2);
3413 return yyerror ("Dregs expected");
3418 #line 997 "bfin-parse.y"
3420 notethat ("dsp32alu: Ax = ABS Ax\n");
3421 (yyval.instr) = DSP32ALU (16, IS_A1 ((yyvsp[(1) - (3)].reg)), 0, 0, ®7, ®7, 0, 0, IS_A1 ((yyvsp[(3) - (3)].reg)));
3426 #line 1002 "bfin-parse.y"
3428 if (IS_DREG_L ((yyvsp[(3) - (3)].reg)))
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);
3434 return yyerror ("A0.l = Rx.l expected");
3439 #line 1012 "bfin-parse.y"
3441 if (IS_DREG_L ((yyvsp[(3) - (3)].reg)))
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);
3447 return yyerror ("A1.l = Rx.l expected");
3452 #line 1023 "bfin-parse.y"
3454 if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
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);
3460 return yyerror ("Dregs expected");
3465 #line 1034 "bfin-parse.y"
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");
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);
3482 #line 1048 "bfin-parse.y"
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");
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);
3499 #line 1064 "bfin-parse.y"
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");
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);
3516 #line 1080 "bfin-parse.y"
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");
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);
3533 #line 1095 "bfin-parse.y"
3535 if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
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);
3541 return yyerror ("Dregs expected");
3546 #line 1107 "bfin-parse.y"
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)))
3550 notethat ("dsp32alu: dregs_hi = dregs_lo ="
3551 "SIGN (dregs_hi) * dregs_hi + "
3552 "SIGN (dregs_lo) * dregs_lo \n");
3554 (yyval.instr) = DSP32ALU (12, 0, 0, &(yyvsp[(1) - (17)].reg), &(yyvsp[(7) - (17)].reg), &(yyvsp[(10) - (17)].reg), 0, 0, 0);
3557 return yyerror ("Dregs expected");
3562 #line 1120 "bfin-parse.y"
3564 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
3566 if ((yyvsp[(6) - (6)].modcodes).aop == 0)
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);
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);
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)
3582 notethat ("COMP3op: pregs = pregs + pregs\n");
3583 (yyval.instr) = COMP3OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(5) - (6)].reg), 5);
3586 return yyerror ("Dregs expected");
3591 #line 1146 "bfin-parse.y"
3595 if (IS_DREG ((yyvsp[(1) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && IS_DREG ((yyvsp[(7) - (9)].reg)))
3597 if ((yyvsp[(9) - (9)].r0).r0)
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);
3606 return yyerror ("Dregs expected");
3611 #line 1164 "bfin-parse.y"
3613 notethat ("dsp32alu: Ax = - Ax\n");
3614 (yyval.instr) = DSP32ALU (14, IS_A1 ((yyvsp[(1) - (3)].reg)), 0, 0, ®7, ®7, 0, 0, IS_A1 ((yyvsp[(3) - (3)].reg)));
3619 #line 1169 "bfin-parse.y"
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)));
3628 #line 1175 "bfin-parse.y"
3630 if (EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 0 && !REG_SAME ((yyvsp[(1) - (3)].reg), (yyvsp[(2) - (3)].reg)))
3632 notethat ("dsp32alu: A1 = A0 = 0\n");
3633 (yyval.instr) = DSP32ALU (8, 0, 0, 0, ®7, ®7, 0, 0, 2);
3636 return yyerror ("Bad value, 0 expected");
3641 #line 1187 "bfin-parse.y"
3643 if (REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(2) - (5)].reg)))
3645 notethat ("dsp32alu: Ax = Ax (S)\n");
3646 (yyval.instr) = DSP32ALU (8, 0, 0, 0, ®7, ®7, 1, 0, IS_A1 ((yyvsp[(1) - (5)].reg)));
3649 return yyerror ("Registers must be equal");
3654 #line 1198 "bfin-parse.y"
3656 if (IS_DREG ((yyvsp[(3) - (6)].reg)))
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);
3662 return yyerror ("Dregs expected");
3667 #line 1209 "bfin-parse.y"
3669 if (IS_DREG ((yyvsp[(3) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)))
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);
3675 return yyerror ("Dregs expected");
3680 #line 1220 "bfin-parse.y"
3682 if (IS_DREG ((yyvsp[(3) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)))
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);
3688 return yyerror ("Dregs expected");
3693 #line 1231 "bfin-parse.y"
3695 if (!REG_SAME ((yyvsp[(1) - (2)].reg), (yyvsp[(2) - (2)].reg)))
3697 notethat ("dsp32alu: An = Am\n");
3698 (yyval.instr) = DSP32ALU (8, 0, 0, 0, ®7, ®7, IS_A1 ((yyvsp[(1) - (2)].reg)), 0, 3);
3701 return yyerror ("Accu reg arguments must differ");
3706 #line 1242 "bfin-parse.y"
3708 if (IS_DREG ((yyvsp[(2) - (2)].reg)))
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);
3714 return yyerror ("Dregs expected");
3719 #line 1253 "bfin-parse.y"
3721 if (!IS_H ((yyvsp[(3) - (4)].reg)))
3723 if ((yyvsp[(1) - (4)].reg).regno == REG_A0x && IS_DREG ((yyvsp[(3) - (4)].reg)))
3725 notethat ("dsp32alu: A0.x = dregs_lo\n");
3726 (yyval.instr) = DSP32ALU (9, 0, 0, 0, &(yyvsp[(3) - (4)].reg), 0, 0, 0, 1);
3728 else if ((yyvsp[(1) - (4)].reg).regno == REG_A1x && IS_DREG ((yyvsp[(3) - (4)].reg)))
3730 notethat ("dsp32alu: A1.x = dregs_lo\n");
3731 (yyval.instr) = DSP32ALU (9, 0, 0, 0, &(yyvsp[(3) - (4)].reg), 0, 0, 0, 3);
3733 else if (IS_DREG ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(3) - (4)].reg)))
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));
3739 return yyerror ("Register mismatch");
3742 return yyerror ("Low reg expected");
3747 #line 1279 "bfin-parse.y"
3749 notethat ("LDIMMhalf: pregs_half = imm16\n");
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");
3755 if (!IS_IMM ((yyvsp[(3) - (3)].expr), 16) && !IS_UIMM ((yyvsp[(3) - (3)].expr), 16))
3756 return yyerror ("Constant out of range");
3758 (yyval.instr) = LDIMMHALF_R (&(yyvsp[(1) - (3)].reg), IS_H ((yyvsp[(1) - (3)].reg)), 0, 0, (yyvsp[(3) - (3)].expr));
3763 #line 1293 "bfin-parse.y"
3765 notethat ("dsp32alu: An = 0\n");
3767 if (imm7 ((yyvsp[(2) - (2)].expr)) != 0)
3768 return yyerror ("0 expected");
3770 (yyval.instr) = DSP32ALU (8, 0, 0, 0, 0, 0, 0, 0, IS_A1 ((yyvsp[(1) - (2)].reg)));
3775 #line 1303 "bfin-parse.y"
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");
3781 if ((yyvsp[(4) - (4)].r0).r0 == 0)
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)))
3788 notethat ("COMPI2opD: dregs = imm7 (x) \n");
3789 (yyval.instr) = COMPI2OPD (&(yyvsp[(1) - (4)].reg), imm7 ((yyvsp[(3) - (4)].expr)), 0);
3791 else if (IS_CONST ((yyvsp[(3) - (4)].expr)) && IS_IMM ((yyvsp[(3) - (4)].expr), 7) && IS_PREG ((yyvsp[(1) - (4)].reg)))
3793 notethat ("COMPI2opP: pregs = imm7 (x)\n");
3794 (yyval.instr) = COMPI2OPP (&(yyvsp[(1) - (4)].reg), imm7 ((yyvsp[(3) - (4)].expr)), 0);
3798 if (IS_CONST ((yyvsp[(3) - (4)].expr)) && !IS_IMM ((yyvsp[(3) - (4)].expr), 16))
3799 return yyerror ("Immediate value out of range");
3801 notethat ("LDIMMhalf: regs = luimm16 (x)\n");
3803 (yyval.instr) = LDIMMHALF_R5 (&(yyvsp[(1) - (4)].reg), 0, 1, 0, (yyvsp[(3) - (4)].expr));
3808 /* (z) There is no 7 bit zero extended instruction.
3809 If the expr is a relocation, generate it. */
3811 if (IS_CONST ((yyvsp[(3) - (4)].expr)) && !IS_UIMM ((yyvsp[(3) - (4)].expr), 16))
3812 return yyerror ("Immediate value out of range");
3814 notethat ("LDIMMhalf: regs = luimm16 (x)\n");
3816 (yyval.instr) = LDIMMHALF_R5 (&(yyvsp[(1) - (4)].reg), 0, 0, 1, (yyvsp[(3) - (4)].expr));
3822 #line 1348 "bfin-parse.y"
3824 if (IS_H ((yyvsp[(1) - (3)].reg)))
3825 return yyerror ("Low reg expected");
3827 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && (yyvsp[(3) - (3)].reg).regno == REG_A0x)
3829 notethat ("dsp32alu: dregs_lo = A0.x\n");
3830 (yyval.instr) = DSP32ALU (10, 0, 0, &(yyvsp[(1) - (3)].reg), ®7, ®7, 0, 0, 0);
3832 else if (IS_DREG ((yyvsp[(1) - (3)].reg)) && (yyvsp[(3) - (3)].reg).regno == REG_A1x)
3834 notethat ("dsp32alu: dregs_lo = A1.x\n");
3835 (yyval.instr) = DSP32ALU (10, 0, 0, &(yyvsp[(1) - (3)].reg), ®7, ®7, 0, 0, 1);
3838 return yyerror ("Register mismatch");
3843 #line 1367 "bfin-parse.y"
3845 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_DREG ((yyvsp[(5) - (6)].reg)))
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);
3851 return yyerror ("Register mismatch");
3856 #line 1378 "bfin-parse.y"
3858 if (IS_DREG ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(3) - (4)].reg)))
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));
3864 return yyerror ("Register mismatch");
3869 #line 1389 "bfin-parse.y"
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)))
3873 notethat ("dsp32alu: A1 = ABS A1 , A0 = ABS A0\n");
3874 (yyval.instr) = DSP32ALU (16, 0, 0, 0, ®7, ®7, 0, 0, 3);
3877 return yyerror ("Register mismatch");
3882 #line 1400 "bfin-parse.y"
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)))
3886 notethat ("dsp32alu: A1 = - A1 , A0 = - A0\n");
3887 (yyval.instr) = DSP32ALU (14, 0, 0, 0, ®7, ®7, 0, 0, 3);
3890 return yyerror ("Register mismatch");
3895 #line 1411 "bfin-parse.y"
3897 if (!IS_A1 ((yyvsp[(1) - (3)].reg)) && IS_A1 ((yyvsp[(2) - (3)].reg)))
3899 notethat ("dsp32alu: A0 -= A1\n");
3900 (yyval.instr) = DSP32ALU (11, 0, 0, 0, ®7, ®7, (yyvsp[(3) - (3)].r0).r0, 0, 3);
3903 return yyerror ("Register mismatch");
3908 #line 1422 "bfin-parse.y"
3910 if (IS_IREG ((yyvsp[(1) - (3)].reg)) && EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 4)
3912 notethat ("dagMODik: iregs -= 4\n");
3913 (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 3);
3915 else if (IS_IREG ((yyvsp[(1) - (3)].reg)) && EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 2)
3917 notethat ("dagMODik: iregs -= 2\n");
3918 (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 1);
3921 return yyerror ("Register or value mismatch");
3926 #line 1438 "bfin-parse.y"
3928 if (IS_IREG ((yyvsp[(1) - (6)].reg)) && IS_MREG ((yyvsp[(3) - (6)].reg)))
3930 notethat ("dagMODim: iregs += mregs (opt_brev)\n");
3932 (yyval.instr) = DAGMODIM (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 0, 1);
3934 else if (IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)))
3936 notethat ("PTR2op: pregs += pregs (BREV )\n");
3937 (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 5);
3940 return yyerror ("Register mismatch");
3945 #line 1455 "bfin-parse.y"
3947 if (IS_IREG ((yyvsp[(1) - (3)].reg)) && IS_MREG ((yyvsp[(3) - (3)].reg)))
3949 notethat ("dagMODim: iregs -= mregs\n");
3950 (yyval.instr) = DAGMODIM (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 1, 0);
3952 else if (IS_PREG ((yyvsp[(1) - (3)].reg)) && IS_PREG ((yyvsp[(3) - (3)].reg)))
3954 notethat ("PTR2op: pregs -= pregs\n");
3955 (yyval.instr) = PTR2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 0);
3958 return yyerror ("Register mismatch");
3963 #line 1471 "bfin-parse.y"
3965 if (!IS_A1 ((yyvsp[(1) - (4)].reg)) && IS_A1 ((yyvsp[(3) - (4)].reg)))
3967 notethat ("dsp32alu: A0 += A1 (W32)\n");
3968 (yyval.instr) = DSP32ALU (11, 0, 0, 0, ®7, ®7, (yyvsp[(4) - (4)].r0).r0, 0, 2);
3971 return yyerror ("Register mismatch");
3976 #line 1482 "bfin-parse.y"
3978 if (IS_IREG ((yyvsp[(1) - (3)].reg)) && IS_MREG ((yyvsp[(3) - (3)].reg)))
3980 notethat ("dagMODim: iregs += mregs\n");
3981 (yyval.instr) = DAGMODIM (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 0, 0);
3984 return yyerror ("iregs += mregs expected");
3989 #line 1493 "bfin-parse.y"
3991 if (IS_IREG ((yyvsp[(1) - (3)].reg)))
3993 if (EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 4)
3995 notethat ("dagMODik: iregs += 4\n");
3996 (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 2);
3998 else if (EXPR_VALUE ((yyvsp[(3) - (3)].expr)) == 2)
4000 notethat ("dagMODik: iregs += 2\n");
4001 (yyval.instr) = DAGMODIK (&(yyvsp[(1) - (3)].reg), 0);
4004 return yyerror ("iregs += [ 2 | 4 ");
4006 else if (IS_PREG ((yyvsp[(1) - (3)].reg)) && IS_IMM ((yyvsp[(3) - (3)].expr), 7))
4008 notethat ("COMPI2opP: pregs += imm7\n");
4009 (yyval.instr) = COMPI2OPP (&(yyvsp[(1) - (3)].reg), imm7 ((yyvsp[(3) - (3)].expr)), 1);
4011 else if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_IMM ((yyvsp[(3) - (3)].expr), 7))
4013 notethat ("COMPI2opD: dregs += imm7\n");
4014 (yyval.instr) = COMPI2OPD (&(yyvsp[(1) - (3)].reg), imm7 ((yyvsp[(3) - (3)].expr)), 1);
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");
4019 return yyerror ("Register mismatch");
4024 #line 1526 "bfin-parse.y"
4026 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
4028 notethat ("ALU2op: dregs *= dregs\n");
4029 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 3);
4032 return yyerror ("Register mismatch");
4037 #line 1537 "bfin-parse.y"
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");
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);
4052 #line 1550 "bfin-parse.y"
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)))
4056 notethat ("dsp32alu: A1 = A1 (S) , A0 = A0 (S)\n");
4057 (yyval.instr) = DSP32ALU (8, 0, 0, 0, ®7, ®7, 1, 0, 2);
4060 return yyerror ("Register mismatch");
4065 #line 1561 "bfin-parse.y"
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)))
4070 if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 1)
4072 notethat ("ALU2op: dregs = (dregs + dregs) << 1\n");
4073 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 4);
4075 else if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 2)
4077 notethat ("ALU2op: dregs = (dregs + dregs) << 2\n");
4078 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 5);
4081 return yyerror ("Bad shift value");
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)))
4086 if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 1)
4088 notethat ("PTR2op: pregs = (pregs + pregs) << 1\n");
4089 (yyval.instr) = PTR2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 6);
4091 else if (EXPR_VALUE ((yyvsp[(9) - (9)].expr)) == 2)
4093 notethat ("PTR2op: pregs = (pregs + pregs) << 2\n");
4094 (yyval.instr) = PTR2OP (&(yyvsp[(1) - (9)].reg), &(yyvsp[(6) - (9)].reg), 7);
4097 return yyerror ("Bad shift value");
4100 return yyerror ("Register mismatch");
4105 #line 1600 "bfin-parse.y"
4107 if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(3) - (5)].reg)) && IS_DREG ((yyvsp[(5) - (5)].reg)))
4109 notethat ("COMP3op: dregs = dregs | dregs\n");
4110 (yyval.instr) = COMP3OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(3) - (5)].reg), &(yyvsp[(5) - (5)].reg), 3);
4113 return yyerror ("Dregs expected");
4118 #line 1610 "bfin-parse.y"
4120 if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(3) - (5)].reg)) && IS_DREG ((yyvsp[(5) - (5)].reg)))
4122 notethat ("COMP3op: dregs = dregs ^ dregs\n");
4123 (yyval.instr) = COMP3OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(3) - (5)].reg), &(yyvsp[(5) - (5)].reg), 4);
4126 return yyerror ("Dregs expected");
4131 #line 1620 "bfin-parse.y"
4133 if (IS_PREG ((yyvsp[(1) - (9)].reg)) && IS_PREG ((yyvsp[(3) - (9)].reg)) && IS_PREG ((yyvsp[(6) - (9)].reg)))
4135 if (EXPR_VALUE ((yyvsp[(8) - (9)].expr)) == 1)
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);
4140 else if (EXPR_VALUE ((yyvsp[(8) - (9)].expr)) == 2)
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);
4146 return yyerror ("Bad shift value");
4149 return yyerror ("Dregs expected");
4154 #line 1640 "bfin-parse.y"
4156 if ((yyvsp[(3) - (5)].reg).regno == REG_A0 && (yyvsp[(5) - (5)].reg).regno == REG_A1)
4158 notethat ("CCflag: CC = A0 == A1\n");
4159 (yyval.instr) = CCFLAG (0, 0, 5, 0, 0);
4162 return yyerror ("AREGs are in bad order or same");
4167 #line 1650 "bfin-parse.y"
4169 if ((yyvsp[(3) - (5)].reg).regno == REG_A0 && (yyvsp[(5) - (5)].reg).regno == REG_A1)
4171 notethat ("CCflag: CC = A0 < A1\n");
4172 (yyval.instr) = CCFLAG (0, 0, 6, 0, 0);
4175 return yyerror ("AREGs are in bad order or same");
4180 #line 1660 "bfin-parse.y"
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))))
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);
4189 return yyerror ("Bad register in comparison");
4194 #line 1671 "bfin-parse.y"
4196 if (!IS_DREG ((yyvsp[(3) - (6)].reg)) && !IS_PREG ((yyvsp[(3) - (6)].reg)))
4197 return yyerror ("Bad register in comparison");
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)))
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);
4206 return yyerror ("Bad constant value");
4211 #line 1685 "bfin-parse.y"
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))))
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);
4220 return yyerror ("Bad register in comparison");
4225 #line 1696 "bfin-parse.y"
4227 if (!IS_DREG ((yyvsp[(3) - (5)].reg)) && !IS_PREG ((yyvsp[(3) - (5)].reg)))
4228 return yyerror ("Bad register in comparison");
4230 if (IS_IMM ((yyvsp[(5) - (5)].expr), 3))
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);
4236 return yyerror ("Bad constant range");
4241 #line 1709 "bfin-parse.y"
4243 if ((yyvsp[(3) - (5)].reg).regno == REG_A0 && (yyvsp[(5) - (5)].reg).regno == REG_A1)
4245 notethat ("CCflag: CC = A0 <= A1\n");
4246 (yyval.instr) = CCFLAG (0, 0, 7, 0, 0);
4249 return yyerror ("AREGs are in bad order or same");
4254 #line 1719 "bfin-parse.y"
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))))
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);
4264 return yyerror ("Bad register in comparison");
4269 #line 1731 "bfin-parse.y"
4271 if (!IS_DREG ((yyvsp[(3) - (6)].reg)) && !IS_PREG ((yyvsp[(3) - (6)].reg)))
4272 return yyerror ("Bad register in comparison");
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)))
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);
4281 return yyerror ("Bad constant value");
4286 #line 1746 "bfin-parse.y"
4288 if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(3) - (5)].reg)) && IS_DREG ((yyvsp[(5) - (5)].reg)))
4290 notethat ("COMP3op: dregs = dregs & dregs\n");
4291 (yyval.instr) = COMP3OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(3) - (5)].reg), &(yyvsp[(5) - (5)].reg), 2);
4294 return yyerror ("Dregs expected");
4299 #line 1757 "bfin-parse.y"
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);
4307 #line 1763 "bfin-parse.y"
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))
4323 (yyval.instr) = bfin_gen_regmv (&(yyvsp[(3) - (3)].reg), &(yyvsp[(1) - (3)].reg));
4326 return yyerror ("Unsupported register move");
4331 #line 1785 "bfin-parse.y"
4333 if (IS_DREG ((yyvsp[(3) - (3)].reg)))
4335 notethat ("CC2dreg: CC = dregs\n");
4336 (yyval.instr) = bfin_gen_cc2dreg (1, &(yyvsp[(3) - (3)].reg));
4339 return yyerror ("Only 'CC = Dreg' supported");
4344 #line 1796 "bfin-parse.y"
4346 if (IS_DREG ((yyvsp[(1) - (3)].reg)))
4348 notethat ("CC2dreg: dregs = CC\n");
4349 (yyval.instr) = bfin_gen_cc2dreg (0, &(yyvsp[(1) - (3)].reg));
4352 return yyerror ("Only 'Dreg = CC' supported");
4357 #line 1807 "bfin-parse.y"
4359 notethat ("CC2dreg: CC =! CC\n");
4360 (yyval.instr) = bfin_gen_cc2dreg (3, 0);
4365 #line 1815 "bfin-parse.y"
4367 notethat ("dsp32mult: dregs_half = multiply_halfregs (opt_mode)\n");
4369 if (!IS_H ((yyvsp[(1) - (4)].reg)) && (yyvsp[(4) - (4)].mod).MM)
4370 return yyerror ("(M) not allowed with MAC0");
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.");
4377 if (IS_H ((yyvsp[(1) - (4)].reg)))
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);
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);
4393 #line 1841 "bfin-parse.y"
4395 /* Odd registers can use (M). */
4396 if (!IS_DREG ((yyvsp[(1) - (4)].reg)))
4397 return yyerror ("Dreg expected");
4399 if (IS_EVEN ((yyvsp[(1) - (4)].reg)) && (yyvsp[(4) - (4)].mod).MM)
4400 return yyerror ("(M) not allowed with MAC0");
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");
4406 if (!IS_EVEN ((yyvsp[(1) - (4)].reg)))
4408 notethat ("dsp32mult: dregs = multiply_halfregs (opt_mode)\n");
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);
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);
4425 #line 1872 "bfin-parse.y"
4427 if (!IS_DREG ((yyvsp[(1) - (9)].reg)) || !IS_DREG ((yyvsp[(6) - (9)].reg)))
4428 return yyerror ("Dregs expected");
4430 if (!IS_HCOMPL((yyvsp[(1) - (9)].reg), (yyvsp[(6) - (9)].reg)))
4431 return yyerror ("Dest registers mismatch");
4433 if (check_multiply_halfregs (&(yyvsp[(3) - (9)].macfunc), &(yyvsp[(8) - (9)].macfunc)) < 0)
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");
4440 notethat ("dsp32mult: dregs_hi = multiply_halfregs mxd_mod, "
4441 "dregs_lo = multiply_halfregs opt_mode\n");
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);
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);
4455 #line 1900 "bfin-parse.y"
4457 if (!IS_DREG ((yyvsp[(1) - (9)].reg)) || !IS_DREG ((yyvsp[(6) - (9)].reg)))
4458 return yyerror ("Dregs expected");
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");
4464 if (check_multiply_halfregs (&(yyvsp[(3) - (9)].macfunc), &(yyvsp[(8) - (9)].macfunc)) < 0)
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");
4471 notethat ("dsp32mult: dregs = multiply_halfregs mxd_mod, "
4472 "dregs = multiply_halfregs opt_mode\n");
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);
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);
4486 #line 1931 "bfin-parse.y"
4488 if (!REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(3) - (5)].reg)))
4489 return yyerror ("Aregs must be same");
4491 if (IS_DREG ((yyvsp[(5) - (5)].reg)) && !IS_H ((yyvsp[(5) - (5)].reg)))
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)));
4497 return yyerror ("Dregs expected");
4502 #line 1945 "bfin-parse.y"
4504 if (IS_DREG ((yyvsp[(6) - (7)].reg)) && !IS_H ((yyvsp[(6) - (7)].reg)))
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)));
4510 return yyerror ("Dregs expected");
4515 #line 1956 "bfin-parse.y"
4517 if (!REG_SAME ((yyvsp[(1) - (4)].reg), (yyvsp[(2) - (4)].reg)))
4518 return yyerror ("Aregs must be same");
4520 if (IS_UIMM ((yyvsp[(4) - (4)].expr), 5))
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)));
4526 return yyerror ("Bad shift value");
4531 #line 1970 "bfin-parse.y"
4533 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
4535 if ((yyvsp[(6) - (6)].modcodes).r0)
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);
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);
4547 else if ((yyvsp[(6) - (6)].modcodes).s0 == 0 && IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)))
4549 if (EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 2)
4551 notethat ("PTR2op: pregs = pregs << 2\n");
4552 (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 1);
4554 else if (EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 1)
4556 notethat ("COMP3op: pregs = pregs << 1\n");
4557 (yyval.instr) = COMP3OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), &(yyvsp[(3) - (6)].reg), 5);
4560 return yyerror ("Bad shift value");
4563 return yyerror ("Bad shift value or register");
4568 #line 2004 "bfin-parse.y"
4570 if (IS_UIMM ((yyvsp[(5) - (6)].expr), 4))
4572 if ((yyvsp[(6) - (6)].modcodes).s0)
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)));
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)));
4584 return yyerror ("Bad shift value");
4589 #line 2022 "bfin-parse.y"
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)))
4595 if ((yyvsp[(7) - (7)].modcodes).r0)
4598 notethat ("dsp32shift: dregs = ASHIFT dregs BY "
4599 "dregs_lo (V, .)\n");
4605 notethat ("dsp32shift: dregs = ASHIFT dregs BY dregs_lo (.)\n");
4607 (yyval.instr) = DSP32SHIFT (op, &(yyvsp[(1) - (7)].reg), &(yyvsp[(6) - (7)].reg), &(yyvsp[(4) - (7)].reg), (yyvsp[(7) - (7)].modcodes).s0, 0);
4610 return yyerror ("Dregs expected");
4615 #line 2047 "bfin-parse.y"
4617 if (IS_DREG_L ((yyvsp[(1) - (9)].reg)) && IS_DREG_L ((yyvsp[(5) - (9)].reg)) && IS_DREG_L ((yyvsp[(7) - (9)].reg)))
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);
4623 return yyerror ("Bad shift value or register");
4628 #line 2059 "bfin-parse.y"
4630 if (IS_DREG_L ((yyvsp[(1) - (8)].reg)) && IS_DREG_L ((yyvsp[(5) - (8)].reg)) && IS_DREG_L ((yyvsp[(7) - (8)].reg)))
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);
4635 else if (IS_DREG_L ((yyvsp[(1) - (8)].reg)) && IS_DREG_H ((yyvsp[(5) - (8)].reg)) && IS_DREG_L ((yyvsp[(7) - (8)].reg)))
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);
4641 return yyerror ("Bad shift value or register");
4646 #line 2077 "bfin-parse.y"
4648 if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
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);
4654 return yyerror ("Register mismatch");
4659 #line 2088 "bfin-parse.y"
4661 if (IS_DREG ((yyvsp[(1) - (11)].reg)) && IS_DREG ((yyvsp[(5) - (11)].reg)) && IS_DREG ((yyvsp[(7) - (11)].reg)))
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);
4667 return yyerror ("Register mismatch");
4672 #line 2099 "bfin-parse.y"
4674 if (IS_DREG ((yyvsp[(1) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && IS_DREG_L ((yyvsp[(7) - (9)].reg)))
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);
4680 return yyerror ("Register mismatch");
4685 #line 2110 "bfin-parse.y"
4687 if (!REG_SAME ((yyvsp[(1) - (4)].reg), (yyvsp[(2) - (4)].reg)))
4688 return yyerror ("Aregs must be same");
4690 if (IS_UIMM ((yyvsp[(4) - (4)].expr), 5))
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)));
4696 return yyerror ("Shift value range error");
4701 #line 2123 "bfin-parse.y"
4703 if (REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(3) - (5)].reg)) && IS_DREG_L ((yyvsp[(5) - (5)].reg)))
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)));
4709 return yyerror ("Register mismatch");
4714 #line 2134 "bfin-parse.y"
4716 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_DREG_L ((yyvsp[(6) - (6)].reg)))
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)));
4722 return yyerror ("Register mismatch");
4727 #line 2145 "bfin-parse.y"
4729 if (IS_DREG ((yyvsp[(1) - (7)].reg)) && IS_DREG ((yyvsp[(4) - (7)].reg)) && IS_DREG_L ((yyvsp[(6) - (7)].reg)))
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);
4735 return yyerror ("Register mismatch");
4740 #line 2156 "bfin-parse.y"
4742 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_DREG_L ((yyvsp[(6) - (6)].reg)))
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);
4748 return yyerror ("Register mismatch");
4753 #line 2167 "bfin-parse.y"
4755 if (REG_SAME ((yyvsp[(1) - (4)].reg), (yyvsp[(2) - (4)].reg)) && IS_IMM ((yyvsp[(4) - (4)].expr), 6) >= 0)
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)));
4761 return yyerror ("Accu register expected");
4766 #line 2178 "bfin-parse.y"
4768 if ((yyvsp[(6) - (6)].r0).r0 == 1)
4770 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
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);
4776 return yyerror ("Register mismatch");
4780 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
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);
4785 else if (IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)) && EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 2)
4787 notethat ("PTR2op: pregs = pregs >> 2\n");
4788 (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 3);
4790 else if (IS_PREG ((yyvsp[(1) - (6)].reg)) && IS_PREG ((yyvsp[(3) - (6)].reg)) && EXPR_VALUE ((yyvsp[(5) - (6)].expr)) == 1)
4792 notethat ("PTR2op: pregs = pregs >> 1\n");
4793 (yyval.instr) = PTR2OP (&(yyvsp[(1) - (6)].reg), &(yyvsp[(3) - (6)].reg), 4);
4796 return yyerror ("Register mismatch");
4802 #line 2211 "bfin-parse.y"
4804 if (IS_UIMM ((yyvsp[(5) - (5)].expr), 5))
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)));
4810 return yyerror ("Register mismatch");
4815 #line 2221 "bfin-parse.y"
4817 if (IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
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)));
4824 return yyerror ("Register or modifier mismatch");
4829 #line 2234 "bfin-parse.y"
4831 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
4833 if ((yyvsp[(6) - (6)].modcodes).r0)
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);
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);
4846 return yyerror ("Register mismatch");
4851 #line 2254 "bfin-parse.y"
4853 if (IS_DREG_L ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(4) - (4)].reg)))
4855 notethat ("dsp32shift: dregs_lo = ONES dregs\n");
4856 (yyval.instr) = DSP32SHIFT (6, &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(4) - (4)].reg), 3, 0);
4859 return yyerror ("Register mismatch");
4864 #line 2265 "bfin-parse.y"
4866 if (IS_DREG ((yyvsp[(1) - (8)].reg)) && IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_DREG ((yyvsp[(7) - (8)].reg)))
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);
4872 return yyerror ("Register mismatch");
4877 #line 2276 "bfin-parse.y"
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)))
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);
4887 return yyerror ("Register mismatch");
4892 #line 2289 "bfin-parse.y"
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)))
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);
4902 return yyerror ("Register mismatch");
4907 #line 2302 "bfin-parse.y"
4909 if (IS_DREG ((yyvsp[(1) - (12)].reg)) && !IS_H ((yyvsp[(1) - (12)].reg)) && !REG_SAME ((yyvsp[(7) - (12)].reg), (yyvsp[(9) - (12)].reg)))
4911 notethat ("dsp32shift: dregs_lo = CC = BXOR (A0 , A1 , CC)\n");
4912 (yyval.instr) = DSP32SHIFT (12, &(yyvsp[(1) - (12)].reg), 0, 0, 1, 0);
4915 return yyerror ("Register mismatch");
4920 #line 2313 "bfin-parse.y"
4922 if (REG_SAME ((yyvsp[(1) - (5)].reg), (yyvsp[(3) - (5)].reg)) && IS_DREG_L ((yyvsp[(5) - (5)].reg)))
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)));
4928 return yyerror ("Register mismatch");
4933 #line 2324 "bfin-parse.y"
4935 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_DREG_L ((yyvsp[(6) - (6)].reg)))
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);
4941 return yyerror ("Register mismatch");
4946 #line 2335 "bfin-parse.y"
4948 if (IS_IMM ((yyvsp[(5) - (5)].expr), 6))
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)));
4954 return yyerror ("Register mismatch");
4959 #line 2346 "bfin-parse.y"
4961 if (IS_DREG ((yyvsp[(1) - (6)].reg)) && IS_DREG ((yyvsp[(4) - (6)].reg)) && IS_IMM ((yyvsp[(6) - (6)].expr), 6))
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)));
4966 return yyerror ("Register mismatch");
4971 #line 2356 "bfin-parse.y"
4973 if (IS_DREG_L ((yyvsp[(1) - (4)].reg)))
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);
4979 return yyerror ("Register mismatch");
4984 #line 2367 "bfin-parse.y"
4986 if (IS_DREG_L ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(4) - (4)].reg)))
4988 notethat ("dsp32shift: dregs_lo = SIGNBITS dregs\n");
4989 (yyval.instr) = DSP32SHIFT (5, &(yyvsp[(1) - (4)].reg), 0, &(yyvsp[(4) - (4)].reg), 0, 0);
4992 return yyerror ("Register mismatch");
4997 #line 2378 "bfin-parse.y"
4999 if (IS_DREG_L ((yyvsp[(1) - (4)].reg)))
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);
5005 return yyerror ("Register mismatch");
5010 #line 2390 "bfin-parse.y"
5012 if (IS_DREG_L ((yyvsp[(1) - (7)].reg)) && IS_DREG ((yyvsp[(5) - (7)].reg)))
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);
5018 return yyerror ("Register mismatch");
5023 #line 2401 "bfin-parse.y"
5025 if (IS_DREG ((yyvsp[(1) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && IS_DREG ((yyvsp[(7) - (9)].reg)))
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);
5031 return yyerror ("Register mismatch");
5036 #line 2412 "bfin-parse.y"
5038 if (REG_SAME ((yyvsp[(3) - (9)].reg), (yyvsp[(5) - (9)].reg)))
5039 return yyerror ("Illegal source register combination");
5041 if (IS_DREG ((yyvsp[(3) - (9)].reg)) && IS_DREG ((yyvsp[(5) - (9)].reg)) && !IS_A1 ((yyvsp[(7) - (9)].reg)))
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);
5047 return yyerror ("Register mismatch");
5052 #line 2426 "bfin-parse.y"
5054 if (!IS_A1 ((yyvsp[(1) - (9)].reg)) && !IS_A1 ((yyvsp[(4) - (9)].reg)) && IS_A1 ((yyvsp[(6) - (9)].reg)))
5056 notethat ("dsp32shift: A0 = BXORSHIFT (A0 , A1 , CC )\n");
5057 (yyval.instr) = DSP32SHIFT (12, 0, 0, 0, 0, 0);
5060 return yyerror ("Dregs expected");
5065 #line 2439 "bfin-parse.y"
5067 if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
5069 notethat ("LOGI2op: BITCLR (dregs , uimm5 )\n");
5070 (yyval.instr) = LOGI2OP ((yyvsp[(3) - (6)].reg), uimm5 ((yyvsp[(5) - (6)].expr)), 4);
5073 return yyerror ("Register mismatch");
5078 #line 2451 "bfin-parse.y"
5080 if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
5082 notethat ("LOGI2op: BITCLR (dregs , uimm5 )\n");
5083 (yyval.instr) = LOGI2OP ((yyvsp[(3) - (6)].reg), uimm5 ((yyvsp[(5) - (6)].expr)), 2);
5086 return yyerror ("Register mismatch");
5091 #line 2463 "bfin-parse.y"
5093 if (IS_DREG ((yyvsp[(3) - (6)].reg)) && IS_UIMM ((yyvsp[(5) - (6)].expr), 5))
5095 notethat ("LOGI2op: BITCLR (dregs , uimm5 )\n");
5096 (yyval.instr) = LOGI2OP ((yyvsp[(3) - (6)].reg), uimm5 ((yyvsp[(5) - (6)].expr)), 3);
5099 return yyerror ("Register mismatch");
5104 #line 2474 "bfin-parse.y"
5106 if (IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_UIMM ((yyvsp[(7) - (8)].expr), 5))
5108 notethat ("LOGI2op: CC =! BITTST (dregs , uimm5 )\n");
5109 (yyval.instr) = LOGI2OP ((yyvsp[(5) - (8)].reg), uimm5 ((yyvsp[(7) - (8)].expr)), 0);
5112 return yyerror ("Register mismatch or value error");
5117 #line 2485 "bfin-parse.y"
5119 if (IS_DREG ((yyvsp[(5) - (8)].reg)) && IS_UIMM ((yyvsp[(7) - (8)].expr), 5))
5121 notethat ("LOGI2op: CC = BITTST (dregs , uimm5 )\n");
5122 (yyval.instr) = LOGI2OP ((yyvsp[(5) - (8)].reg), uimm5 ((yyvsp[(7) - (8)].expr)), 1);
5125 return yyerror ("Register mismatch or value error");
5130 #line 2496 "bfin-parse.y"
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))))
5135 notethat ("ccMV: IF ! CC gregs = gregs\n");
5136 (yyval.instr) = CCMV (&(yyvsp[(6) - (6)].reg), &(yyvsp[(4) - (6)].reg), 0);
5139 return yyerror ("Register mismatch");
5144 #line 2508 "bfin-parse.y"
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))))
5149 notethat ("ccMV: IF CC gregs = gregs\n");
5150 (yyval.instr) = CCMV (&(yyvsp[(5) - (5)].reg), &(yyvsp[(3) - (5)].reg), 1);
5153 return yyerror ("Register mismatch");
5158 #line 2520 "bfin-parse.y"
5160 if (IS_PCREL10 ((yyvsp[(5) - (5)].expr)))
5162 notethat ("BRCC: IF !CC JUMP pcrel11m2\n");
5163 (yyval.instr) = BRCC (0, 0, (yyvsp[(5) - (5)].expr));
5166 return yyerror ("Bad jump offset");
5171 #line 2531 "bfin-parse.y"
5173 if (IS_PCREL10 ((yyvsp[(5) - (8)].expr)))
5175 notethat ("BRCC: IF !CC JUMP pcrel11m2\n");
5176 (yyval.instr) = BRCC (0, 1, (yyvsp[(5) - (8)].expr));
5179 return yyerror ("Bad jump offset");
5184 #line 2542 "bfin-parse.y"
5186 if (IS_PCREL10 ((yyvsp[(4) - (4)].expr)))
5188 notethat ("BRCC: IF CC JUMP pcrel11m2\n");
5189 (yyval.instr) = BRCC (1, 0, (yyvsp[(4) - (4)].expr));
5192 return yyerror ("Bad jump offset");
5197 #line 2553 "bfin-parse.y"
5199 if (IS_PCREL10 ((yyvsp[(4) - (7)].expr)))
5201 notethat ("BRCC: IF !CC JUMP pcrel11m2\n");
5202 (yyval.instr) = BRCC (1, 1, (yyvsp[(4) - (7)].expr));
5205 return yyerror ("Bad jump offset");
5210 #line 2563 "bfin-parse.y"
5212 notethat ("ProgCtrl: NOP\n");
5213 (yyval.instr) = PROGCTRL (0, 0);
5218 #line 2569 "bfin-parse.y"
5220 notethat ("ProgCtrl: RTS\n");
5221 (yyval.instr) = PROGCTRL (1, 0);
5226 #line 2575 "bfin-parse.y"
5228 notethat ("ProgCtrl: RTI\n");
5229 (yyval.instr) = PROGCTRL (1, 1);
5234 #line 2581 "bfin-parse.y"
5236 notethat ("ProgCtrl: RTX\n");
5237 (yyval.instr) = PROGCTRL (1, 2);
5242 #line 2587 "bfin-parse.y"
5244 notethat ("ProgCtrl: RTN\n");
5245 (yyval.instr) = PROGCTRL (1, 3);
5250 #line 2593 "bfin-parse.y"
5252 notethat ("ProgCtrl: RTE\n");
5253 (yyval.instr) = PROGCTRL (1, 4);
5258 #line 2599 "bfin-parse.y"
5260 notethat ("ProgCtrl: IDLE\n");
5261 (yyval.instr) = PROGCTRL (2, 0);
5266 #line 2605 "bfin-parse.y"
5268 notethat ("ProgCtrl: CSYNC\n");
5269 (yyval.instr) = PROGCTRL (2, 3);
5274 #line 2611 "bfin-parse.y"
5276 notethat ("ProgCtrl: SSYNC\n");
5277 (yyval.instr) = PROGCTRL (2, 4);
5282 #line 2617 "bfin-parse.y"
5284 notethat ("ProgCtrl: EMUEXCPT\n");
5285 (yyval.instr) = PROGCTRL (2, 5);
5290 #line 2623 "bfin-parse.y"
5292 if (IS_DREG ((yyvsp[(2) - (2)].reg)))
5294 notethat ("ProgCtrl: CLI dregs\n");
5295 (yyval.instr) = PROGCTRL (3, (yyvsp[(2) - (2)].reg).regno & CODE_MASK);
5298 return yyerror ("Dreg expected for CLI");
5303 #line 2634 "bfin-parse.y"
5305 if (IS_DREG ((yyvsp[(2) - (2)].reg)))
5307 notethat ("ProgCtrl: STI dregs\n");
5308 (yyval.instr) = PROGCTRL (4, (yyvsp[(2) - (2)].reg).regno & CODE_MASK);
5311 return yyerror ("Dreg expected for STI");
5316 #line 2645 "bfin-parse.y"
5318 if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5320 notethat ("ProgCtrl: JUMP (pregs )\n");
5321 (yyval.instr) = PROGCTRL (5, (yyvsp[(3) - (4)].reg).regno & CODE_MASK);
5324 return yyerror ("Bad register for indirect jump");
5329 #line 2656 "bfin-parse.y"
5331 if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5333 notethat ("ProgCtrl: CALL (pregs )\n");
5334 (yyval.instr) = PROGCTRL (6, (yyvsp[(3) - (4)].reg).regno & CODE_MASK);
5337 return yyerror ("Bad register for indirect call");
5342 #line 2667 "bfin-parse.y"
5344 if (IS_PREG ((yyvsp[(5) - (6)].reg)))
5346 notethat ("ProgCtrl: CALL (PC + pregs )\n");
5347 (yyval.instr) = PROGCTRL (7, (yyvsp[(5) - (6)].reg).regno & CODE_MASK);
5350 return yyerror ("Bad register for indirect call");
5355 #line 2678 "bfin-parse.y"
5357 if (IS_PREG ((yyvsp[(5) - (6)].reg)))
5359 notethat ("ProgCtrl: JUMP (PC + pregs )\n");
5360 (yyval.instr) = PROGCTRL (8, (yyvsp[(5) - (6)].reg).regno & CODE_MASK);
5363 return yyerror ("Bad register for indirect jump");
5368 #line 2689 "bfin-parse.y"
5370 if (IS_UIMM ((yyvsp[(2) - (2)].expr), 4))
5372 notethat ("ProgCtrl: RAISE uimm4\n");
5373 (yyval.instr) = PROGCTRL (9, uimm4 ((yyvsp[(2) - (2)].expr)));
5376 return yyerror ("Bad value for RAISE");
5381 #line 2700 "bfin-parse.y"
5383 notethat ("ProgCtrl: EMUEXCPT\n");
5384 (yyval.instr) = PROGCTRL (10, uimm4 ((yyvsp[(2) - (2)].expr)));
5389 #line 2706 "bfin-parse.y"
5391 if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5393 if ((yyvsp[(3) - (4)].reg).regno == REG_SP || (yyvsp[(3) - (4)].reg).regno == REG_FP)
5394 return yyerror ("Bad register for TESTSET");
5396 notethat ("ProgCtrl: TESTSET (pregs )\n");
5397 (yyval.instr) = PROGCTRL (11, (yyvsp[(3) - (4)].reg).regno & CODE_MASK);
5400 return yyerror ("Preg expected");
5405 #line 2720 "bfin-parse.y"
5407 if (IS_PCREL12 ((yyvsp[(2) - (2)].expr)))
5409 notethat ("UJUMP: JUMP pcrel12\n");
5410 (yyval.instr) = UJUMP ((yyvsp[(2) - (2)].expr));
5413 return yyerror ("Bad value for relative jump");
5418 #line 2731 "bfin-parse.y"
5420 if (IS_PCREL12 ((yyvsp[(2) - (2)].expr)))
5422 notethat ("UJUMP: JUMP_DOT_S pcrel12\n");
5423 (yyval.instr) = UJUMP((yyvsp[(2) - (2)].expr));
5426 return yyerror ("Bad value for relative jump");
5431 #line 2742 "bfin-parse.y"
5433 if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5435 notethat ("CALLa: jump.l pcrel24\n");
5436 (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 0);
5439 return yyerror ("Bad value for long jump");
5444 #line 2753 "bfin-parse.y"
5446 if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5448 notethat ("CALLa: jump.l pcrel24\n");
5449 (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 2);
5452 return yyerror ("Bad value for long jump");
5457 #line 2764 "bfin-parse.y"
5459 if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5461 notethat ("CALLa: CALL pcrel25m2\n");
5462 (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 1);
5465 return yyerror ("Bad call address");
5470 #line 2774 "bfin-parse.y"
5472 if (IS_PCREL24 ((yyvsp[(2) - (2)].expr)))
5474 notethat ("CALLa: CALL pcrel25m2\n");
5475 (yyval.instr) = CALLA ((yyvsp[(2) - (2)].expr), 2);
5478 return yyerror ("Bad call address");
5483 #line 2787 "bfin-parse.y"
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);
5488 return yyerror ("Bad registers for DIVQ");
5493 #line 2795 "bfin-parse.y"
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);
5498 return yyerror ("Bad registers for DIVS");
5503 #line 2803 "bfin-parse.y"
5505 if (IS_DREG ((yyvsp[(1) - (5)].reg)) && IS_DREG ((yyvsp[(4) - (5)].reg)))
5507 if ((yyvsp[(5) - (5)].modcodes).r0 == 0 && (yyvsp[(5) - (5)].modcodes).s0 == 0 && (yyvsp[(5) - (5)].modcodes).aop == 0)
5509 notethat ("ALU2op: dregs = - dregs\n");
5510 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (5)].reg), &(yyvsp[(4) - (5)].reg), 14);
5512 else if ((yyvsp[(5) - (5)].modcodes).r0 == 1 && (yyvsp[(5) - (5)].modcodes).s0 == 0 && (yyvsp[(5) - (5)].modcodes).aop == 3)
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);
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);
5524 return yyerror ("Dregs expected");
5529 #line 2827 "bfin-parse.y"
5531 if (IS_DREG ((yyvsp[(1) - (4)].reg)) && IS_DREG ((yyvsp[(4) - (4)].reg)))
5533 notethat ("ALU2op: dregs = ~dregs\n");
5534 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (4)].reg), &(yyvsp[(4) - (4)].reg), 15);
5537 return yyerror ("Dregs expected");
5542 #line 2838 "bfin-parse.y"
5544 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
5546 notethat ("ALU2op: dregs >>= dregs\n");
5547 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 1);
5550 return yyerror ("Dregs expected");
5555 #line 2849 "bfin-parse.y"
5557 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_UIMM ((yyvsp[(3) - (3)].expr), 5))
5559 notethat ("LOGI2op: dregs >>= uimm5\n");
5560 (yyval.instr) = LOGI2OP ((yyvsp[(1) - (3)].reg), uimm5 ((yyvsp[(3) - (3)].expr)), 6);
5563 return yyerror ("Dregs expected or value error");
5568 #line 2860 "bfin-parse.y"
5570 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
5572 notethat ("ALU2op: dregs >>>= dregs\n");
5573 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 0);
5576 return yyerror ("Dregs expected");
5581 #line 2871 "bfin-parse.y"
5583 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
5585 notethat ("ALU2op: dregs <<= dregs\n");
5586 (yyval.instr) = ALU2OP (&(yyvsp[(1) - (3)].reg), &(yyvsp[(3) - (3)].reg), 2);
5589 return yyerror ("Dregs expected");
5594 #line 2882 "bfin-parse.y"
5596 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_UIMM ((yyvsp[(3) - (3)].expr), 5))
5598 notethat ("LOGI2op: dregs <<= uimm5\n");
5599 (yyval.instr) = LOGI2OP ((yyvsp[(1) - (3)].reg), uimm5 ((yyvsp[(3) - (3)].expr)), 7);
5602 return yyerror ("Dregs expected or const value error");
5607 #line 2894 "bfin-parse.y"
5609 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_UIMM ((yyvsp[(3) - (3)].expr), 5))
5611 notethat ("LOGI2op: dregs >>>= uimm5\n");
5612 (yyval.instr) = LOGI2OP ((yyvsp[(1) - (3)].reg), uimm5 ((yyvsp[(3) - (3)].expr)), 5);
5615 return yyerror ("Dregs expected");
5620 #line 2907 "bfin-parse.y"
5622 notethat ("CaCTRL: FLUSH [ pregs ]\n");
5623 if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5624 (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 2);
5626 return yyerror ("Bad register(s) for FLUSH");
5631 #line 2916 "bfin-parse.y"
5633 if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5635 notethat ("CaCTRL: FLUSH [ pregs ++ ]\n");
5636 (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 2);
5639 return yyerror ("Bad register(s) for FLUSH");
5644 #line 2927 "bfin-parse.y"
5646 if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5648 notethat ("CaCTRL: FLUSHINV [ pregs ]\n");
5649 (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 1);
5652 return yyerror ("Bad register(s) for FLUSH");
5657 #line 2938 "bfin-parse.y"
5659 if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5661 notethat ("CaCTRL: FLUSHINV [ pregs ++ ]\n");
5662 (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 1);
5665 return yyerror ("Bad register(s) for FLUSH");
5670 #line 2950 "bfin-parse.y"
5672 if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5674 notethat ("CaCTRL: IFLUSH [ pregs ]\n");
5675 (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 3);
5678 return yyerror ("Bad register(s) for FLUSH");
5683 #line 2961 "bfin-parse.y"
5685 if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5687 notethat ("CaCTRL: IFLUSH [ pregs ++ ]\n");
5688 (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 3);
5691 return yyerror ("Bad register(s) for FLUSH");
5696 #line 2972 "bfin-parse.y"
5698 if (IS_PREG ((yyvsp[(3) - (4)].reg)))
5700 notethat ("CaCTRL: PREFETCH [ pregs ]\n");
5701 (yyval.instr) = CACTRL (&(yyvsp[(3) - (4)].reg), 0, 0);
5704 return yyerror ("Bad register(s) for PREFETCH");
5709 #line 2983 "bfin-parse.y"
5711 if (IS_PREG ((yyvsp[(2) - (2)].reg)))
5713 notethat ("CaCTRL: PREFETCH [ pregs ++ ]\n");
5714 (yyval.instr) = CACTRL (&(yyvsp[(2) - (2)].reg), 1, 0);
5717 return yyerror ("Bad register(s) for PREFETCH");
5722 #line 2997 "bfin-parse.y"
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");
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);
5735 #line 3009 "bfin-parse.y"
5737 Expr_Node *tmp = (yyvsp[(5) - (8)].expr);
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");
5744 if (IS_RELOC ((yyvsp[(5) - (8)].expr)))
5745 return yyerror ("Plain symbol used as offset");
5747 if ((yyvsp[(4) - (8)].r0).r0)
5748 tmp = unary (Expr_Op_Type_NEG, tmp);
5750 if (in_range_p (tmp, -32768, 32767, 0))
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));
5756 return yyerror ("Displacement out of range");
5761 #line 3035 "bfin-parse.y"
5763 Expr_Node *tmp = (yyvsp[(5) - (8)].expr);
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");
5770 if ((yyvsp[(4) - (8)].r0).r0)
5771 tmp = unary (Expr_Op_Type_NEG, tmp);
5773 if (IS_RELOC ((yyvsp[(5) - (8)].expr)))
5774 return yyerror ("Plain symbol used as offset");
5776 if (in_range_p (tmp, 0, 30, 1))
5778 notethat ("LDSTii: W [ pregs +- uimm5m2 ] = dregs\n");
5779 (yyval.instr) = LDSTII (&(yyvsp[(3) - (8)].reg), &(yyvsp[(8) - (8)].reg), tmp, 1, 1);
5781 else if (in_range_p (tmp, -65536, 65535, 1))
5783 notethat ("LDSTidxI: W [ pregs + imm17m2 ] = dregs\n");
5784 (yyval.instr) = LDSTIDXI (&(yyvsp[(3) - (8)].reg), &(yyvsp[(8) - (8)].reg), 1, 1, 0, tmp);
5787 return yyerror ("Displacement out of range");
5792 #line 3065 "bfin-parse.y"
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");
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);
5805 #line 3076 "bfin-parse.y"
5807 if (!IS_DREG ((yyvsp[(7) - (7)].reg)))
5808 return yyerror ("Dreg expected for source operand");
5809 if ((yyvsp[(4) - (7)].modcodes).x0 == 2)
5811 if (!IS_IREG ((yyvsp[(3) - (7)].reg)) && !IS_PREG ((yyvsp[(3) - (7)].reg)))
5812 return yyerror ("Ireg or Preg expected in address");
5814 else if (!IS_IREG ((yyvsp[(3) - (7)].reg)))
5815 return yyerror ("Ireg expected in address");
5817 if (IS_IREG ((yyvsp[(3) - (7)].reg)))
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);
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);
5831 #line 3101 "bfin-parse.y"
5833 Expr_Node *tmp = (yyvsp[(4) - (7)].expr);
5834 int ispreg = IS_PREG ((yyvsp[(7) - (7)].reg));
5836 if (!IS_PREG ((yyvsp[(2) - (7)].reg)))
5837 return yyerror ("Preg expected in address");
5839 if (!IS_DREG ((yyvsp[(7) - (7)].reg)) && !ispreg)
5840 return yyerror ("Preg expected for source operand");
5842 if ((yyvsp[(3) - (7)].r0).r0)
5843 tmp = unary (Expr_Op_Type_NEG, tmp);
5845 if (IS_RELOC ((yyvsp[(4) - (7)].expr)))
5846 return yyerror ("Plain symbol used as offset");
5848 if (in_range_p (tmp, 0, 63, 3))
5850 notethat ("LDSTii: dpregs = [ pregs + uimm6m4 ]\n");
5851 (yyval.instr) = LDSTII (&(yyvsp[(2) - (7)].reg), &(yyvsp[(7) - (7)].reg), tmp, 1, ispreg ? 3 : 0);
5853 else if ((yyvsp[(2) - (7)].reg).regno == REG_FP && in_range_p (tmp, -128, 0, 3))
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);
5859 else if (in_range_p (tmp, -131072, 131071, 3))
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);
5865 return yyerror ("Displacement out of range");
5870 #line 3138 "bfin-parse.y"
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");
5878 if ((yyvsp[(6) - (9)].r0).r0)
5879 tmp = unary (Expr_Op_Type_NEG, tmp);
5881 if (IS_RELOC ((yyvsp[(7) - (9)].expr)))
5882 return yyerror ("Plain symbol used as offset");
5884 if (in_range_p (tmp, 0, 30, 1))
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);
5889 else if (in_range_p (tmp, -65536, 65535, 1))
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);
5895 return yyerror ("Displacement out of range");
5900 #line 3166 "bfin-parse.y"
5902 if (!IS_DREG ((yyvsp[(1) - (7)].reg)))
5903 return yyerror ("Dreg expected for source operand");
5904 if ((yyvsp[(6) - (7)].modcodes).x0 == 2)
5906 if (!IS_IREG ((yyvsp[(5) - (7)].reg)) && !IS_PREG ((yyvsp[(5) - (7)].reg)))
5907 return yyerror ("Ireg or Preg expected in address");
5909 else if (!IS_IREG ((yyvsp[(5) - (7)].reg)))
5910 return yyerror ("Ireg expected in address");
5912 if (IS_IREG ((yyvsp[(5) - (7)].reg)))
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);
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);
5926 #line 3191 "bfin-parse.y"
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");
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);
5939 #line 3202 "bfin-parse.y"
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");
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);
5952 #line 3213 "bfin-parse.y"
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");
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);
5965 #line 3224 "bfin-parse.y"
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");
5974 if (IS_IREG ((yyvsp[(2) - (6)].reg)))
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);
5979 else if (IS_DREG ((yyvsp[(6) - (6)].reg)))
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);
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);
5993 #line 3250 "bfin-parse.y"
5995 if (!IS_DREG ((yyvsp[(7) - (7)].reg)))
5996 return yyerror ("Dreg expected for source operand");
5998 if (IS_IREG ((yyvsp[(2) - (7)].reg)) && IS_MREG ((yyvsp[(4) - (7)].reg)))
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);
6003 else if (IS_PREG ((yyvsp[(2) - (7)].reg)) && IS_PREG ((yyvsp[(4) - (7)].reg)))
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);
6009 return yyerror ("Preg ++ Preg or Ireg ++ Mreg expected in address");
6014 #line 3269 "bfin-parse.y"
6016 if (!IS_DREG ((yyvsp[(8) - (8)].reg)))
6017 return yyerror ("Dreg expected for source operand");
6019 if (IS_PREG ((yyvsp[(3) - (8)].reg)) && IS_PREG ((yyvsp[(5) - (8)].reg)))
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);
6025 return yyerror ("Preg ++ Preg expected in address");
6030 #line 3283 "bfin-parse.y"
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");
6038 if ((yyvsp[(6) - (9)].r0).r0)
6039 tmp = unary (Expr_Op_Type_NEG, tmp);
6041 if (IS_RELOC ((yyvsp[(7) - (9)].expr)))
6042 return yyerror ("Plain symbol used as offset");
6044 if (in_range_p (tmp, -32768, 32767, 0))
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);
6051 return yyerror ("Displacement out of range");
6056 #line 3307 "bfin-parse.y"
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");
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);
6070 #line 3319 "bfin-parse.y"
6072 if (!IS_DREG ((yyvsp[(1) - (7)].reg)))
6073 return yyerror ("Dreg expected for destination operand");
6075 if (IS_IREG ((yyvsp[(4) - (7)].reg)) && IS_MREG ((yyvsp[(6) - (7)].reg)))
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);
6080 else if (IS_PREG ((yyvsp[(4) - (7)].reg)) && IS_PREG ((yyvsp[(6) - (7)].reg)))
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);
6086 return yyerror ("Preg ++ Preg or Ireg ++ Mreg expected in address");
6091 #line 3338 "bfin-parse.y"
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));
6097 if (!IS_PREG ((yyvsp[(4) - (7)].reg)))
6098 return yyerror ("Preg expected in address");
6100 if (!IS_DREG ((yyvsp[(1) - (7)].reg)) && !ispreg)
6101 return yyerror ("Dreg or Preg expected for destination operand");
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");
6108 if ((yyvsp[(5) - (7)].r0).r0)
6109 tmp = unary (Expr_Op_Type_NEG, tmp);
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);
6116 else if (in_range_p (tmp, 0, 63, 3))
6118 notethat ("LDSTii: dpregs = [ pregs + uimm7m4 ]\n");
6119 (yyval.instr) = LDSTII (&(yyvsp[(4) - (7)].reg), &(yyvsp[(1) - (7)].reg), tmp, 0, ispreg ? 3 : 0);
6121 else if ((yyvsp[(4) - (7)].reg).regno == REG_FP && in_range_p (tmp, -128, 0, 3))
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);
6127 else if (in_range_p (tmp, -131072, 131071, 3))
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);
6134 return yyerror ("Displacement out of range");
6139 #line 3384 "bfin-parse.y"
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");
6149 if (IS_IREG ((yyvsp[(4) - (6)].reg)))
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);
6154 else if (IS_DREG ((yyvsp[(1) - (6)].reg)))
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);
6159 else if (IS_PREG ((yyvsp[(1) - (6)].reg)))
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");
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);
6169 notethat ("PushPopReg: allregs = [ SP ++ ]\n");
6170 (yyval.instr) = PUSHPOPREG (&(yyvsp[(1) - (6)].reg), 0);
6176 #line 3421 "bfin-parse.y"
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))
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);
6189 return yyerror ("Bad register for PushPopMultiple");
6194 #line 3437 "bfin-parse.y"
6196 if ((yyvsp[(1) - (7)].reg).regno != REG_SP)
6197 yyerror ("Stack Pointer expected");
6199 if ((yyvsp[(4) - (7)].reg).regno == REG_R7 && IN_RANGE ((yyvsp[(6) - (7)].expr), 0, 7))
6201 notethat ("PushPopMultiple: [ -- SP ] = (R7 : reglim )\n");
6202 (yyval.instr) = PUSHPOPMULTIPLE (imm5 ((yyvsp[(6) - (7)].expr)), 0, 1, 0, 1);
6204 else if ((yyvsp[(4) - (7)].reg).regno == REG_P5 && IN_RANGE ((yyvsp[(6) - (7)].expr), 0, 6))
6206 notethat ("PushPopMultiple: [ -- SP ] = (P5 : reglim )\n");
6207 (yyval.instr) = PUSHPOPMULTIPLE (0, imm5 ((yyvsp[(6) - (7)].expr)), 0, 1, 1);
6210 return yyerror ("Bad register for PushPopMultiple");
6215 #line 3456 "bfin-parse.y"
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)))
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);
6226 return yyerror ("Bad register range for PushPopMultiple");
6231 #line 3470 "bfin-parse.y"
6233 if ((yyvsp[(7) - (7)].reg).regno != REG_SP)
6234 yyerror ("Stack Pointer expected");
6236 if ((yyvsp[(2) - (7)].reg).regno == REG_R7 && IN_RANGE ((yyvsp[(4) - (7)].expr), 0, 7))
6238 notethat ("PushPopMultiple: (R7 : reglim ) = [ SP ++ ]\n");
6239 (yyval.instr) = PUSHPOPMULTIPLE (imm5 ((yyvsp[(4) - (7)].expr)), 0, 1, 0, 0);
6241 else if ((yyvsp[(2) - (7)].reg).regno == REG_P5 && IN_RANGE ((yyvsp[(4) - (7)].expr), 0, 6))
6243 notethat ("PushPopMultiple: (P5 : reglim ) = [ SP ++ ]\n");
6244 (yyval.instr) = PUSHPOPMULTIPLE (0, imm5 ((yyvsp[(4) - (7)].expr)), 0, 1, 0);
6247 return yyerror ("Bad register range for PushPopMultiple");
6252 #line 3489 "bfin-parse.y"
6254 if ((yyvsp[(1) - (3)].reg).regno != REG_SP)
6255 yyerror ("Stack Pointer expected");
6257 if (IS_ALLREG ((yyvsp[(3) - (3)].reg)))
6259 notethat ("PushPopReg: [ -- SP ] = allregs\n");
6260 (yyval.instr) = PUSHPOPREG (&(yyvsp[(3) - (3)].reg), 1);
6263 return yyerror ("Bad register for PushPopReg");
6268 #line 3505 "bfin-parse.y"
6270 if (IS_URANGE (16, (yyvsp[(2) - (2)].expr), 0, 4))
6271 (yyval.instr) = LINKAGE (0, uimm16s4 ((yyvsp[(2) - (2)].expr)));
6273 return yyerror ("Bad constant for LINK");
6278 #line 3513 "bfin-parse.y"
6280 notethat ("linkage: UNLINK\n");
6281 (yyval.instr) = LINKAGE (1, 0);
6286 #line 3522 "bfin-parse.y"
6288 if (IS_PCREL4 ((yyvsp[(3) - (7)].expr)) && IS_LPPCREL10 ((yyvsp[(5) - (7)].expr)) && IS_CREG ((yyvsp[(7) - (7)].reg)))
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);
6294 return yyerror ("Bad register or values for LSETUP");
6300 #line 3533 "bfin-parse.y"
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)))
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));
6309 return yyerror ("Bad register or values for LSETUP");
6314 #line 3545 "bfin-parse.y"
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)
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));
6324 return yyerror ("Bad register or values for LSETUP");
6329 #line 3559 "bfin-parse.y"
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);
6340 #line 3567 "bfin-parse.y"
6342 if (IS_RELOC ((yyvsp[(2) - (5)].expr)) && IS_PREG ((yyvsp[(5) - (5)].reg)) && IS_CREG ((yyvsp[(3) - (5)].reg)))
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));
6348 return yyerror ("Bad register or values for LOOP");
6353 #line 3577 "bfin-parse.y"
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)
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));
6361 return yyerror ("Bad register or values for LOOP");
6366 #line 3589 "bfin-parse.y"
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);
6380 #line 3600 "bfin-parse.y"
6382 if (!IS_RELOC ((yyvsp[(2) - (2)].expr)))
6383 return yyerror ("Invalid expression in LOOP_BEGIN statement");
6385 bfin_loop_beginend ((yyvsp[(2) - (2)].expr), 1);
6391 #line 3610 "bfin-parse.y"
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);
6405 #line 3621 "bfin-parse.y"
6407 if (!IS_RELOC ((yyvsp[(2) - (2)].expr)))
6408 return yyerror ("Invalid expression in LOOP_END statement");
6410 bfin_loop_beginend ((yyvsp[(2) - (2)].expr), 0);
6416 #line 3632 "bfin-parse.y"
6418 notethat ("psedoDEBUG: ABORT\n");
6419 (yyval.instr) = bfin_gen_pseudodbg (3, 3, 0);
6424 #line 3638 "bfin-parse.y"
6426 notethat ("pseudoDEBUG: DBG\n");
6427 (yyval.instr) = bfin_gen_pseudodbg (3, 7, 0);
6432 #line 3643 "bfin-parse.y"
6434 notethat ("pseudoDEBUG: DBG REG_A\n");
6435 (yyval.instr) = bfin_gen_pseudodbg (3, IS_A1 ((yyvsp[(2) - (2)].reg)), 0);
6440 #line 3648 "bfin-parse.y"
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);
6448 #line 3654 "bfin-parse.y"
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);
6458 #line 3662 "bfin-parse.y"
6460 notethat ("psedoDEBUG: DBGHALT\n");
6461 (yyval.instr) = bfin_gen_pseudodbg (3, 5, 0);
6466 #line 3668 "bfin-parse.y"
6468 notethat ("psedoDEBUG: HLT\n");
6469 (yyval.instr) = bfin_gen_pseudodbg (3, 4, 0);
6474 #line 3674 "bfin-parse.y"
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)));
6482 #line 3680 "bfin-parse.y"
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)));
6490 #line 3686 "bfin-parse.y"
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)));
6498 #line 3692 "bfin-parse.y"
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)));
6508 #line 3700 "bfin-parse.y"
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);
6518 #line 3714 "bfin-parse.y"
6520 (yyval.reg) = (yyvsp[(1) - (1)].reg);
6525 #line 3718 "bfin-parse.y"
6527 (yyval.reg) = (yyvsp[(1) - (1)].reg);
6532 #line 3727 "bfin-parse.y"
6535 (yyval.mod).mod = 0;
6540 #line 3732 "bfin-parse.y"
6543 (yyval.mod).mod = (yyvsp[(4) - (5)].value);
6548 #line 3737 "bfin-parse.y"
6551 (yyval.mod).mod = (yyvsp[(2) - (5)].value);
6556 #line 3742 "bfin-parse.y"
6559 (yyval.mod).mod = (yyvsp[(2) - (3)].value);
6564 #line 3747 "bfin-parse.y"
6567 (yyval.mod).mod = 0;
6572 #line 3754 "bfin-parse.y"
6579 #line 3758 "bfin-parse.y"
6586 #line 3764 "bfin-parse.y"
6588 (yyval.modcodes).s0 = 0;
6589 (yyval.modcodes).x0 = 0;
6594 #line 3769 "bfin-parse.y"
6596 (yyval.modcodes).s0 = 1;
6597 (yyval.modcodes).x0 = 0;
6602 #line 3774 "bfin-parse.y"
6604 (yyval.modcodes).s0 = 0;
6605 (yyval.modcodes).x0 = 1;
6610 #line 3779 "bfin-parse.y"
6612 (yyval.modcodes).s0 = 1;
6613 (yyval.modcodes).x0 = 1;
6618 #line 3787 "bfin-parse.y"
6625 #line 3791 "bfin-parse.y"
6632 #line 3797 "bfin-parse.y"
6634 (yyval.modcodes).s0 = 0;
6635 (yyval.modcodes).x0 = 0;
6640 #line 3802 "bfin-parse.y"
6642 (yyval.modcodes).s0 = (yyvsp[(2) - (3)].modcodes).s0;
6643 (yyval.modcodes).x0 = (yyvsp[(2) - (3)].modcodes).x0;
6648 #line 3809 "bfin-parse.y"
6650 (yyval.modcodes).s0 = 0;
6651 (yyval.modcodes).x0 = 0;
6652 (yyval.modcodes).aop = 0;
6657 #line 3815 "bfin-parse.y"
6659 (yyval.modcodes).s0 = 0;
6660 (yyval.modcodes).x0 = 0;
6661 (yyval.modcodes).aop = 1;
6666 #line 3821 "bfin-parse.y"
6668 (yyval.modcodes).s0 = 1;
6669 (yyval.modcodes).x0 = 0;
6670 (yyval.modcodes).aop = 1;
6675 #line 3829 "bfin-parse.y"
6677 (yyval.modcodes).r0 = 0;
6678 (yyval.modcodes).s0 = 0;
6679 (yyval.modcodes).x0 = 0;
6684 #line 3835 "bfin-parse.y"
6686 (yyval.modcodes).r0 = 2 + (yyvsp[(2) - (3)].r0).r0;
6687 (yyval.modcodes).s0 = 0;
6688 (yyval.modcodes).x0 = 0;
6693 #line 3841 "bfin-parse.y"
6695 (yyval.modcodes).r0 = 0;
6696 (yyval.modcodes).s0 = (yyvsp[(2) - (3)].modcodes).s0;
6697 (yyval.modcodes).x0 = (yyvsp[(2) - (3)].modcodes).x0;
6702 #line 3847 "bfin-parse.y"
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;
6711 #line 3853 "bfin-parse.y"
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;
6720 #line 3861 "bfin-parse.y"
6727 #line 3865 "bfin-parse.y"
6734 #line 3869 "bfin-parse.y"
6741 #line 3875 "bfin-parse.y"
6748 #line 3879 "bfin-parse.y"
6755 #line 3883 "bfin-parse.y"
6762 #line 3889 "bfin-parse.y"
6764 (yyval.modcodes).r0 = 0;
6765 (yyval.modcodes).s0 = 0;
6766 (yyval.modcodes).aop = 0;
6771 #line 3895 "bfin-parse.y"
6773 (yyval.modcodes).r0 = 0;
6774 (yyval.modcodes).s0 = 0;
6775 (yyval.modcodes).aop = 3;
6780 #line 3901 "bfin-parse.y"
6782 (yyval.modcodes).r0 = 0;
6783 (yyval.modcodes).s0 = 1;
6784 (yyval.modcodes).aop = 3;
6789 #line 3907 "bfin-parse.y"
6791 (yyval.modcodes).r0 = 1;
6792 (yyval.modcodes).s0 = 0;
6793 (yyval.modcodes).aop = 3;
6798 #line 3913 "bfin-parse.y"
6800 (yyval.modcodes).r0 = 1;
6801 (yyval.modcodes).s0 = 1;
6806 #line 3918 "bfin-parse.y"
6808 (yyval.modcodes).r0 = 1;
6809 (yyval.modcodes).s0 = 1;
6814 #line 3925 "bfin-parse.y"
6821 #line 3929 "bfin-parse.y"
6828 #line 3935 "bfin-parse.y"
6830 (yyval.modcodes).s0 = 0;
6835 #line 3939 "bfin-parse.y"
6837 (yyval.modcodes).s0 = 1;
6842 #line 3946 "bfin-parse.y"
6849 #line 3950 "bfin-parse.y"
6856 #line 3954 "bfin-parse.y"
6863 #line 3958 "bfin-parse.y"
6870 #line 3964 "bfin-parse.y"
6877 #line 3968 "bfin-parse.y"
6884 #line 3975 "bfin-parse.y"
6886 (yyval.modcodes).r0 = 0;
6887 (yyval.modcodes).s0 = 1;
6892 #line 3980 "bfin-parse.y"
6894 if ((yyvsp[(2) - (3)].value) != M_T)
6895 return yyerror ("Bad modifier");
6896 (yyval.modcodes).r0 = 1;
6897 (yyval.modcodes).s0 = 0;
6902 #line 3987 "bfin-parse.y"
6904 if ((yyvsp[(2) - (5)].value) != M_T)
6905 return yyerror ("Bad modifier");
6906 (yyval.modcodes).r0 = 1;
6907 (yyval.modcodes).s0 = 1;
6912 #line 3994 "bfin-parse.y"
6914 if ((yyvsp[(4) - (5)].value) != M_T)
6915 return yyerror ("Bad modifier");
6916 (yyval.modcodes).r0 = 1;
6917 (yyval.modcodes).s0 = 1;
6922 #line 4006 "bfin-parse.y"
6929 #line 4010 "bfin-parse.y"
6936 #line 4014 "bfin-parse.y"
6943 #line 4020 "bfin-parse.y"
6950 #line 4024 "bfin-parse.y"
6952 if ((yyvsp[(2) - (3)].value) == M_W32)
6955 return yyerror ("Only (W32) allowed");
6960 #line 4033 "bfin-parse.y"
6967 #line 4037 "bfin-parse.y"
6969 if ((yyvsp[(2) - (3)].value) == M_IU)
6972 return yyerror ("(IU) expected");
6977 #line 4046 "bfin-parse.y"
6979 (yyval.reg) = (yyvsp[(3) - (4)].reg);
6984 #line 4052 "bfin-parse.y"
6986 (yyval.reg) = (yyvsp[(2) - (4)].reg);
6991 #line 4061 "bfin-parse.y"
6998 #line 4065 "bfin-parse.y"
7005 #line 4072 "bfin-parse.y"
7012 #line 4076 "bfin-parse.y"
7019 #line 4080 "bfin-parse.y"
7026 #line 4084 "bfin-parse.y"
7033 #line 4091 "bfin-parse.y"
7040 #line 4095 "bfin-parse.y"
7047 #line 4102 "bfin-parse.y"
7049 (yyval.modcodes).r0 = 1; /* HL. */
7050 (yyval.modcodes).s0 = 0; /* s. */
7051 (yyval.modcodes).x0 = 0; /* x. */
7052 (yyval.modcodes).aop = 0; /* aop. */
7057 #line 4110 "bfin-parse.y"
7059 (yyval.modcodes).r0 = 1; /* HL. */
7060 (yyval.modcodes).s0 = 0; /* s. */
7061 (yyval.modcodes).x0 = 0; /* x. */
7062 (yyval.modcodes).aop = 1; /* aop. */
7067 #line 4118 "bfin-parse.y"
7069 (yyval.modcodes).r0 = 0; /* HL. */
7070 (yyval.modcodes).s0 = 0; /* s. */
7071 (yyval.modcodes).x0 = 0; /* x. */
7072 (yyval.modcodes).aop = 0; /* aop. */
7077 #line 4126 "bfin-parse.y"
7079 (yyval.modcodes).r0 = 0; /* HL. */
7080 (yyval.modcodes).s0 = 0; /* s. */
7081 (yyval.modcodes).x0 = 0; /* x. */
7082 (yyval.modcodes).aop = 1;
7087 #line 4134 "bfin-parse.y"
7089 (yyval.modcodes).r0 = 1; /* HL. */
7090 (yyval.modcodes).s0 = 1; /* s. */
7091 (yyval.modcodes).x0 = 0; /* x. */
7092 (yyval.modcodes).aop = 0; /* aop. */
7097 #line 4141 "bfin-parse.y"
7099 (yyval.modcodes).r0 = 1; /* HL. */
7100 (yyval.modcodes).s0 = 1; /* s. */
7101 (yyval.modcodes).x0 = 0; /* x. */
7102 (yyval.modcodes).aop = 1; /* aop. */
7107 #line 4148 "bfin-parse.y"
7109 (yyval.modcodes).r0 = 0; /* HL. */
7110 (yyval.modcodes).s0 = 1; /* s. */
7111 (yyval.modcodes).x0 = 0; /* x. */
7112 (yyval.modcodes).aop = 0; /* aop. */
7117 #line 4156 "bfin-parse.y"
7119 (yyval.modcodes).r0 = 0; /* HL. */
7120 (yyval.modcodes).s0 = 1; /* s. */
7121 (yyval.modcodes).x0 = 0; /* x. */
7122 (yyval.modcodes).aop = 1; /* aop. */
7127 #line 4166 "bfin-parse.y"
7129 (yyval.modcodes).s0 = 0; /* s. */
7130 (yyval.modcodes).x0 = 0; /* HL. */
7135 #line 4171 "bfin-parse.y"
7137 (yyval.modcodes).s0 = 0; /* s. */
7138 (yyval.modcodes).x0 = 1; /* HL. */
7143 #line 4176 "bfin-parse.y"
7145 (yyval.modcodes).s0 = 1; /* s. */
7146 (yyval.modcodes).x0 = 0; /* HL. */
7151 #line 4181 "bfin-parse.y"
7153 (yyval.modcodes).s0 = 1; /* s. */
7154 (yyval.modcodes).x0 = 1; /* HL. */
7159 #line 4188 "bfin-parse.y"
7161 (yyval.modcodes).x0 = 2;
7166 #line 4192 "bfin-parse.y"
7168 (yyval.modcodes).x0 = 0;
7173 #line 4196 "bfin-parse.y"
7175 (yyval.modcodes).x0 = 1;
7180 #line 4205 "bfin-parse.y"
7182 (yyval.reg) = (yyvsp[(1) - (2)].reg);
7187 #line 4212 "bfin-parse.y"
7189 (yyval.reg) = (yyvsp[(1) - (2)].reg);
7194 #line 4219 "bfin-parse.y"
7196 (yyval.reg) = (yyvsp[(1) - (2)].reg);
7201 #line 4226 "bfin-parse.y"
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");
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;
7219 #line 4241 "bfin-parse.y"
7221 (yyval.macfunc) = (yyvsp[(1) - (1)].macfunc);
7222 (yyval.macfunc).w = 0; (yyval.macfunc).P = 0;
7223 (yyval.macfunc).dst.regno = 0;
7228 #line 4247 "bfin-parse.y"
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");
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);
7243 #line 4260 "bfin-parse.y"
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");
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);
7258 #line 4273 "bfin-parse.y"
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");
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;
7276 #line 4291 "bfin-parse.y"
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;
7286 #line 4298 "bfin-parse.y"
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;
7296 #line 4305 "bfin-parse.y"
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;
7306 #line 4315 "bfin-parse.y"
7308 if (IS_DREG ((yyvsp[(1) - (3)].reg)) && IS_DREG ((yyvsp[(3) - (3)].reg)))
7310 (yyval.macfunc).s0 = (yyvsp[(1) - (3)].reg);
7311 (yyval.macfunc).s1 = (yyvsp[(3) - (3)].reg);
7314 return yyerror ("Dregs expected");
7319 #line 4328 "bfin-parse.y"
7326 #line 4332 "bfin-parse.y"
7333 #line 4336 "bfin-parse.y"
7340 #line 4340 "bfin-parse.y"
7347 #line 4347 "bfin-parse.y"
7349 (yyval.modcodes).r0 = (yyvsp[(3) - (3)].reg).regno;
7350 (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7351 (yyval.modcodes).s0 = 0;
7356 #line 4353 "bfin-parse.y"
7358 (yyval.modcodes).r0 = 0x18;
7359 (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7360 (yyval.modcodes).s0 = 0;
7365 #line 4359 "bfin-parse.y"
7367 (yyval.modcodes).r0 = (yyvsp[(1) - (3)].reg).regno;
7368 (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7369 (yyval.modcodes).s0 = 1;
7374 #line 4365 "bfin-parse.y"
7376 (yyval.modcodes).r0 = 0x18;
7377 (yyval.modcodes).x0 = (yyvsp[(2) - (3)].r0).r0;
7378 (yyval.modcodes).s0 = 1;
7383 #line 4375 "bfin-parse.y"
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);
7392 #line 4384 "bfin-parse.y"
7393 { (yyval.value) = BFD_RELOC_BFIN_GOT; }
7397 #line 4386 "bfin-parse.y"
7398 { (yyval.value) = BFD_RELOC_BFIN_GOT17M4; }
7402 #line 4388 "bfin-parse.y"
7403 { (yyval.value) = BFD_RELOC_BFIN_FUNCDESC_GOT17M4; }
7407 #line 4392 "bfin-parse.y"
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);
7416 #line 4400 "bfin-parse.y"
7418 (yyval.expr) = (yyvsp[(1) - (1)].expr);
7423 #line 4404 "bfin-parse.y"
7425 (yyval.expr) = (yyvsp[(1) - (1)].expr);
7430 #line 4411 "bfin-parse.y"
7432 (yyval.expr) = (yyvsp[(1) - (3)].expr);
7437 #line 4417 "bfin-parse.y"
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);
7446 #line 4423 "bfin-parse.y"
7448 (yyval.expr) = (yyvsp[(1) - (1)].expr);
7453 #line 4427 "bfin-parse.y"
7455 (yyval.expr) = (yyvsp[(2) - (3)].expr);
7460 #line 4431 "bfin-parse.y"
7462 (yyval.expr) = unary (Expr_Op_Type_COMP, (yyvsp[(2) - (2)].expr));
7467 #line 4435 "bfin-parse.y"
7469 (yyval.expr) = unary (Expr_Op_Type_NEG, (yyvsp[(2) - (2)].expr));
7474 #line 4441 "bfin-parse.y"
7476 (yyval.expr) = (yyvsp[(1) - (1)].expr);
7481 #line 4447 "bfin-parse.y"
7483 (yyval.expr) = binary (Expr_Op_Type_Mult, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7488 #line 4451 "bfin-parse.y"
7490 (yyval.expr) = binary (Expr_Op_Type_Div, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7495 #line 4455 "bfin-parse.y"
7497 (yyval.expr) = binary (Expr_Op_Type_Mod, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7502 #line 4459 "bfin-parse.y"
7504 (yyval.expr) = binary (Expr_Op_Type_Add, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7509 #line 4463 "bfin-parse.y"
7511 (yyval.expr) = binary (Expr_Op_Type_Sub, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7516 #line 4467 "bfin-parse.y"
7518 (yyval.expr) = binary (Expr_Op_Type_Lshift, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7523 #line 4471 "bfin-parse.y"
7525 (yyval.expr) = binary (Expr_Op_Type_Rshift, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7530 #line 4475 "bfin-parse.y"
7532 (yyval.expr) = binary (Expr_Op_Type_BAND, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7537 #line 4479 "bfin-parse.y"
7539 (yyval.expr) = binary (Expr_Op_Type_LOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7544 #line 4483 "bfin-parse.y"
7546 (yyval.expr) = binary (Expr_Op_Type_BOR, (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr));
7551 #line 4487 "bfin-parse.y"
7553 (yyval.expr) = (yyvsp[(1) - (1)].expr);
7558 /* Line 1267 of yacc.c. */
7559 #line 7560 "bfin-parse.c"
7562 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
7566 YY_STACK_PRINT (yyss, yyssp);
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. */
7577 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
7578 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
7579 yystate = yytable[yystate];
7581 yystate = yydefgoto[yyn - YYNTOKENS];
7586 /*------------------------------------.
7587 | yyerrlab -- here on detecting error |
7588 `------------------------------------*/
7590 /* If not already recovering from an error, report this error. */
7594 #if ! YYERROR_VERBOSE
7595 yyerror (YY_("syntax error"));
7598 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
7599 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
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);
7608 yymsg_alloc = yyalloc;
7612 yymsg_alloc = sizeof yymsgbuf;
7616 if (0 < yysize && yysize <= yymsg_alloc)
7618 (void) yysyntax_error (yymsg, yystate, yychar);
7623 yyerror (YY_("syntax error"));
7625 goto yyexhaustedlab;
7633 if (yyerrstatus == 3)
7635 /* If just tried and failed to reuse look-ahead token after an
7636 error, discard it. */
7638 if (yychar <= YYEOF)
7640 /* Return failure if at end of input. */
7641 if (yychar == YYEOF)
7646 yydestruct ("Error: discarding",
7652 /* Else will try to reuse look-ahead token after shifting the error
7657 /*---------------------------------------------------.
7658 | yyerrorlab -- error raised explicitly by YYERROR. |
7659 `---------------------------------------------------*/
7662 /* Pacify compilers like GCC when the user code never invokes
7663 YYERROR and the label yyerrorlab therefore never appears in user
7665 if (/*CONSTCOND*/ 0)
7668 /* Do not reclaim the symbols of the rule which action triggered
7672 YY_STACK_PRINT (yyss, yyssp);
7677 /*-------------------------------------------------------------.
7678 | yyerrlab1 -- common code for both syntax error and YYERROR. |
7679 `-------------------------------------------------------------*/
7681 yyerrstatus = 3; /* Each real token shifted decrements this. */
7685 yyn = yypact[yystate];
7686 if (yyn != YYPACT_NINF)
7689 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
7697 /* Pop the current state because it cannot handle the error token. */
7702 yydestruct ("Error: popping",
7703 yystos[yystate], yyvsp);
7706 YY_STACK_PRINT (yyss, yyssp);
7715 /* Shift the error token. */
7716 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7722 /*-------------------------------------.
7723 | yyacceptlab -- YYACCEPT comes here. |
7724 `-------------------------------------*/
7729 /*-----------------------------------.
7730 | yyabortlab -- YYABORT comes here. |
7731 `-----------------------------------*/
7737 /*-------------------------------------------------.
7738 | yyexhaustedlab -- memory exhaustion comes here. |
7739 `-------------------------------------------------*/
7741 yyerror (YY_("memory exhausted"));
7747 if (yychar != YYEOF && yychar != YYEMPTY)
7748 yydestruct ("Cleanup: discarding lookahead",
7750 /* Do not reclaim the symbols of the rule which action triggered
7751 this YYABORT or YYACCEPT. */
7753 YY_STACK_PRINT (yyss, yyssp);
7754 while (yyssp != yyss)
7756 yydestruct ("Cleanup: popping",
7757 yystos[*yyssp], yyvsp);
7762 YYSTACK_FREE (yyss);
7765 if (yymsg != yymsgbuf)
7766 YYSTACK_FREE (yymsg);
7768 /* Make sure YYID is used. */
7769 return YYID (yyresult);
7773 #line 4493 "bfin-parse.y"
7777 mkexpr (int x, SYMBOL_T s)
7779 EXPR_T e = (EXPR_T) ALLOCATE (sizeof (struct expression_cell));
7786 value_match (Expr_Node *exp, int sz, int sign, int mul, int issigned)
7788 int umax = (1 << sz) - 1;
7789 int min = -1 << (sz - 1);
7790 int max = (1 << (sz - 1)) - 1;
7792 int v = (EXPR_VALUE (exp)) & 0xffffffff;
7796 error ("%s:%d: Value Error -- Must align to %d\n", __FILE__, __LINE__, mul);
7807 if (v >= min && v <= max) return 1;
7810 fprintf(stderr, "signed value %lx out of range\n", v * mul);
7814 if (v <= umax && v >= 0)
7817 fprintf(stderr, "unsigned value %lx out of range\n", v * mul);
7822 /* Return the expression structure that allows symbol operations.
7823 If the left and right children are constants, do the operation. */
7825 binary (Expr_Op_Type op, Expr_Node *x, Expr_Node *y)
7827 Expr_Node_Value val;
7829 if (x->type == Expr_Node_Constant && y->type == Expr_Node_Constant)
7833 case Expr_Op_Type_Add:
7834 x->value.i_value += y->value.i_value;
7836 case Expr_Op_Type_Sub:
7837 x->value.i_value -= y->value.i_value;
7839 case Expr_Op_Type_Mult:
7840 x->value.i_value *= y->value.i_value;
7842 case Expr_Op_Type_Div:
7843 if (y->value.i_value == 0)
7844 error ("Illegal Expression: Division by zero.");
7846 x->value.i_value /= y->value.i_value;
7848 case Expr_Op_Type_Mod:
7849 x->value.i_value %= y->value.i_value;
7851 case Expr_Op_Type_Lshift:
7852 x->value.i_value <<= y->value.i_value;
7854 case Expr_Op_Type_Rshift:
7855 x->value.i_value >>= y->value.i_value;
7857 case Expr_Op_Type_BAND:
7858 x->value.i_value &= y->value.i_value;
7860 case Expr_Op_Type_BOR:
7861 x->value.i_value |= y->value.i_value;
7863 case Expr_Op_Type_BXOR:
7864 x->value.i_value ^= y->value.i_value;
7866 case Expr_Op_Type_LAND:
7867 x->value.i_value = x->value.i_value && y->value.i_value;
7869 case Expr_Op_Type_LOR:
7870 x->value.i_value = x->value.i_value || y->value.i_value;
7874 error ("%s:%d: Internal assembler error\n", __FILE__, __LINE__);
7878 /* Canonicalize order to EXPR OP CONSTANT. */
7879 if (x->type == Expr_Node_Constant)
7885 /* Canonicalize subtraction of const to addition of negated const. */
7886 if (op == Expr_Op_Type_Sub && y->type == Expr_Node_Constant)
7888 op = Expr_Op_Type_Add;
7889 y->value.i_value = -y->value.i_value;
7891 if (y->type == Expr_Node_Constant && x->type == Expr_Node_Binop
7892 && x->Right_Child->type == Expr_Node_Constant)
7894 if (op == x->value.op_value && x->value.op_value == Expr_Op_Type_Add)
7896 x->Right_Child->value.i_value += y->value.i_value;
7901 /* Create a new expression structure. */
7903 return Expr_Node_Create (Expr_Node_Binop, val, x, y);
7907 unary (Expr_Op_Type op, Expr_Node *x)
7909 if (x->type == Expr_Node_Constant)
7913 case Expr_Op_Type_NEG:
7914 x->value.i_value = -x->value.i_value;
7916 case Expr_Op_Type_COMP:
7917 x->value.i_value = ~x->value.i_value;
7920 error ("%s:%d: Internal assembler error\n", __FILE__, __LINE__);
7926 /* Create a new expression structure. */
7927 Expr_Node_Value val;
7929 return Expr_Node_Create (Expr_Node_Unop, val, x, NULL);
7933 int debug_codeselection = 0;
7935 notethat (char *format, ...)
7938 va_start (ap, format);
7939 if (debug_codeselection)
7941 vfprintf (errorf, format, ap);
7947 main (int argc, char **argv)
projects / platform / upstream / binutils.git / blob