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