rx-parse.c revision 1.1
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 /* Substitute the variable and function names. */ 68 #define yyparse rx_parse 69 #define yylex rx_lex 70 #define yyerror rx_error 71 #define yydebug rx_debug 72 #define yynerrs rx_nerrs 73 #define yylval rx_lval 74 #define yychar rx_char 75 76 /* First part of user prologue. */ 77 #line 20 "./config/rx-parse.y" 78 79 80 #include "as.h" 81 #include "safe-ctype.h" 82 #include "rx-defs.h" 83 84 static int rx_lex (void); 85 86 #define COND_EQ 0 87 #define COND_NE 1 88 89 #define MEMEX 0x06 90 91 #define BSIZE 0 92 #define WSIZE 1 93 #define LSIZE 2 94 #define DSIZE 3 95 96 /* .sb .sw .l .uw */ 97 static int sizemap[] = { BSIZE, WSIZE, LSIZE, WSIZE }; 98 99 /* Ok, here are the rules for using these macros... 100 101 B*() is used to specify the base opcode bytes. Fields to be filled 102 in later, leave zero. Call this first. 103 104 F() and FE() are used to fill in fields within the base opcode bytes. You MUST 105 call B*() before any F() or FE(). 106 107 [UN]*O*(), PC*() appends operands to the end of the opcode. You 108 must call P() and B*() before any of these, so that the fixups 109 have the right byte location. 110 O = signed, UO = unsigned, NO = negated, PC = pcrel 111 112 IMM() adds an immediate and fills in the field for it. 113 NIMM() same, but negates the immediate. 114 NBIMM() same, but negates the immediate, for sbb. 115 DSP() adds a displacement, and fills in the field for it. 116 117 Note that order is significant for the O, IMM, and DSP macros, as 118 they append their data to the operand buffer in the order that you 119 call them. 120 121 Use "disp" for displacements whenever possible; this handles the 122 "0" case properly. */ 123 124 #define B1(b1) rx_base1 (b1) 125 #define B2(b1, b2) rx_base2 (b1, b2) 126 #define B3(b1, b2, b3) rx_base3 (b1, b2, b3) 127 #define B4(b1, b2, b3, b4) rx_base4 (b1, b2, b3, b4) 128 129 /* POS is bits from the MSB of the first byte to the LSB of the last byte. */ 130 #define F(val,pos,sz) rx_field (val, pos, sz) 131 #define FE(exp,pos,sz) rx_field (exp_val (exp), pos, sz); 132 133 #define O1(v) rx_op (v, 1, RXREL_SIGNED); rx_range (v, -128, 255) 134 #define O2(v) rx_op (v, 2, RXREL_SIGNED); rx_range (v, -32768, 65536) 135 #define O3(v) rx_op (v, 3, RXREL_SIGNED); rx_range (v, -8388608, 16777216) 136 #define O4(v) rx_op (v, 4, RXREL_SIGNED) 137 138 #define UO1(v) rx_op (v, 1, RXREL_UNSIGNED); rx_range (v, 0, 255) 139 #define UO2(v) rx_op (v, 2, RXREL_UNSIGNED); rx_range (v, 0, 65536) 140 #define UO3(v) rx_op (v, 3, RXREL_UNSIGNED); rx_range (v, 0, 16777216) 141 #define UO4(v) rx_op (v, 4, RXREL_UNSIGNED) 142 143 #define NO1(v) rx_op (v, 1, RXREL_NEGATIVE) 144 #define NO2(v) rx_op (v, 2, RXREL_NEGATIVE) 145 #define NO3(v) rx_op (v, 3, RXREL_NEGATIVE) 146 #define NO4(v) rx_op (v, 4, RXREL_NEGATIVE) 147 148 #define PC1(v) rx_op (v, 1, RXREL_PCREL) 149 #define PC2(v) rx_op (v, 2, RXREL_PCREL) 150 #define PC3(v) rx_op (v, 3, RXREL_PCREL) 151 152 #define POST(v) rx_post (v) 153 154 #define IMM_(v,pos,size) F (immediate (v, RXREL_SIGNED, pos, size), pos, 2); \ 155 if (v.X_op != O_constant && v.X_op != O_big) rx_linkrelax_imm (pos) 156 #define IMM(v,pos) IMM_ (v, pos, 32) 157 #define IMMW(v,pos) IMM_ (v, pos, 16); rx_range (v, -32768, 65536) 158 #define IMMB(v,pos) IMM_ (v, pos, 8); rx_range (v, -128, 255) 159 #define NIMM(v,pos) F (immediate (v, RXREL_NEGATIVE, pos, 32), pos, 2) 160 #define NBIMM(v,pos) F (immediate (v, RXREL_NEGATIVE_BORROW, pos, 32), pos, 2) 161 #define DSP(v,pos,msz) if (!v.X_md) rx_relax (RX_RELAX_DISP, pos); \ 162 else rx_linkrelax_dsp (pos); \ 163 F (displacement (v, msz), pos, 2) 164 165 #define id24(a,b2,b3) B3 (0xfb + a, b2, b3) 166 167 static void rx_check_float_support (void); 168 static int rx_intop (expressionS, int, int); 169 static int rx_uintop (expressionS, int); 170 static int rx_disp3op (expressionS); 171 static int rx_disp5op (expressionS *, int); 172 static int rx_disp5op0 (expressionS *, int); 173 static int exp_val (expressionS exp); 174 static expressionS zero_expr (void); 175 static int immediate (expressionS, int, int, int); 176 static int displacement (expressionS, int); 177 static void rtsd_immediate (expressionS); 178 static void rx_range (expressionS, int, int); 179 static void rx_check_v2 (void); 180 static void rx_check_v3 (void); 181 static void rx_check_dfpu (void); 182 183 static int need_flag = 0; 184 static int rx_in_brackets = 0; 185 static int rx_last_token = 0; 186 static char * rx_init_start; 187 static char * rx_last_exp_start = 0; 188 static int sub_op; 189 static int sub_op2; 190 191 #define YYDEBUG 1 192 #define YYERROR_VERBOSE 1 193 194 195 #line 196 "config/rx-parse.c" 196 197 # ifndef YY_CAST 198 # ifdef __cplusplus 199 # define YY_CAST(Type, Val) static_cast<Type> (Val) 200 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) 201 # else 202 # define YY_CAST(Type, Val) ((Type) (Val)) 203 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) 204 # endif 205 # endif 206 # ifndef YY_NULLPTR 207 # if defined __cplusplus 208 # if 201103L <= __cplusplus 209 # define YY_NULLPTR nullptr 210 # else 211 # define YY_NULLPTR 0 212 # endif 213 # else 214 # define YY_NULLPTR ((void*)0) 215 # endif 216 # endif 217 218 /* Use api.header.include to #include this header 219 instead of duplicating it here. */ 220 #ifndef YY_RX_CONFIG_RX_PARSE_H_INCLUDED 221 # define YY_RX_CONFIG_RX_PARSE_H_INCLUDED 222 /* Debug traces. */ 223 #ifndef YYDEBUG 224 # define YYDEBUG 0 225 #endif 226 #if YYDEBUG 227 extern int rx_debug; 228 #endif 229 230 /* Token kinds. */ 231 #ifndef YYTOKENTYPE 232 # define YYTOKENTYPE 233 enum yytokentype 234 { 235 YYEMPTY = -2, 236 YYEOF = 0, /* "end of file" */ 237 YYerror = 256, /* error */ 238 YYUNDEF = 257, /* "invalid token" */ 239 REG = 258, /* REG */ 240 FLAG = 259, /* FLAG */ 241 CREG = 260, /* CREG */ 242 ACC = 261, /* ACC */ 243 DREG = 262, /* DREG */ 244 DREGH = 263, /* DREGH */ 245 DREGL = 264, /* DREGL */ 246 DCREG = 265, /* DCREG */ 247 EXPR = 266, /* EXPR */ 248 UNKNOWN_OPCODE = 267, /* UNKNOWN_OPCODE */ 249 IS_OPCODE = 268, /* IS_OPCODE */ 250 DOT_S = 269, /* DOT_S */ 251 DOT_B = 270, /* DOT_B */ 252 DOT_W = 271, /* DOT_W */ 253 DOT_L = 272, /* DOT_L */ 254 DOT_A = 273, /* DOT_A */ 255 DOT_UB = 274, /* DOT_UB */ 256 DOT_UW = 275, /* DOT_UW */ 257 DOT_D = 276, /* DOT_D */ 258 ABS = 277, /* ABS */ 259 ADC = 278, /* ADC */ 260 ADD = 279, /* ADD */ 261 AND_ = 280, /* AND_ */ 262 BCLR = 281, /* BCLR */ 263 BCND = 282, /* BCND */ 264 BFMOV = 283, /* BFMOV */ 265 BFMOVZ = 284, /* BFMOVZ */ 266 BMCND = 285, /* BMCND */ 267 BNOT = 286, /* BNOT */ 268 BRA = 287, /* BRA */ 269 BRK = 288, /* BRK */ 270 BSET = 289, /* BSET */ 271 BSR = 290, /* BSR */ 272 BTST = 291, /* BTST */ 273 CLRPSW = 292, /* CLRPSW */ 274 CMP = 293, /* CMP */ 275 DABS = 294, /* DABS */ 276 DADD = 295, /* DADD */ 277 DBT = 296, /* DBT */ 278 DCMP = 297, /* DCMP */ 279 DDIV = 298, /* DDIV */ 280 DIV = 299, /* DIV */ 281 DIVU = 300, /* DIVU */ 282 DMOV = 301, /* DMOV */ 283 DMUL = 302, /* DMUL */ 284 DNEG = 303, /* DNEG */ 285 DPOPM = 304, /* DPOPM */ 286 DPUSHM = 305, /* DPUSHM */ 287 DROUND = 306, /* DROUND */ 288 DSQRT = 307, /* DSQRT */ 289 DSUB = 308, /* DSUB */ 290 DTOF = 309, /* DTOF */ 291 DTOI = 310, /* DTOI */ 292 DTOU = 311, /* DTOU */ 293 EDIV = 312, /* EDIV */ 294 EDIVU = 313, /* EDIVU */ 295 EMACA = 314, /* EMACA */ 296 EMSBA = 315, /* EMSBA */ 297 EMUL = 316, /* EMUL */ 298 EMULA = 317, /* EMULA */ 299 EMULU = 318, /* EMULU */ 300 FADD = 319, /* FADD */ 301 FCMP = 320, /* FCMP */ 302 FDIV = 321, /* FDIV */ 303 FMUL = 322, /* FMUL */ 304 FREIT = 323, /* FREIT */ 305 FSUB = 324, /* FSUB */ 306 FSQRT = 325, /* FSQRT */ 307 FTOD = 326, /* FTOD */ 308 FTOI = 327, /* FTOI */ 309 FTOU = 328, /* FTOU */ 310 INT = 329, /* INT */ 311 ITOD = 330, /* ITOD */ 312 ITOF = 331, /* ITOF */ 313 JMP = 332, /* JMP */ 314 JSR = 333, /* JSR */ 315 MACHI = 334, /* MACHI */ 316 MACLH = 335, /* MACLH */ 317 MACLO = 336, /* MACLO */ 318 MAX = 337, /* MAX */ 319 MIN = 338, /* MIN */ 320 MOV = 339, /* MOV */ 321 MOVCO = 340, /* MOVCO */ 322 MOVLI = 341, /* MOVLI */ 323 MOVU = 342, /* MOVU */ 324 MSBHI = 343, /* MSBHI */ 325 MSBLH = 344, /* MSBLH */ 326 MSBLO = 345, /* MSBLO */ 327 MUL = 346, /* MUL */ 328 MULHI = 347, /* MULHI */ 329 MULLH = 348, /* MULLH */ 330 MULLO = 349, /* MULLO */ 331 MULU = 350, /* MULU */ 332 MVFACHI = 351, /* MVFACHI */ 333 MVFACGU = 352, /* MVFACGU */ 334 MVFACMI = 353, /* MVFACMI */ 335 MVFACLO = 354, /* MVFACLO */ 336 MVFC = 355, /* MVFC */ 337 MVFDC = 356, /* MVFDC */ 338 MVFDR = 357, /* MVFDR */ 339 MVTACGU = 358, /* MVTACGU */ 340 MVTACHI = 359, /* MVTACHI */ 341 MVTACLO = 360, /* MVTACLO */ 342 MVTC = 361, /* MVTC */ 343 MVTDC = 362, /* MVTDC */ 344 MVTIPL = 363, /* MVTIPL */ 345 NEG = 364, /* NEG */ 346 NOP = 365, /* NOP */ 347 NOT = 366, /* NOT */ 348 OR = 367, /* OR */ 349 POP = 368, /* POP */ 350 POPC = 369, /* POPC */ 351 POPM = 370, /* POPM */ 352 PUSH = 371, /* PUSH */ 353 PUSHA = 372, /* PUSHA */ 354 PUSHC = 373, /* PUSHC */ 355 PUSHM = 374, /* PUSHM */ 356 RACL = 375, /* RACL */ 357 RACW = 376, /* RACW */ 358 RDACL = 377, /* RDACL */ 359 RDACW = 378, /* RDACW */ 360 REIT = 379, /* REIT */ 361 REVL = 380, /* REVL */ 362 REVW = 381, /* REVW */ 363 RMPA = 382, /* RMPA */ 364 ROLC = 383, /* ROLC */ 365 RORC = 384, /* RORC */ 366 ROTL = 385, /* ROTL */ 367 ROTR = 386, /* ROTR */ 368 ROUND = 387, /* ROUND */ 369 RSTR = 388, /* RSTR */ 370 RTE = 389, /* RTE */ 371 RTFI = 390, /* RTFI */ 372 RTS = 391, /* RTS */ 373 RTSD = 392, /* RTSD */ 374 SAT = 393, /* SAT */ 375 SATR = 394, /* SATR */ 376 SAVE = 395, /* SAVE */ 377 SBB = 396, /* SBB */ 378 SCCND = 397, /* SCCND */ 379 SCMPU = 398, /* SCMPU */ 380 SETPSW = 399, /* SETPSW */ 381 SHAR = 400, /* SHAR */ 382 SHLL = 401, /* SHLL */ 383 SHLR = 402, /* SHLR */ 384 SMOVB = 403, /* SMOVB */ 385 SMOVF = 404, /* SMOVF */ 386 SMOVU = 405, /* SMOVU */ 387 SSTR = 406, /* SSTR */ 388 STNZ = 407, /* STNZ */ 389 STOP = 408, /* STOP */ 390 STZ = 409, /* STZ */ 391 SUB = 410, /* SUB */ 392 SUNTIL = 411, /* SUNTIL */ 393 SWHILE = 412, /* SWHILE */ 394 TST = 413, /* TST */ 395 UTOD = 414, /* UTOD */ 396 UTOF = 415, /* UTOF */ 397 WAIT = 416, /* WAIT */ 398 XCHG = 417, /* XCHG */ 399 XOR = 418 /* XOR */ 400 }; 401 typedef enum yytokentype yytoken_kind_t; 402 #endif 403 /* Token kinds. */ 404 #define YYEMPTY -2 405 #define YYEOF 0 406 #define YYerror 256 407 #define YYUNDEF 257 408 #define REG 258 409 #define FLAG 259 410 #define CREG 260 411 #define ACC 261 412 #define DREG 262 413 #define DREGH 263 414 #define DREGL 264 415 #define DCREG 265 416 #define EXPR 266 417 #define UNKNOWN_OPCODE 267 418 #define IS_OPCODE 268 419 #define DOT_S 269 420 #define DOT_B 270 421 #define DOT_W 271 422 #define DOT_L 272 423 #define DOT_A 273 424 #define DOT_UB 274 425 #define DOT_UW 275 426 #define DOT_D 276 427 #define ABS 277 428 #define ADC 278 429 #define ADD 279 430 #define AND_ 280 431 #define BCLR 281 432 #define BCND 282 433 #define BFMOV 283 434 #define BFMOVZ 284 435 #define BMCND 285 436 #define BNOT 286 437 #define BRA 287 438 #define BRK 288 439 #define BSET 289 440 #define BSR 290 441 #define BTST 291 442 #define CLRPSW 292 443 #define CMP 293 444 #define DABS 294 445 #define DADD 295 446 #define DBT 296 447 #define DCMP 297 448 #define DDIV 298 449 #define DIV 299 450 #define DIVU 300 451 #define DMOV 301 452 #define DMUL 302 453 #define DNEG 303 454 #define DPOPM 304 455 #define DPUSHM 305 456 #define DROUND 306 457 #define DSQRT 307 458 #define DSUB 308 459 #define DTOF 309 460 #define DTOI 310 461 #define DTOU 311 462 #define EDIV 312 463 #define EDIVU 313 464 #define EMACA 314 465 #define EMSBA 315 466 #define EMUL 316 467 #define EMULA 317 468 #define EMULU 318 469 #define FADD 319 470 #define FCMP 320 471 #define FDIV 321 472 #define FMUL 322 473 #define FREIT 323 474 #define FSUB 324 475 #define FSQRT 325 476 #define FTOD 326 477 #define FTOI 327 478 #define FTOU 328 479 #define INT 329 480 #define ITOD 330 481 #define ITOF 331 482 #define JMP 332 483 #define JSR 333 484 #define MACHI 334 485 #define MACLH 335 486 #define MACLO 336 487 #define MAX 337 488 #define MIN 338 489 #define MOV 339 490 #define MOVCO 340 491 #define MOVLI 341 492 #define MOVU 342 493 #define MSBHI 343 494 #define MSBLH 344 495 #define MSBLO 345 496 #define MUL 346 497 #define MULHI 347 498 #define MULLH 348 499 #define MULLO 349 500 #define MULU 350 501 #define MVFACHI 351 502 #define MVFACGU 352 503 #define MVFACMI 353 504 #define MVFACLO 354 505 #define MVFC 355 506 #define MVFDC 356 507 #define MVFDR 357 508 #define MVTACGU 358 509 #define MVTACHI 359 510 #define MVTACLO 360 511 #define MVTC 361 512 #define MVTDC 362 513 #define MVTIPL 363 514 #define NEG 364 515 #define NOP 365 516 #define NOT 366 517 #define OR 367 518 #define POP 368 519 #define POPC 369 520 #define POPM 370 521 #define PUSH 371 522 #define PUSHA 372 523 #define PUSHC 373 524 #define PUSHM 374 525 #define RACL 375 526 #define RACW 376 527 #define RDACL 377 528 #define RDACW 378 529 #define REIT 379 530 #define REVL 380 531 #define REVW 381 532 #define RMPA 382 533 #define ROLC 383 534 #define RORC 384 535 #define ROTL 385 536 #define ROTR 386 537 #define ROUND 387 538 #define RSTR 388 539 #define RTE 389 540 #define RTFI 390 541 #define RTS 391 542 #define RTSD 392 543 #define SAT 393 544 #define SATR 394 545 #define SAVE 395 546 #define SBB 396 547 #define SCCND 397 548 #define SCMPU 398 549 #define SETPSW 399 550 #define SHAR 400 551 #define SHLL 401 552 #define SHLR 402 553 #define SMOVB 403 554 #define SMOVF 404 555 #define SMOVU 405 556 #define SSTR 406 557 #define STNZ 407 558 #define STOP 408 559 #define STZ 409 560 #define SUB 410 561 #define SUNTIL 411 562 #define SWHILE 412 563 #define TST 413 564 #define UTOD 414 565 #define UTOF 415 566 #define WAIT 416 567 #define XCHG 417 568 #define XOR 418 569 570 /* Value type. */ 571 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 572 union YYSTYPE 573 { 574 #line 140 "./config/rx-parse.y" 575 576 int regno; 577 expressionS exp; 578 579 #line 580 "config/rx-parse.c" 580 581 }; 582 typedef union YYSTYPE YYSTYPE; 583 # define YYSTYPE_IS_TRIVIAL 1 584 # define YYSTYPE_IS_DECLARED 1 585 #endif 586 587 588 extern YYSTYPE rx_lval; 589 590 591 int rx_parse (void); 592 593 594 #endif /* !YY_RX_CONFIG_RX_PARSE_H_INCLUDED */ 595 /* Symbol kind. */ 596 enum yysymbol_kind_t 597 { 598 YYSYMBOL_YYEMPTY = -2, 599 YYSYMBOL_YYEOF = 0, /* "end of file" */ 600 YYSYMBOL_YYerror = 1, /* error */ 601 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ 602 YYSYMBOL_REG = 3, /* REG */ 603 YYSYMBOL_FLAG = 4, /* FLAG */ 604 YYSYMBOL_CREG = 5, /* CREG */ 605 YYSYMBOL_ACC = 6, /* ACC */ 606 YYSYMBOL_DREG = 7, /* DREG */ 607 YYSYMBOL_DREGH = 8, /* DREGH */ 608 YYSYMBOL_DREGL = 9, /* DREGL */ 609 YYSYMBOL_DCREG = 10, /* DCREG */ 610 YYSYMBOL_EXPR = 11, /* EXPR */ 611 YYSYMBOL_UNKNOWN_OPCODE = 12, /* UNKNOWN_OPCODE */ 612 YYSYMBOL_IS_OPCODE = 13, /* IS_OPCODE */ 613 YYSYMBOL_DOT_S = 14, /* DOT_S */ 614 YYSYMBOL_DOT_B = 15, /* DOT_B */ 615 YYSYMBOL_DOT_W = 16, /* DOT_W */ 616 YYSYMBOL_DOT_L = 17, /* DOT_L */ 617 YYSYMBOL_DOT_A = 18, /* DOT_A */ 618 YYSYMBOL_DOT_UB = 19, /* DOT_UB */ 619 YYSYMBOL_DOT_UW = 20, /* DOT_UW */ 620 YYSYMBOL_DOT_D = 21, /* DOT_D */ 621 YYSYMBOL_ABS = 22, /* ABS */ 622 YYSYMBOL_ADC = 23, /* ADC */ 623 YYSYMBOL_ADD = 24, /* ADD */ 624 YYSYMBOL_AND_ = 25, /* AND_ */ 625 YYSYMBOL_BCLR = 26, /* BCLR */ 626 YYSYMBOL_BCND = 27, /* BCND */ 627 YYSYMBOL_BFMOV = 28, /* BFMOV */ 628 YYSYMBOL_BFMOVZ = 29, /* BFMOVZ */ 629 YYSYMBOL_BMCND = 30, /* BMCND */ 630 YYSYMBOL_BNOT = 31, /* BNOT */ 631 YYSYMBOL_BRA = 32, /* BRA */ 632 YYSYMBOL_BRK = 33, /* BRK */ 633 YYSYMBOL_BSET = 34, /* BSET */ 634 YYSYMBOL_BSR = 35, /* BSR */ 635 YYSYMBOL_BTST = 36, /* BTST */ 636 YYSYMBOL_CLRPSW = 37, /* CLRPSW */ 637 YYSYMBOL_CMP = 38, /* CMP */ 638 YYSYMBOL_DABS = 39, /* DABS */ 639 YYSYMBOL_DADD = 40, /* DADD */ 640 YYSYMBOL_DBT = 41, /* DBT */ 641 YYSYMBOL_DCMP = 42, /* DCMP */ 642 YYSYMBOL_DDIV = 43, /* DDIV */ 643 YYSYMBOL_DIV = 44, /* DIV */ 644 YYSYMBOL_DIVU = 45, /* DIVU */ 645 YYSYMBOL_DMOV = 46, /* DMOV */ 646 YYSYMBOL_DMUL = 47, /* DMUL */ 647 YYSYMBOL_DNEG = 48, /* DNEG */ 648 YYSYMBOL_DPOPM = 49, /* DPOPM */ 649 YYSYMBOL_DPUSHM = 50, /* DPUSHM */ 650 YYSYMBOL_DROUND = 51, /* DROUND */ 651 YYSYMBOL_DSQRT = 52, /* DSQRT */ 652 YYSYMBOL_DSUB = 53, /* DSUB */ 653 YYSYMBOL_DTOF = 54, /* DTOF */ 654 YYSYMBOL_DTOI = 55, /* DTOI */ 655 YYSYMBOL_DTOU = 56, /* DTOU */ 656 YYSYMBOL_EDIV = 57, /* EDIV */ 657 YYSYMBOL_EDIVU = 58, /* EDIVU */ 658 YYSYMBOL_EMACA = 59, /* EMACA */ 659 YYSYMBOL_EMSBA = 60, /* EMSBA */ 660 YYSYMBOL_EMUL = 61, /* EMUL */ 661 YYSYMBOL_EMULA = 62, /* EMULA */ 662 YYSYMBOL_EMULU = 63, /* EMULU */ 663 YYSYMBOL_FADD = 64, /* FADD */ 664 YYSYMBOL_FCMP = 65, /* FCMP */ 665 YYSYMBOL_FDIV = 66, /* FDIV */ 666 YYSYMBOL_FMUL = 67, /* FMUL */ 667 YYSYMBOL_FREIT = 68, /* FREIT */ 668 YYSYMBOL_FSUB = 69, /* FSUB */ 669 YYSYMBOL_FSQRT = 70, /* FSQRT */ 670 YYSYMBOL_FTOD = 71, /* FTOD */ 671 YYSYMBOL_FTOI = 72, /* FTOI */ 672 YYSYMBOL_FTOU = 73, /* FTOU */ 673 YYSYMBOL_INT = 74, /* INT */ 674 YYSYMBOL_ITOD = 75, /* ITOD */ 675 YYSYMBOL_ITOF = 76, /* ITOF */ 676 YYSYMBOL_JMP = 77, /* JMP */ 677 YYSYMBOL_JSR = 78, /* JSR */ 678 YYSYMBOL_MACHI = 79, /* MACHI */ 679 YYSYMBOL_MACLH = 80, /* MACLH */ 680 YYSYMBOL_MACLO = 81, /* MACLO */ 681 YYSYMBOL_MAX = 82, /* MAX */ 682 YYSYMBOL_MIN = 83, /* MIN */ 683 YYSYMBOL_MOV = 84, /* MOV */ 684 YYSYMBOL_MOVCO = 85, /* MOVCO */ 685 YYSYMBOL_MOVLI = 86, /* MOVLI */ 686 YYSYMBOL_MOVU = 87, /* MOVU */ 687 YYSYMBOL_MSBHI = 88, /* MSBHI */ 688 YYSYMBOL_MSBLH = 89, /* MSBLH */ 689 YYSYMBOL_MSBLO = 90, /* MSBLO */ 690 YYSYMBOL_MUL = 91, /* MUL */ 691 YYSYMBOL_MULHI = 92, /* MULHI */ 692 YYSYMBOL_MULLH = 93, /* MULLH */ 693 YYSYMBOL_MULLO = 94, /* MULLO */ 694 YYSYMBOL_MULU = 95, /* MULU */ 695 YYSYMBOL_MVFACHI = 96, /* MVFACHI */ 696 YYSYMBOL_MVFACGU = 97, /* MVFACGU */ 697 YYSYMBOL_MVFACMI = 98, /* MVFACMI */ 698 YYSYMBOL_MVFACLO = 99, /* MVFACLO */ 699 YYSYMBOL_MVFC = 100, /* MVFC */ 700 YYSYMBOL_MVFDC = 101, /* MVFDC */ 701 YYSYMBOL_MVFDR = 102, /* MVFDR */ 702 YYSYMBOL_MVTACGU = 103, /* MVTACGU */ 703 YYSYMBOL_MVTACHI = 104, /* MVTACHI */ 704 YYSYMBOL_MVTACLO = 105, /* MVTACLO */ 705 YYSYMBOL_MVTC = 106, /* MVTC */ 706 YYSYMBOL_MVTDC = 107, /* MVTDC */ 707 YYSYMBOL_MVTIPL = 108, /* MVTIPL */ 708 YYSYMBOL_NEG = 109, /* NEG */ 709 YYSYMBOL_NOP = 110, /* NOP */ 710 YYSYMBOL_NOT = 111, /* NOT */ 711 YYSYMBOL_OR = 112, /* OR */ 712 YYSYMBOL_POP = 113, /* POP */ 713 YYSYMBOL_POPC = 114, /* POPC */ 714 YYSYMBOL_POPM = 115, /* POPM */ 715 YYSYMBOL_PUSH = 116, /* PUSH */ 716 YYSYMBOL_PUSHA = 117, /* PUSHA */ 717 YYSYMBOL_PUSHC = 118, /* PUSHC */ 718 YYSYMBOL_PUSHM = 119, /* PUSHM */ 719 YYSYMBOL_RACL = 120, /* RACL */ 720 YYSYMBOL_RACW = 121, /* RACW */ 721 YYSYMBOL_RDACL = 122, /* RDACL */ 722 YYSYMBOL_RDACW = 123, /* RDACW */ 723 YYSYMBOL_REIT = 124, /* REIT */ 724 YYSYMBOL_REVL = 125, /* REVL */ 725 YYSYMBOL_REVW = 126, /* REVW */ 726 YYSYMBOL_RMPA = 127, /* RMPA */ 727 YYSYMBOL_ROLC = 128, /* ROLC */ 728 YYSYMBOL_RORC = 129, /* RORC */ 729 YYSYMBOL_ROTL = 130, /* ROTL */ 730 YYSYMBOL_ROTR = 131, /* ROTR */ 731 YYSYMBOL_ROUND = 132, /* ROUND */ 732 YYSYMBOL_RSTR = 133, /* RSTR */ 733 YYSYMBOL_RTE = 134, /* RTE */ 734 YYSYMBOL_RTFI = 135, /* RTFI */ 735 YYSYMBOL_RTS = 136, /* RTS */ 736 YYSYMBOL_RTSD = 137, /* RTSD */ 737 YYSYMBOL_SAT = 138, /* SAT */ 738 YYSYMBOL_SATR = 139, /* SATR */ 739 YYSYMBOL_SAVE = 140, /* SAVE */ 740 YYSYMBOL_SBB = 141, /* SBB */ 741 YYSYMBOL_SCCND = 142, /* SCCND */ 742 YYSYMBOL_SCMPU = 143, /* SCMPU */ 743 YYSYMBOL_SETPSW = 144, /* SETPSW */ 744 YYSYMBOL_SHAR = 145, /* SHAR */ 745 YYSYMBOL_SHLL = 146, /* SHLL */ 746 YYSYMBOL_SHLR = 147, /* SHLR */ 747 YYSYMBOL_SMOVB = 148, /* SMOVB */ 748 YYSYMBOL_SMOVF = 149, /* SMOVF */ 749 YYSYMBOL_SMOVU = 150, /* SMOVU */ 750 YYSYMBOL_SSTR = 151, /* SSTR */ 751 YYSYMBOL_STNZ = 152, /* STNZ */ 752 YYSYMBOL_STOP = 153, /* STOP */ 753 YYSYMBOL_STZ = 154, /* STZ */ 754 YYSYMBOL_SUB = 155, /* SUB */ 755 YYSYMBOL_SUNTIL = 156, /* SUNTIL */ 756 YYSYMBOL_SWHILE = 157, /* SWHILE */ 757 YYSYMBOL_TST = 158, /* TST */ 758 YYSYMBOL_UTOD = 159, /* UTOD */ 759 YYSYMBOL_UTOF = 160, /* UTOF */ 760 YYSYMBOL_WAIT = 161, /* WAIT */ 761 YYSYMBOL_XCHG = 162, /* XCHG */ 762 YYSYMBOL_XOR = 163, /* XOR */ 763 YYSYMBOL_164_ = 164, /* '#' */ 764 YYSYMBOL_165_ = 165, /* ',' */ 765 YYSYMBOL_166_ = 166, /* '[' */ 766 YYSYMBOL_167_ = 167, /* ']' */ 767 YYSYMBOL_168_ = 168, /* '-' */ 768 YYSYMBOL_169_ = 169, /* '+' */ 769 YYSYMBOL_YYACCEPT = 170, /* $accept */ 770 YYSYMBOL_statement = 171, /* statement */ 771 YYSYMBOL_172_1 = 172, /* $@1 */ 772 YYSYMBOL_173_2 = 173, /* $@2 */ 773 YYSYMBOL_174_3 = 174, /* $@3 */ 774 YYSYMBOL_175_4 = 175, /* $@4 */ 775 YYSYMBOL_176_5 = 176, /* $@5 */ 776 YYSYMBOL_177_6 = 177, /* $@6 */ 777 YYSYMBOL_178_7 = 178, /* $@7 */ 778 YYSYMBOL_179_8 = 179, /* $@8 */ 779 YYSYMBOL_180_9 = 180, /* $@9 */ 780 YYSYMBOL_181_10 = 181, /* $@10 */ 781 YYSYMBOL_182_11 = 182, /* $@11 */ 782 YYSYMBOL_183_12 = 183, /* $@12 */ 783 YYSYMBOL_184_13 = 184, /* $@13 */ 784 YYSYMBOL_185_14 = 185, /* $@14 */ 785 YYSYMBOL_186_15 = 186, /* $@15 */ 786 YYSYMBOL_187_16 = 187, /* $@16 */ 787 YYSYMBOL_188_17 = 188, /* $@17 */ 788 YYSYMBOL_189_18 = 189, /* $@18 */ 789 YYSYMBOL_190_19 = 190, /* $@19 */ 790 YYSYMBOL_191_20 = 191, /* $@20 */ 791 YYSYMBOL_192_21 = 192, /* $@21 */ 792 YYSYMBOL_193_22 = 193, /* $@22 */ 793 YYSYMBOL_194_23 = 194, /* $@23 */ 794 YYSYMBOL_195_24 = 195, /* $@24 */ 795 YYSYMBOL_196_25 = 196, /* $@25 */ 796 YYSYMBOL_197_26 = 197, /* $@26 */ 797 YYSYMBOL_198_27 = 198, /* $@27 */ 798 YYSYMBOL_199_28 = 199, /* $@28 */ 799 YYSYMBOL_200_29 = 200, /* $@29 */ 800 YYSYMBOL_201_30 = 201, /* $@30 */ 801 YYSYMBOL_202_31 = 202, /* $@31 */ 802 YYSYMBOL_203_32 = 203, /* $@32 */ 803 YYSYMBOL_204_33 = 204, /* $@33 */ 804 YYSYMBOL_205_34 = 205, /* $@34 */ 805 YYSYMBOL_206_35 = 206, /* $@35 */ 806 YYSYMBOL_207_36 = 207, /* $@36 */ 807 YYSYMBOL_208_37 = 208, /* $@37 */ 808 YYSYMBOL_209_38 = 209, /* $@38 */ 809 YYSYMBOL_210_39 = 210, /* $@39 */ 810 YYSYMBOL_211_40 = 211, /* $@40 */ 811 YYSYMBOL_212_41 = 212, /* $@41 */ 812 YYSYMBOL_213_42 = 213, /* $@42 */ 813 YYSYMBOL_214_43 = 214, /* $@43 */ 814 YYSYMBOL_215_44 = 215, /* $@44 */ 815 YYSYMBOL_216_45 = 216, /* $@45 */ 816 YYSYMBOL_217_46 = 217, /* $@46 */ 817 YYSYMBOL_218_47 = 218, /* $@47 */ 818 YYSYMBOL_219_48 = 219, /* $@48 */ 819 YYSYMBOL_220_49 = 220, /* $@49 */ 820 YYSYMBOL_221_50 = 221, /* $@50 */ 821 YYSYMBOL_222_51 = 222, /* $@51 */ 822 YYSYMBOL_223_52 = 223, /* $@52 */ 823 YYSYMBOL_224_53 = 224, /* $@53 */ 824 YYSYMBOL_225_54 = 225, /* $@54 */ 825 YYSYMBOL_226_55 = 226, /* $@55 */ 826 YYSYMBOL_227_56 = 227, /* $@56 */ 827 YYSYMBOL_228_57 = 228, /* $@57 */ 828 YYSYMBOL_229_58 = 229, /* $@58 */ 829 YYSYMBOL_230_59 = 230, /* $@59 */ 830 YYSYMBOL_231_60 = 231, /* $@60 */ 831 YYSYMBOL_op_subadd = 232, /* op_subadd */ 832 YYSYMBOL_op_dp20_rm_l = 233, /* op_dp20_rm_l */ 833 YYSYMBOL_op_dp20_rm = 234, /* op_dp20_rm */ 834 YYSYMBOL_op_dp20_i = 235, /* op_dp20_i */ 835 YYSYMBOL_op_dp20_rim = 236, /* op_dp20_rim */ 836 YYSYMBOL_op_dp20_rim_l = 237, /* op_dp20_rim_l */ 837 YYSYMBOL_op_dp20_rr = 238, /* op_dp20_rr */ 838 YYSYMBOL_op_dp20_r = 239, /* op_dp20_r */ 839 YYSYMBOL_op_dp20_ri = 240, /* op_dp20_ri */ 840 YYSYMBOL_241_61 = 241, /* $@61 */ 841 YYSYMBOL_op_xchg = 242, /* op_xchg */ 842 YYSYMBOL_op_shift_rot = 243, /* op_shift_rot */ 843 YYSYMBOL_op_shift = 244, /* op_shift */ 844 YYSYMBOL_float3_op = 245, /* float3_op */ 845 YYSYMBOL_float2_op = 246, /* float2_op */ 846 YYSYMBOL_247_62 = 247, /* $@62 */ 847 YYSYMBOL_float2_op_ni = 248, /* float2_op_ni */ 848 YYSYMBOL_249_63 = 249, /* $@63 */ 849 YYSYMBOL_250_64 = 250, /* $@64 */ 850 YYSYMBOL_mvfa_op = 251, /* mvfa_op */ 851 YYSYMBOL_252_65 = 252, /* $@65 */ 852 YYSYMBOL_op_xor = 253, /* op_xor */ 853 YYSYMBOL_op_bfield = 254, /* op_bfield */ 854 YYSYMBOL_255_66 = 255, /* $@66 */ 855 YYSYMBOL_op_save_rstr = 256, /* op_save_rstr */ 856 YYSYMBOL_double2_op = 257, /* double2_op */ 857 YYSYMBOL_double3_op = 258, /* double3_op */ 858 YYSYMBOL_disp = 259, /* disp */ 859 YYSYMBOL_flag = 260, /* flag */ 860 YYSYMBOL_261_67 = 261, /* $@67 */ 861 YYSYMBOL_memex = 262, /* memex */ 862 YYSYMBOL_bwl = 263, /* bwl */ 863 YYSYMBOL_bw = 264, /* bw */ 864 YYSYMBOL_opt_l = 265, /* opt_l */ 865 YYSYMBOL_opt_b = 266 /* opt_b */ 866 }; 867 typedef enum yysymbol_kind_t yysymbol_kind_t; 868 869 870 871 872 #ifdef short 873 # undef short 874 #endif 875 876 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure 877 <limits.h> and (if available) <stdint.h> are included 878 so that the code can choose integer types of a good width. */ 879 880 #ifndef __PTRDIFF_MAX__ 881 # include <limits.h> /* INFRINGES ON USER NAME SPACE */ 882 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 883 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */ 884 # define YY_STDINT_H 885 # endif 886 #endif 887 888 /* Narrow types that promote to a signed type and that can represent a 889 signed or unsigned integer of at least N bits. In tables they can 890 save space and decrease cache pressure. Promoting to a signed type 891 helps avoid bugs in integer arithmetic. */ 892 893 #ifdef __INT_LEAST8_MAX__ 894 typedef __INT_LEAST8_TYPE__ yytype_int8; 895 #elif defined YY_STDINT_H 896 typedef int_least8_t yytype_int8; 897 #else 898 typedef signed char yytype_int8; 899 #endif 900 901 #ifdef __INT_LEAST16_MAX__ 902 typedef __INT_LEAST16_TYPE__ yytype_int16; 903 #elif defined YY_STDINT_H 904 typedef int_least16_t yytype_int16; 905 #else 906 typedef short yytype_int16; 907 #endif 908 909 /* Work around bug in HP-UX 11.23, which defines these macros 910 incorrectly for preprocessor constants. This workaround can likely 911 be removed in 2023, as HPE has promised support for HP-UX 11.23 912 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of 913 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */ 914 #ifdef __hpux 915 # undef UINT_LEAST8_MAX 916 # undef UINT_LEAST16_MAX 917 # define UINT_LEAST8_MAX 255 918 # define UINT_LEAST16_MAX 65535 919 #endif 920 921 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ 922 typedef __UINT_LEAST8_TYPE__ yytype_uint8; 923 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ 924 && UINT_LEAST8_MAX <= INT_MAX) 925 typedef uint_least8_t yytype_uint8; 926 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX 927 typedef unsigned char yytype_uint8; 928 #else 929 typedef short yytype_uint8; 930 #endif 931 932 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ 933 typedef __UINT_LEAST16_TYPE__ yytype_uint16; 934 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ 935 && UINT_LEAST16_MAX <= INT_MAX) 936 typedef uint_least16_t yytype_uint16; 937 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX 938 typedef unsigned short yytype_uint16; 939 #else 940 typedef int yytype_uint16; 941 #endif 942 943 #ifndef YYPTRDIFF_T 944 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ 945 # define YYPTRDIFF_T __PTRDIFF_TYPE__ 946 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ 947 # elif defined PTRDIFF_MAX 948 # ifndef ptrdiff_t 949 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 950 # endif 951 # define YYPTRDIFF_T ptrdiff_t 952 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX 953 # else 954 # define YYPTRDIFF_T long 955 # define YYPTRDIFF_MAXIMUM LONG_MAX 956 # endif 957 #endif 958 959 #ifndef YYSIZE_T 960 # ifdef __SIZE_TYPE__ 961 # define YYSIZE_T __SIZE_TYPE__ 962 # elif defined size_t 963 # define YYSIZE_T size_t 964 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ 965 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 966 # define YYSIZE_T size_t 967 # else 968 # define YYSIZE_T unsigned 969 # endif 970 #endif 971 972 #define YYSIZE_MAXIMUM \ 973 YY_CAST (YYPTRDIFF_T, \ 974 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ 975 ? YYPTRDIFF_MAXIMUM \ 976 : YY_CAST (YYSIZE_T, -1))) 977 978 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) 979 980 981 /* Stored state numbers (used for stacks). */ 982 typedef yytype_int16 yy_state_t; 983 984 /* State numbers in computations. */ 985 typedef int yy_state_fast_t; 986 987 #ifndef YY_ 988 # if defined YYENABLE_NLS && YYENABLE_NLS 989 # if ENABLE_NLS 990 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 991 # define YY_(Msgid) dgettext ("bison-runtime", Msgid) 992 # endif 993 # endif 994 # ifndef YY_ 995 # define YY_(Msgid) Msgid 996 # endif 997 #endif 998 999 1000 #ifndef YY_ATTRIBUTE_PURE 1001 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) 1002 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) 1003 # else 1004 # define YY_ATTRIBUTE_PURE 1005 # endif 1006 #endif 1007 1008 #ifndef YY_ATTRIBUTE_UNUSED 1009 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) 1010 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) 1011 # else 1012 # define YY_ATTRIBUTE_UNUSED 1013 # endif 1014 #endif 1015 1016 /* Suppress unused-variable warnings by "using" E. */ 1017 #if ! defined lint || defined __GNUC__ 1018 # define YY_USE(E) ((void) (E)) 1019 #else 1020 # define YY_USE(E) /* empty */ 1021 #endif 1022 1023 /* Suppress an incorrect diagnostic about yylval being uninitialized. */ 1024 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ 1025 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407 1026 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 1027 _Pragma ("GCC diagnostic push") \ 1028 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") 1029 # else 1030 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ 1031 _Pragma ("GCC diagnostic push") \ 1032 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ 1033 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") 1034 # endif 1035 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \ 1036 _Pragma ("GCC diagnostic pop") 1037 #else 1038 # define YY_INITIAL_VALUE(Value) Value 1039 #endif 1040 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1041 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 1042 # define YY_IGNORE_MAYBE_UNINITIALIZED_END 1043 #endif 1044 #ifndef YY_INITIAL_VALUE 1045 # define YY_INITIAL_VALUE(Value) /* Nothing. */ 1046 #endif 1047 1048 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ 1049 # define YY_IGNORE_USELESS_CAST_BEGIN \ 1050 _Pragma ("GCC diagnostic push") \ 1051 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") 1052 # define YY_IGNORE_USELESS_CAST_END \ 1053 _Pragma ("GCC diagnostic pop") 1054 #endif 1055 #ifndef YY_IGNORE_USELESS_CAST_BEGIN 1056 # define YY_IGNORE_USELESS_CAST_BEGIN 1057 # define YY_IGNORE_USELESS_CAST_END 1058 #endif 1059 1060 1061 #define YY_ASSERT(E) ((void) (0 && (E))) 1062 1063 #if !defined yyoverflow 1064 1065 /* The parser invokes alloca or malloc; define the necessary symbols. */ 1066 1067 # ifdef YYSTACK_USE_ALLOCA 1068 # if YYSTACK_USE_ALLOCA 1069 # ifdef __GNUC__ 1070 # define YYSTACK_ALLOC __builtin_alloca 1071 # elif defined __BUILTIN_VA_ARG_INCR 1072 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 1073 # elif defined _AIX 1074 # define YYSTACK_ALLOC __alloca 1075 # elif defined _MSC_VER 1076 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 1077 # define alloca _alloca 1078 # else 1079 # define YYSTACK_ALLOC alloca 1080 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS 1081 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 1082 /* Use EXIT_SUCCESS as a witness for stdlib.h. */ 1083 # ifndef EXIT_SUCCESS 1084 # define EXIT_SUCCESS 0 1085 # endif 1086 # endif 1087 # endif 1088 # endif 1089 # endif 1090 1091 # ifdef YYSTACK_ALLOC 1092 /* Pacify GCC's 'empty if-body' warning. */ 1093 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 1094 # ifndef YYSTACK_ALLOC_MAXIMUM 1095 /* The OS might guarantee only one guard page at the bottom of the stack, 1096 and a page size can be as small as 4096 bytes. So we cannot safely 1097 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 1098 to allow for a few compiler-allocated temporary stack slots. */ 1099 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 1100 # endif 1101 # else 1102 # define YYSTACK_ALLOC YYMALLOC 1103 # define YYSTACK_FREE YYFREE 1104 # ifndef YYSTACK_ALLOC_MAXIMUM 1105 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 1106 # endif 1107 # if (defined __cplusplus && ! defined EXIT_SUCCESS \ 1108 && ! ((defined YYMALLOC || defined malloc) \ 1109 && (defined YYFREE || defined free))) 1110 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 1111 # ifndef EXIT_SUCCESS 1112 # define EXIT_SUCCESS 0 1113 # endif 1114 # endif 1115 # ifndef YYMALLOC 1116 # define YYMALLOC malloc 1117 # if ! defined malloc && ! defined EXIT_SUCCESS 1118 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 1119 # endif 1120 # endif 1121 # ifndef YYFREE 1122 # define YYFREE free 1123 # if ! defined free && ! defined EXIT_SUCCESS 1124 void free (void *); /* INFRINGES ON USER NAME SPACE */ 1125 # endif 1126 # endif 1127 # endif 1128 #endif /* !defined yyoverflow */ 1129 1130 #if (! defined yyoverflow \ 1131 && (! defined __cplusplus \ 1132 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 1133 1134 /* A type that is properly aligned for any stack member. */ 1135 union yyalloc 1136 { 1137 yy_state_t yyss_alloc; 1138 YYSTYPE yyvs_alloc; 1139 }; 1140 1141 /* The size of the maximum gap between one aligned stack and the next. */ 1142 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) 1143 1144 /* The size of an array large to enough to hold all stacks, each with 1145 N elements. */ 1146 # define YYSTACK_BYTES(N) \ 1147 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ 1148 + YYSTACK_GAP_MAXIMUM) 1149 1150 # define YYCOPY_NEEDED 1 1151 1152 /* Relocate STACK from its old location to the new one. The 1153 local variables YYSIZE and YYSTACKSIZE give the old and new number of 1154 elements in the stack, and YYPTR gives the new location of the 1155 stack. Advance YYPTR to a properly aligned location for the next 1156 stack. */ 1157 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 1158 do \ 1159 { \ 1160 YYPTRDIFF_T yynewbytes; \ 1161 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 1162 Stack = &yyptr->Stack_alloc; \ 1163 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ 1164 yyptr += yynewbytes / YYSIZEOF (*yyptr); \ 1165 } \ 1166 while (0) 1167 1168 #endif 1169 1170 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED 1171 /* Copy COUNT objects from SRC to DST. The source and destination do 1172 not overlap. */ 1173 # ifndef YYCOPY 1174 # if defined __GNUC__ && 1 < __GNUC__ 1175 # define YYCOPY(Dst, Src, Count) \ 1176 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) 1177 # else 1178 # define YYCOPY(Dst, Src, Count) \ 1179 do \ 1180 { \ 1181 YYPTRDIFF_T yyi; \ 1182 for (yyi = 0; yyi < (Count); yyi++) \ 1183 (Dst)[yyi] = (Src)[yyi]; \ 1184 } \ 1185 while (0) 1186 # endif 1187 # endif 1188 #endif /* !YYCOPY_NEEDED */ 1189 1190 /* YYFINAL -- State number of the termination state. */ 1191 #define YYFINAL 307 1192 /* YYLAST -- Last index in YYTABLE. */ 1193 #define YYLAST 967 1194 1195 /* YYNTOKENS -- Number of terminals. */ 1196 #define YYNTOKENS 170 1197 /* YYNNTS -- Number of nonterminals. */ 1198 #define YYNNTS 97 1199 /* YYNRULES -- Number of rules. */ 1200 #define YYNRULES 356 1201 /* YYNSTATES -- Number of states. */ 1202 #define YYNSTATES 924 1203 1204 /* YYMAXUTOK -- Last valid token kind. */ 1205 #define YYMAXUTOK 418 1206 1207 1208 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM 1209 as returned by yylex, with out-of-bounds checking. */ 1210 #define YYTRANSLATE(YYX) \ 1211 (0 <= (YYX) && (YYX) <= YYMAXUTOK \ 1212 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ 1213 : YYSYMBOL_YYUNDEF) 1214 1215 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM 1216 as returned by yylex. */ 1217 static const yytype_uint8 yytranslate[] = 1218 { 1219 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1220 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1221 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1222 2, 2, 2, 2, 2, 164, 2, 2, 2, 2, 1223 2, 2, 2, 169, 165, 168, 2, 2, 2, 2, 1224 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1225 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1226 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1227 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1228 2, 166, 2, 167, 2, 2, 2, 2, 2, 2, 1229 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1230 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1231 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1232 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1233 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1234 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1235 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1236 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1237 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1238 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1239 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1240 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1241 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1242 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1243 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1244 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 1245 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1246 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 1247 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 1248 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 1249 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 1250 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 1251 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 1252 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 1253 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 1254 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 1255 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 1256 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 1257 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 1258 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 1259 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 1260 155, 156, 157, 158, 159, 160, 161, 162, 163 1261 }; 1262 1263 #if YYDEBUG 1264 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ 1265 static const yytype_int16 yyrline[] = 1266 { 1267 0, 184, 184, 189, 192, 195, 198, 203, 218, 221, 1268 226, 235, 240, 248, 251, 256, 258, 260, 265, 283, 1269 286, 289, 292, 300, 306, 314, 323, 328, 331, 336, 1270 341, 344, 352, 359, 367, 373, 379, 385, 391, 399, 1271 409, 414, 414, 415, 415, 416, 416, 420, 433, 446, 1272 451, 456, 458, 463, 468, 470, 472, 477, 482, 487, 1273 497, 507, 509, 514, 516, 518, 520, 525, 527, 529, 1274 531, 536, 538, 540, 545, 550, 552, 554, 556, 561, 1275 567, 575, 589, 594, 599, 604, 609, 614, 616, 618, 1276 623, 628, 628, 629, 629, 630, 630, 631, 631, 632, 1277 632, 633, 633, 634, 634, 635, 635, 636, 636, 637, 1278 637, 638, 638, 639, 639, 640, 640, 641, 641, 642, 1279 642, 646, 646, 647, 647, 648, 648, 649, 649, 650, 1280 650, 654, 656, 658, 660, 663, 665, 667, 669, 674, 1281 674, 675, 675, 676, 676, 677, 677, 678, 678, 679, 1282 679, 680, 680, 681, 681, 682, 682, 689, 691, 696, 1283 702, 708, 710, 712, 714, 716, 718, 720, 722, 728, 1284 730, 732, 734, 736, 738, 738, 739, 741, 741, 742, 1285 744, 744, 745, 753, 764, 766, 771, 773, 778, 780, 1286 785, 785, 786, 786, 787, 787, 788, 788, 792, 800, 1287 807, 809, 814, 821, 827, 832, 835, 838, 843, 843, 1288 844, 844, 845, 845, 846, 846, 847, 847, 852, 857, 1289 862, 867, 869, 871, 873, 875, 877, 879, 881, 883, 1290 883, 884, 886, 894, 902, 912, 912, 913, 913, 916, 1291 916, 917, 917, 920, 920, 921, 921, 922, 922, 923, 1292 923, 924, 924, 925, 925, 926, 926, 927, 927, 928, 1293 928, 929, 929, 930, 930, 931, 933, 936, 939, 942, 1294 945, 948, 951, 954, 958, 961, 965, 968, 971, 974, 1295 977, 980, 983, 986, 989, 991, 994, 997, 1000, 1011, 1296 1013, 1015, 1017, 1024, 1026, 1034, 1036, 1038, 1044, 1049, 1297 1050, 1054, 1055, 1059, 1061, 1066, 1071, 1071, 1073, 1078, 1298 1080, 1082, 1089, 1093, 1095, 1097, 1101, 1103, 1105, 1107, 1299 1112, 1112, 1115, 1119, 1119, 1122, 1122, 1128, 1128, 1151, 1300 1152, 1157, 1157, 1165, 1167, 1172, 1176, 1181, 1182, 1185, 1301 1185, 1190, 1191, 1192, 1193, 1194, 1197, 1198, 1199, 1200, 1302 1203, 1204, 1205, 1208, 1209, 1212, 1213 1303 }; 1304 #endif 1305 1306 /** Accessing symbol of state STATE. */ 1307 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) 1308 1309 #if YYDEBUG || 0 1310 /* The user-facing name of the symbol whose (internal) number is 1311 YYSYMBOL. No bounds checking. */ 1312 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; 1313 1314 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 1315 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 1316 static const char *const yytname[] = 1317 { 1318 "\"end of file\"", "error", "\"invalid token\"", "REG", "FLAG", "CREG", 1319 "ACC", "DREG", "DREGH", "DREGL", "DCREG", "EXPR", "UNKNOWN_OPCODE", 1320 "IS_OPCODE", "DOT_S", "DOT_B", "DOT_W", "DOT_L", "DOT_A", "DOT_UB", 1321 "DOT_UW", "DOT_D", "ABS", "ADC", "ADD", "AND_", "BCLR", "BCND", "BFMOV", 1322 "BFMOVZ", "BMCND", "BNOT", "BRA", "BRK", "BSET", "BSR", "BTST", "CLRPSW", 1323 "CMP", "DABS", "DADD", "DBT", "DCMP", "DDIV", "DIV", "DIVU", "DMOV", 1324 "DMUL", "DNEG", "DPOPM", "DPUSHM", "DROUND", "DSQRT", "DSUB", "DTOF", 1325 "DTOI", "DTOU", "EDIV", "EDIVU", "EMACA", "EMSBA", "EMUL", "EMULA", 1326 "EMULU", "FADD", "FCMP", "FDIV", "FMUL", "FREIT", "FSUB", "FSQRT", 1327 "FTOD", "FTOI", "FTOU", "INT", "ITOD", "ITOF", "JMP", "JSR", "MACHI", 1328 "MACLH", "MACLO", "MAX", "MIN", "MOV", "MOVCO", "MOVLI", "MOVU", "MSBHI", 1329 "MSBLH", "MSBLO", "MUL", "MULHI", "MULLH", "MULLO", "MULU", "MVFACHI", 1330 "MVFACGU", "MVFACMI", "MVFACLO", "MVFC", "MVFDC", "MVFDR", "MVTACGU", 1331 "MVTACHI", "MVTACLO", "MVTC", "MVTDC", "MVTIPL", "NEG", "NOP", "NOT", 1332 "OR", "POP", "POPC", "POPM", "PUSH", "PUSHA", "PUSHC", "PUSHM", "RACL", 1333 "RACW", "RDACL", "RDACW", "REIT", "REVL", "REVW", "RMPA", "ROLC", "RORC", 1334 "ROTL", "ROTR", "ROUND", "RSTR", "RTE", "RTFI", "RTS", "RTSD", "SAT", 1335 "SATR", "SAVE", "SBB", "SCCND", "SCMPU", "SETPSW", "SHAR", "SHLL", 1336 "SHLR", "SMOVB", "SMOVF", "SMOVU", "SSTR", "STNZ", "STOP", "STZ", "SUB", 1337 "SUNTIL", "SWHILE", "TST", "UTOD", "UTOF", "WAIT", "XCHG", "XOR", "'#'", 1338 "','", "'['", "']'", "'-'", "'+'", "$accept", "statement", "$@1", "$@2", 1339 "$@3", "$@4", "$@5", "$@6", "$@7", "$@8", "$@9", "$@10", "$@11", "$@12", 1340 "$@13", "$@14", "$@15", "$@16", "$@17", "$@18", "$@19", "$@20", "$@21", 1341 "$@22", "$@23", "$@24", "$@25", "$@26", "$@27", "$@28", "$@29", "$@30", 1342 "$@31", "$@32", "$@33", "$@34", "$@35", "$@36", "$@37", "$@38", "$@39", 1343 "$@40", "$@41", "$@42", "$@43", "$@44", "$@45", "$@46", "$@47", "$@48", 1344 "$@49", "$@50", "$@51", "$@52", "$@53", "$@54", "$@55", "$@56", "$@57", 1345 "$@58", "$@59", "$@60", "op_subadd", "op_dp20_rm_l", "op_dp20_rm", 1346 "op_dp20_i", "op_dp20_rim", "op_dp20_rim_l", "op_dp20_rr", "op_dp20_r", 1347 "op_dp20_ri", "$@61", "op_xchg", "op_shift_rot", "op_shift", "float3_op", 1348 "float2_op", "$@62", "float2_op_ni", "$@63", "$@64", "mvfa_op", "$@65", 1349 "op_xor", "op_bfield", "$@66", "op_save_rstr", "double2_op", 1350 "double3_op", "disp", "flag", "$@67", "memex", "bwl", "bw", "opt_l", 1351 "opt_b", YY_NULLPTR 1352 }; 1353 1354 static const char * 1355 yysymbol_name (yysymbol_kind_t yysymbol) 1356 { 1357 return yytname[yysymbol]; 1358 } 1359 #endif 1360 1361 #define YYPACT_NINF (-728) 1362 1363 #define yypact_value_is_default(Yyn) \ 1364 ((Yyn) == YYPACT_NINF) 1365 1366 #define YYTABLE_NINF (-324) 1367 1368 #define yytable_value_is_error(Yyn) \ 1369 0 1370 1371 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 1372 STATE-NUM. */ 1373 static const yytype_int16 yypact[] = 1374 { 1375 323, -728, -728, -728, -136, -129, 2, 116, -728, -728, 1376 -120, 29, 127, -728, 31, 136, 33, -728, 12, -728, 1377 -728, -728, 45, -728, -728, -728, 170, -728, -728, 183, 1378 193, -728, -728, -728, -728, -728, -728, 66, 77, -118, 1379 79, -98, -728, -728, -728, -728, -728, -728, 110, -728, 1380 -728, -30, 143, -728, 155, 158, 191, 210, 221, -728, 1381 -728, 41, 244, 85, 34, 249, 250, 251, 99, 252, 1382 253, 254, 255, -728, 256, 257, 259, 258, -728, 262, 1383 263, 264, 35, 266, 112, -728, -728, -728, 113, 268, 1384 269, 270, 162, 273, 272, 115, 118, 119, 120, -728, 1385 -728, 162, 277, 282, 124, 128, -728, -728, -728, -728, 1386 -728, 129, 286, -728, -728, 130, 227, -728, -728, -728, 1387 -728, -728, -728, -728, -728, 162, -728, -728, 131, 162, 1388 162, -728, 287, -728, -728, -728, -728, 261, 288, 19, 1389 285, 64, 289, 64, 132, 290, -728, 291, 292, 294, 1390 -728, -728, 295, 133, 296, -728, 297, 298, 299, -728, 1391 300, 309, 134, 303, -728, 304, 305, 314, 153, 308, 1392 -728, 317, 157, -728, 312, 160, 320, 321, 159, 321, 1393 22, 22, 18, 6, 321, 320, 319, 324, 322, 326, 1394 320, 320, 321, 320, 320, 320, 165, 169, 172, 91, 1395 173, 172, 91, 26, 37, 37, 26, 26, 334, 174, 1396 334, 334, 329, 176, 91, -728, -728, 177, 178, 179, 1397 22, 22, 216, 276, 283, 380, 5, 311, 415, -728, 1398 -728, 7, 327, 330, 332, 476, 64, 333, 335, 336, 1399 -728, -728, -728, -728, -728, -728, -728, 337, 338, 339, 1400 340, 341, 342, 478, 343, 480, 288, 288, 483, 64, 1401 -728, -728, 344, -728, -728, -728, 92, -728, 346, 498, 1402 499, 500, 504, 513, 513, -728, -728, -728, 506, 513, 1403 507, 513, 334, 38, 508, -728, 38, 509, 93, 518, 1404 511, -728, 39, 39, 39, -728, 172, 172, 512, 64, 1405 -728, -728, 22, 359, 91, 91, 28, -728, 360, -728, 1406 361, 516, -728, -728, -728, 362, 364, 365, -728, 366, 1407 368, -728, 94, 369, -728, -728, -728, -728, 367, -728, 1408 370, 95, 371, -728, -728, -728, -728, -728, 96, 372, 1409 -728, -728, -728, 97, 373, -728, 536, 375, 538, 377, 1410 -728, 378, -728, 537, -728, 381, -728, -728, -728, 379, 1411 -728, 382, 383, 384, 539, 386, 387, 542, 551, 389, 1412 -728, -728, 388, 390, 391, 392, -728, -728, -728, -728, 1413 -728, -728, 554, 558, -728, 397, -728, 398, 560, -728, 1414 -728, 400, 555, -728, 401, -728, 404, -728, 566, 511, 1415 -728, -728, -728, -728, 563, -728, -728, -728, 564, -728, 1416 569, 570, 571, -728, -728, 565, 567, 568, 410, 412, 1417 414, -1, 416, 417, 418, 419, 0, 578, 583, 584, 1418 423, -728, 586, 587, 588, -728, 428, -728, -728, -728, 1419 590, 591, 589, 592, 593, 595, 431, 594, -728, -728, 1420 -728, 432, -728, 598, -728, 436, 600, 440, 441, 442, 1421 443, 444, -728, -728, 445, -728, 446, -728, -728, -728, 1422 601, -728, 448, -728, 449, -728, -728, 450, 604, -728, 1423 -728, -728, -728, -728, -728, 614, -728, 453, -728, -728, 1424 612, -728, -728, 455, -728, -728, 618, 619, 458, 621, 1425 622, 623, 624, 625, -728, 463, 98, 620, 107, -728, 1426 464, 108, -728, 466, 109, -728, 467, 111, -728, 631, 1427 468, 629, 630, -728, 635, 636, 231, 637, 638, 477, 1428 642, 40, 479, 484, 640, 643, 639, 644, 645, 490, 1429 491, 654, 655, 494, 657, 496, 659, 634, 501, 497, 1430 -728, -728, 502, 503, 505, 510, 514, 515, 661, 8, 1431 662, 62, 666, 668, 517, 669, 670, 63, 671, 519, 1432 520, 521, 673, 522, 523, 524, 667, -728, -728, -728, 1433 -728, -728, -728, 672, -728, 678, -728, 680, -728, 684, 1434 685, 686, 687, 691, 692, 693, -728, 695, 696, 697, 1435 540, 541, -728, 698, -728, 699, -728, -728, 700, 543, 1436 544, 546, 545, -728, 701, -728, 547, 549, -728, 550, 1437 704, -728, 552, 705, -728, 553, 712, -728, 556, -728, 1438 140, -728, 559, -728, 561, -728, -728, -728, -728, 237, 1439 -728, -728, 714, 557, 713, 562, 572, -728, -728, -728, 1440 -728, 719, 720, -728, 573, 723, 576, 717, 575, 579, 1441 727, 728, 729, 730, 731, -4, 32, 9, -728, -728, 1442 577, 1, 581, 735, 580, 582, 585, 596, 743, -728, 1443 597, 747, 602, 599, 603, 745, 748, 749, -728, 750, 1444 751, 752, 606, -728, -728, 605, -728, -728, -728, -728, 1445 -728, -728, -728, 607, -728, 609, 756, 757, -728, 608, 1446 -728, 245, 758, 759, 192, 610, 762, 615, 765, 611, 1447 766, 613, 771, 616, 778, -728, -728, -728, 617, -728, 1448 626, 726, 200, -728, -728, 627, 781, -728, 746, 628, 1449 -728, -728, 206, -728, 782, -728, 245, 783, -728, 632, 1450 -728, -728, -728, 784, 641, 785, 646, -728, 786, 647, 1451 787, 68, 789, 633, 648, 125, 649, 651, -728, -728, 1452 652, 653, 792, 656, 658, -728, -728, -728, -728, -728, 1453 -728, 790, -728, 794, -728, 660, -728, 797, 663, -728, 1454 -728, 664, 665, 791, 674, 793, 675, 791, 676, 791, 1455 677, 791, 679, 798, 799, -728, 682, 683, -728, 688, 1456 -728, 801, 689, 694, -728, 702, -728, 245, 690, 802, 1457 703, 806, 706, 807, 707, 815, -728, 708, 709, 126, 1458 715, -728, 711, 816, 819, 821, 716, -728, 823, 824, 1459 718, -728, 828, -728, 829, 830, 831, -728, -728, 820, 1460 721, 791, -728, 791, -728, 822, -728, 825, -728, -728, 1461 833, 835, -728, -728, 836, 842, 846, 722, -728, 724, 1462 -728, 725, -728, 732, -728, 733, -728, -728, -728, 736, 1463 847, 848, -728, -728, -728, 849, -728, -728, 850, -728, 1464 -728, -728, -728, -728, 734, -728, -728, -728, -728, -728, 1465 -728, -728, -728, -728, 853, -728, -728, -728, -728, 855, 1466 -728, 737, -728, -728, 851, -728, 738, -728, 741, -728, 1467 857, 742, 858, -728 1468 }; 1469 1470 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. 1471 Performed when YYTABLE does not specify something else to do. Zero 1472 means the default is an error. */ 1473 static const yytype_int16 yydefact[] = 1474 { 1475 0, 2, 97, 95, 210, 214, 0, 0, 235, 237, 1476 0, 0, 353, 3, 0, 353, 0, 339, 337, 243, 1477 257, 4, 0, 259, 107, 109, 0, 261, 245, 0, 1478 0, 247, 249, 263, 251, 253, 255, 0, 0, 121, 1479 0, 123, 143, 141, 147, 145, 139, 149, 0, 151, 1480 153, 0, 0, 127, 0, 0, 0, 0, 0, 99, 1481 101, 346, 0, 0, 350, 0, 0, 0, 212, 0, 1482 0, 0, 174, 229, 177, 180, 0, 0, 284, 0, 1483 0, 0, 0, 0, 0, 93, 6, 115, 216, 0, 1484 0, 0, 346, 0, 0, 0, 0, 0, 0, 196, 1485 194, 346, 0, 0, 190, 192, 155, 239, 76, 75, 1486 5, 0, 0, 78, 241, 91, 346, 67, 339, 43, 1487 45, 41, 69, 70, 68, 346, 119, 117, 208, 346, 1488 346, 111, 0, 129, 77, 125, 113, 0, 0, 337, 1489 0, 337, 0, 337, 0, 0, 18, 0, 0, 0, 1490 331, 331, 0, 0, 0, 7, 0, 0, 0, 354, 1491 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 1492 62, 0, 0, 338, 0, 0, 0, 0, 0, 0, 1493 337, 337, 0, 0, 0, 0, 0, 0, 0, 0, 1494 0, 0, 0, 0, 0, 0, 0, 0, 0, 337, 1495 0, 0, 337, 337, 325, 325, 337, 337, 325, 0, 1496 325, 325, 0, 0, 337, 63, 64, 0, 0, 0, 1497 337, 337, 347, 348, 349, 0, 0, 0, 0, 351, 1498 352, 0, 0, 0, 0, 0, 337, 0, 0, 0, 1499 173, 327, 327, 176, 327, 179, 327, 0, 0, 0, 1500 169, 171, 0, 0, 0, 0, 0, 0, 0, 337, 1501 58, 60, 0, 347, 348, 349, 337, 59, 0, 0, 1502 0, 0, 0, 0, 0, 74, 56, 55, 0, 0, 1503 0, 0, 325, 0, 0, 54, 0, 0, 337, 349, 1504 337, 61, 0, 0, 0, 73, 306, 306, 0, 337, 1505 71, 72, 337, 0, 337, 337, 337, 1, 304, 98, 1506 0, 0, 301, 302, 96, 0, 0, 0, 211, 0, 1507 0, 215, 337, 0, 12, 13, 17, 236, 0, 238, 1508 0, 337, 0, 9, 14, 15, 8, 65, 337, 0, 1509 16, 11, 66, 337, 0, 340, 0, 0, 0, 0, 1510 244, 0, 258, 0, 260, 0, 299, 300, 108, 0, 1511 110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1512 262, 246, 0, 0, 0, 0, 248, 250, 264, 252, 1513 254, 256, 0, 0, 104, 0, 122, 0, 0, 106, 1514 124, 0, 0, 144, 0, 142, 0, 322, 0, 337, 1515 148, 146, 140, 150, 0, 152, 154, 50, 0, 128, 1516 0, 0, 0, 100, 102, 0, 0, 0, 0, 0, 1517 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1518 0, 213, 0, 0, 0, 175, 0, 230, 178, 181, 1519 0, 0, 0, 0, 0, 0, 0, 0, 79, 94, 1520 116, 0, 217, 0, 57, 0, 0, 0, 182, 0, 1521 0, 0, 197, 195, 0, 191, 0, 193, 156, 334, 1522 0, 240, 40, 242, 0, 92, 157, 0, 0, 315, 1523 44, 46, 42, 308, 120, 0, 118, 0, 209, 112, 1524 0, 130, 126, 0, 329, 114, 0, 0, 0, 0, 1525 0, 0, 0, 0, 132, 0, 337, 0, 337, 134, 1526 0, 337, 131, 0, 337, 133, 0, 337, 26, 0, 1527 0, 0, 0, 265, 0, 0, 0, 0, 0, 0, 1528 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1529 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1530 286, 287, 165, 0, 167, 0, 0, 0, 0, 0, 1531 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1532 0, 0, 0, 161, 0, 163, 0, 199, 283, 231, 1533 170, 172, 198, 0, 285, 0, 48, 0, 47, 0, 1534 0, 0, 0, 0, 0, 0, 333, 0, 0, 0, 1535 0, 0, 307, 0, 288, 0, 303, 293, 0, 0, 1536 34, 289, 0, 36, 0, 52, 0, 0, 203, 0, 1537 0, 204, 0, 0, 51, 0, 0, 53, 0, 33, 1538 343, 335, 0, 295, 0, 267, 268, 269, 270, 0, 1539 266, 271, 0, 0, 0, 0, 0, 280, 279, 282, 1540 281, 0, 0, 309, 0, 0, 317, 0, 0, 0, 1541 0, 0, 0, 0, 0, 0, 0, 0, 39, 85, 1542 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 1543 0, 0, 0, 0, 0, 0, 0, 0, 35, 0, 1544 0, 0, 0, 202, 37, 0, 232, 183, 233, 234, 1545 312, 200, 201, 0, 218, 0, 0, 0, 32, 295, 1546 298, 353, 0, 0, 343, 0, 0, 0, 0, 0, 1547 0, 0, 0, 0, 0, 341, 342, 344, 0, 345, 1548 0, 0, 343, 277, 278, 0, 0, 276, 0, 0, 1549 221, 222, 343, 223, 0, 316, 353, 0, 324, 0, 1550 166, 224, 168, 0, 0, 0, 0, 38, 0, 0, 1551 0, 0, 0, 0, 0, 337, 0, 0, 219, 220, 1552 0, 0, 0, 0, 0, 225, 226, 227, 162, 228, 1553 164, 0, 90, 0, 158, 313, 305, 0, 0, 49, 1554 292, 0, 0, 355, 0, 0, 0, 355, 0, 355, 1555 0, 355, 0, 0, 0, 336, 0, 0, 272, 0, 1556 274, 0, 0, 0, 319, 0, 321, 353, 0, 0, 1557 0, 0, 0, 0, 0, 0, 82, 0, 0, 337, 1558 0, 86, 0, 0, 0, 0, 0, 30, 0, 0, 1559 0, 25, 0, 330, 0, 0, 0, 356, 136, 0, 1560 0, 355, 138, 355, 135, 0, 137, 0, 27, 28, 1561 0, 0, 273, 275, 0, 0, 0, 0, 19, 0, 1562 20, 0, 21, 0, 80, 0, 184, 185, 81, 0, 1563 0, 0, 186, 187, 31, 0, 188, 189, 0, 314, 1564 294, 290, 291, 88, 0, 159, 160, 87, 89, 296, 1565 297, 310, 311, 318, 0, 22, 23, 24, 205, 0, 1566 206, 0, 207, 328, 0, 326, 0, 83, 0, 84, 1567 0, 0, 0, 332 1568 }; 1569 1570 /* YYPGOTO[NTERM-NUM]. */ 1571 static const yytype_int16 yypgoto[] = 1572 { 1573 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728, 1574 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728, 1575 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728, 1576 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728, 1577 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728, 1578 -728, -728, -728, -728, -728, -728, -728, -728, -728, -728, 1579 -728, -728, -119, 650, -728, -133, -167, -728, -141, -728, 1580 437, -728, -154, -196, -145, 43, 710, -728, -149, -728, 1581 -728, -8, -728, -728, 739, -728, 681, -104, -108, -18, 1582 753, -728, -669, -37, -728, -14, -727 1583 }; 1584 1585 /* YYDEFGOTO[NTERM-NUM]. */ 1586 static const yytype_int16 yydefgoto[] = 1587 { 1588 0, 137, 294, 292, 293, 288, 256, 139, 138, 220, 1589 221, 198, 201, 180, 181, 302, 306, 257, 297, 296, 1590 199, 202, 305, 214, 304, 207, 204, 203, 206, 205, 1591 208, 210, 211, 282, 241, 244, 246, 279, 281, 274, 1592 273, 299, 141, 236, 143, 259, 242, 150, 151, 283, 1593 286, 176, 185, 190, 191, 193, 194, 195, 177, 179, 1594 184, 192, 318, 312, 356, 357, 358, 314, 309, 602, 1595 484, 485, 386, 479, 480, 393, 395, 396, 397, 398, 1596 399, 435, 436, 495, 327, 328, 471, 350, 352, 359, 1597 170, 171, 730, 226, 231, 161, 848 1598 }; 1599 1600 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If 1601 positive, shift that token. If negative, reduce the rule whose 1602 number is the opposite. If YYTABLE_NINF, syntax error. */ 1603 static const yytype_int16 yytable[] = 1604 { 1605 175, 167, 561, 567, 761, 144, 313, 173, 419, 365, 1606 424, 669, 757, 366, 360, 172, 420, 173, 425, 670, 1607 173, 361, 310, 173, 321, 355, 362, 363, 140, 391, 1608 173, 493, 153, 173, 162, 142, 168, 173, 252, 173, 1609 -323, 469, 461, 173, 152, 792, -103, 641, 390, 229, 1610 230, 173, 178, 413, 414, 266, 222, 223, 224, 403, 1611 409, 405, 406, 807, 275, 384, -105, 317, 389, 196, 1612 852, 354, 854, 813, 856, 173, 370, 462, 463, 290, 1613 197, 371, 200, 465, 378, 467, 376, 377, 295, 379, 1614 380, 381, 300, 301, 385, 454, 310, 504, 509, 512, 1615 515, 615, 173, 173, 173, 173, 173, 173, 173, 173, 1616 618, 621, 624, 209, 627, 449, 450, 431, 173, 173, 1617 173, 315, 173, 319, 895, 319, 896, 146, 831, 878, 1618 147, 148, 149, 468, 212, 489, 173, 173, 155, 494, 1619 452, 156, 157, 158, 159, 160, 213, 164, 481, 482, 1620 491, 492, 165, 159, 166, 725, 726, 727, 215, 728, 1621 729, 216, 753, 483, 483, 369, 145, 562, 568, 762, 1622 367, 421, 368, 426, 671, 758, 174, 263, 264, 265, 1623 488, 387, 364, 311, 387, 394, 311, 182, 394, 394, 1624 392, 183, 311, 154, 217, 163, 387, 169, 755, 253, 1625 186, -320, 470, 478, 187, 225, 642, 725, 726, 727, 1626 188, 791, 729, 218, 189, 725, 726, 727, 319, 806, 1627 729, 725, 726, 727, 219, 812, 729, 673, 681, 674, 1628 682, 675, 683, 825, 437, 826, 438, 827, 439, 635, 1629 636, 319, 263, 264, 289, 733, 734, 227, 455, 401, 1630 402, 228, 232, 233, 234, 237, 238, 239, 240, 243, 1631 245, 307, 159, 235, 247, 249, 250, 251, 248, 254, 1632 315, 260, 477, 262, 261, 268, 255, 258, 267, 269, 1633 276, 319, 270, 271, 272, 277, 387, 387, 278, 285, 1634 303, 308, 280, 284, 287, 298, 316, 322, 331, 338, 1635 320, 323, 324, 325, 505, 326, 330, 332, 333, 334, 1636 335, 336, 337, 510, 339, 340, 341, 342, 343, 344, 1637 513, 345, 346, 347, 353, 516, 348, 349, 351, 372, 1638 382, 373, 374, 375, 383, 1, 311, -323, 388, 404, 1639 407, 408, 410, 411, 412, 2, 3, 4, 5, 6, 1640 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1641 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1642 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 1643 415, 549, 37, 38, 39, 40, 41, 42, 43, 44, 1644 45, 418, 46, 47, 48, 49, 50, 51, 52, 53, 1645 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 1646 64, 65, 66, 67, 68, 69, 70, 71, 423, 72, 1647 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1648 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 1649 416, 93, 94, 95, 96, 97, 98, 417, 99, 100, 1650 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 1651 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 1652 121, 122, 123, 124, 125, 126, 422, 127, 128, 129, 1653 130, 131, 132, 133, 134, 135, 136, 430, 616, 446, 1654 619, 448, 427, 622, 451, 428, 625, 429, 432, 628, 1655 433, 434, 440, 441, 442, 443, 444, 445, 447, 457, 1656 458, 459, 453, 643, 456, 460, 461, 464, 466, 472, 1657 474, 476, 173, 487, 490, 496, 497, 498, 499, 500, 1658 501, 507, 502, 503, 506, 508, 511, 514, 517, 518, 1659 519, 520, 521, 522, 523, 525, 524, 526, 527, 528, 1660 529, 530, 531, 532, 533, 534, 535, 539, 536, 537, 1661 538, 540, 541, 543, 542, 544, 545, 546, 547, 548, 1662 550, 551, 552, 553, 554, 558, 555, 559, 556, 557, 1663 560, 569, 563, 565, 564, 566, 570, 571, 572, 573, 1664 574, 575, 576, 577, 578, 579, 583, 585, 580, 581, 1665 582, 586, 587, 588, 584, 589, 590, 591, 592, 593, 1666 594, 595, 596, 597, 598, 600, 599, 601, 603, 604, 1667 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 1668 620, 617, 623, 626, 629, 630, 631, 632, 633, 634, 1669 637, 638, 639, 646, 644, 659, 648, 754, 756, 759, 1670 640, 645, 650, 647, 649, 651, 652, 653, 654, 655, 1671 656, 657, 658, 661, 668, 672, 660, 662, 663, 676, 1672 664, 677, 679, 680, 684, 665, 688, 693, 692, 666, 1673 667, 694, 678, 695, 685, 686, 687, 689, 690, 691, 1674 696, 697, 698, 699, 700, 701, 702, 788, 703, 704, 1675 705, 708, 709, 710, 715, 706, 707, 719, 721, 712, 1676 711, 713, 714, 716, 717, 723, 718, 735, 720, 722, 1677 745, 737, 724, 736, 731, 740, 741, 738, 732, 743, 1678 748, 749, 815, 805, 486, 750, 751, 752, 764, 739, 1679 742, 744, 746, 760, 747, 765, 769, 832, 763, 766, 1680 771, 775, 767, 810, 776, 777, 778, 779, 780, 785, 1681 786, 789, 790, 768, 770, 794, 773, 772, 796, 798, 1682 774, 781, 782, 787, 800, 783, 784, 793, 797, 795, 1683 799, 802, 803, 801, 809, 814, 816, 818, 820, 822, 1684 824, 804, 828, 811, 808, 837, 840, 841, 829, 817, 1685 843, 858, 859, 867, 850, 869, 847, 819, 863, 871, 1686 873, 879, 821, 823, 833, 830, 834, 835, 875, 882, 1687 836, 838, 883, 839, 884, 842, 886, 887, 844, 845, 1688 846, 889, 890, 891, 892, 893, 899, 897, 900, 901, 1689 898, 849, 851, 853, 855, 902, 857, 860, 861, 903, 1690 910, 911, 912, 913, 864, 862, 915, 868, 916, 865, 1691 921, 923, 918, 0, 0, 0, 0, 866, 0, 0, 1692 870, 291, 0, 872, 874, 876, 877, 881, 0, 0, 1693 880, 885, 0, 888, 0, 0, 894, 904, 0, 0, 1694 329, 905, 906, 0, 0, 0, 0, 0, 914, 907, 1695 908, 0, 909, 0, 917, 919, 920, 922, 0, 0, 1696 0, 0, 0, 0, 0, 400, 0, 0, 0, 0, 1697 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1698 0, 0, 0, 0, 0, 0, 0, 0, 475, 0, 1699 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1700 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1701 0, 0, 0, 0, 0, 0, 0, 473 1702 }; 1703 1704 static const yytype_int16 yycheck[] = 1705 { 1706 18, 15, 3, 3, 3, 3, 139, 11, 3, 3, 1707 3, 3, 3, 7, 181, 3, 11, 11, 11, 11, 1708 11, 3, 3, 11, 143, 3, 8, 9, 164, 3, 1709 11, 3, 3, 11, 3, 164, 3, 11, 3, 11, 1710 3, 3, 3, 11, 164, 714, 164, 7, 202, 15, 1711 16, 11, 7, 220, 221, 92, 15, 16, 17, 208, 1712 214, 210, 211, 732, 101, 198, 164, 3, 201, 3, 1713 797, 179, 799, 742, 801, 11, 184, 273, 274, 116, 1714 3, 185, 3, 279, 192, 281, 190, 191, 125, 193, 1715 194, 195, 129, 130, 3, 3, 3, 3, 3, 3, 1716 3, 3, 11, 11, 11, 11, 11, 11, 11, 11, 1717 3, 3, 3, 3, 3, 256, 257, 236, 11, 11, 1718 11, 139, 11, 141, 851, 143, 853, 11, 3, 3, 1719 14, 15, 16, 282, 164, 302, 11, 11, 11, 306, 1720 259, 14, 15, 16, 17, 18, 3, 11, 293, 294, 1721 304, 305, 16, 17, 18, 15, 16, 17, 3, 19, 1722 20, 3, 166, 296, 297, 183, 164, 168, 168, 168, 1723 164, 166, 166, 166, 166, 166, 164, 15, 16, 17, 1724 299, 199, 164, 164, 202, 203, 164, 17, 206, 207, 1725 164, 21, 164, 164, 3, 164, 214, 164, 166, 164, 1726 17, 164, 164, 164, 21, 164, 166, 15, 16, 17, 1727 17, 19, 20, 3, 21, 15, 16, 17, 236, 19, 1728 20, 15, 16, 17, 3, 19, 20, 165, 165, 167, 1729 167, 169, 169, 165, 242, 167, 244, 169, 246, 8, 1730 9, 259, 15, 16, 17, 8, 9, 3, 266, 206, 1731 207, 166, 3, 3, 3, 3, 3, 3, 3, 3, 1732 3, 0, 17, 164, 5, 3, 3, 3, 10, 3, 1733 288, 3, 290, 3, 5, 3, 164, 164, 5, 164, 1734 3, 299, 164, 164, 164, 3, 304, 305, 164, 3, 1735 3, 3, 164, 164, 164, 164, 11, 165, 165, 165, 1736 11, 11, 11, 11, 322, 11, 11, 11, 11, 11, 1737 11, 11, 3, 331, 11, 11, 11, 3, 165, 11, 1738 338, 4, 165, 11, 165, 343, 166, 7, 7, 10, 1739 165, 7, 10, 7, 165, 12, 164, 3, 165, 165, 1740 11, 165, 165, 165, 165, 22, 23, 24, 25, 26, 1741 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 1742 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 1743 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 1744 164, 399, 59, 60, 61, 62, 63, 64, 65, 66, 1745 67, 11, 69, 70, 71, 72, 73, 74, 75, 76, 1746 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 1747 87, 88, 89, 90, 91, 92, 93, 94, 3, 96, 1748 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 1749 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 1750 164, 118, 119, 120, 121, 122, 123, 164, 125, 126, 1751 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 1752 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 1753 147, 148, 149, 150, 151, 152, 165, 154, 155, 156, 1754 157, 158, 159, 160, 161, 162, 163, 11, 506, 11, 1755 508, 11, 165, 511, 11, 165, 514, 165, 165, 517, 1756 165, 165, 165, 165, 165, 165, 165, 165, 165, 11, 1757 11, 11, 168, 531, 168, 11, 3, 11, 11, 11, 1758 11, 3, 11, 11, 165, 165, 165, 11, 166, 165, 1759 165, 164, 166, 165, 165, 165, 165, 165, 165, 3, 1760 165, 3, 165, 165, 7, 166, 165, 165, 165, 165, 1761 11, 165, 165, 11, 3, 166, 168, 3, 168, 168, 1762 168, 3, 165, 3, 166, 165, 11, 166, 164, 3, 1763 7, 7, 3, 3, 3, 165, 11, 165, 11, 11, 1764 166, 3, 166, 165, 167, 166, 3, 3, 165, 3, 1765 3, 3, 164, 3, 3, 6, 165, 165, 6, 6, 1766 5, 3, 166, 3, 10, 165, 165, 165, 165, 165, 1767 165, 165, 11, 165, 165, 11, 166, 3, 165, 7, 1768 165, 3, 3, 165, 3, 3, 3, 3, 3, 166, 1769 166, 11, 166, 166, 3, 167, 7, 7, 3, 3, 1770 3, 3, 165, 3, 165, 11, 7, 665, 666, 667, 1771 8, 167, 7, 10, 10, 165, 165, 3, 3, 165, 1772 3, 165, 3, 166, 3, 3, 165, 165, 165, 3, 1773 165, 3, 3, 3, 3, 165, 3, 5, 11, 165, 1774 165, 3, 165, 3, 165, 165, 165, 165, 165, 165, 1775 6, 6, 6, 6, 3, 3, 3, 711, 3, 3, 1776 3, 3, 3, 3, 3, 165, 165, 3, 3, 165, 1777 167, 165, 167, 166, 165, 3, 166, 3, 166, 166, 1778 3, 8, 166, 166, 165, 6, 6, 165, 167, 6, 1779 3, 3, 746, 7, 297, 6, 6, 6, 3, 167, 1780 167, 165, 167, 166, 165, 165, 3, 765, 167, 167, 1781 3, 6, 167, 7, 6, 6, 6, 6, 6, 3, 1782 3, 3, 3, 167, 167, 3, 167, 165, 3, 3, 1783 167, 165, 167, 165, 3, 168, 167, 167, 167, 164, 1784 167, 3, 165, 167, 3, 3, 3, 3, 3, 3, 1785 3, 165, 3, 165, 167, 3, 6, 3, 165, 167, 1786 3, 3, 3, 817, 11, 3, 15, 166, 7, 3, 1787 3, 829, 166, 166, 165, 167, 165, 165, 3, 3, 1788 167, 165, 3, 165, 3, 165, 3, 3, 165, 165, 1789 165, 3, 3, 3, 3, 15, 3, 15, 3, 3, 1790 15, 167, 167, 167, 167, 3, 167, 165, 165, 3, 1791 3, 3, 3, 3, 165, 167, 3, 167, 3, 165, 1792 3, 3, 11, -1, -1, -1, -1, 165, -1, -1, 1793 167, 118, -1, 167, 167, 167, 167, 166, -1, -1, 1794 165, 165, -1, 165, -1, -1, 165, 165, -1, -1, 1795 151, 167, 167, -1, -1, -1, -1, -1, 164, 167, 1796 167, -1, 166, -1, 167, 167, 165, 165, -1, -1, 1797 -1, -1, -1, -1, -1, 205, -1, -1, -1, -1, 1798 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1799 -1, -1, -1, -1, -1, -1, -1, -1, 288, -1, 1800 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1801 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1802 -1, -1, -1, -1, -1, -1, -1, 286 1803 }; 1804 1805 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of 1806 state STATE-NUM. */ 1807 static const yytype_int16 yystos[] = 1808 { 1809 0, 12, 22, 23, 24, 25, 26, 27, 28, 29, 1810 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 1811 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 1812 50, 51, 52, 53, 54, 55, 56, 59, 60, 61, 1813 62, 63, 64, 65, 66, 67, 69, 70, 71, 72, 1814 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 1815 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 1816 93, 94, 96, 97, 98, 99, 100, 101, 102, 103, 1817 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 1818 114, 115, 116, 118, 119, 120, 121, 122, 123, 125, 1819 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 1820 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 1821 146, 147, 148, 149, 150, 151, 152, 154, 155, 156, 1822 157, 158, 159, 160, 161, 162, 163, 171, 178, 177, 1823 164, 212, 164, 214, 3, 164, 11, 14, 15, 16, 1824 217, 218, 164, 3, 164, 11, 14, 15, 16, 17, 1825 18, 265, 3, 164, 11, 16, 18, 265, 3, 164, 1826 260, 261, 3, 11, 164, 259, 221, 228, 7, 229, 1827 183, 184, 17, 21, 230, 222, 17, 21, 17, 21, 1828 223, 224, 231, 225, 226, 227, 3, 3, 181, 190, 1829 3, 182, 191, 197, 196, 199, 198, 195, 200, 3, 1830 201, 202, 164, 3, 193, 3, 3, 3, 3, 3, 1831 179, 180, 15, 16, 17, 164, 263, 3, 166, 15, 1832 16, 264, 3, 3, 3, 164, 213, 3, 3, 3, 1833 3, 204, 216, 3, 205, 3, 206, 5, 10, 3, 1834 3, 3, 3, 164, 3, 164, 176, 187, 164, 215, 1835 3, 5, 3, 15, 16, 17, 263, 5, 3, 164, 1836 164, 164, 164, 210, 209, 263, 3, 3, 164, 207, 1837 164, 208, 203, 219, 164, 3, 220, 164, 175, 17, 1838 263, 260, 173, 174, 172, 263, 189, 188, 164, 211, 1839 263, 263, 185, 3, 194, 192, 186, 0, 3, 238, 1840 3, 164, 233, 235, 237, 259, 11, 3, 232, 259, 1841 11, 232, 165, 11, 11, 11, 11, 254, 255, 254, 1842 11, 165, 11, 11, 11, 11, 11, 3, 165, 11, 1843 11, 11, 3, 165, 11, 4, 165, 11, 166, 7, 1844 257, 7, 258, 165, 258, 3, 234, 235, 236, 259, 1845 236, 3, 8, 9, 164, 3, 7, 164, 166, 259, 1846 258, 257, 10, 7, 10, 7, 257, 257, 258, 257, 1847 257, 257, 165, 165, 235, 3, 242, 259, 165, 235, 1848 242, 3, 164, 245, 259, 246, 247, 248, 249, 250, 1849 246, 245, 245, 248, 165, 248, 248, 11, 165, 242, 1850 165, 165, 165, 236, 236, 164, 164, 164, 11, 3, 1851 11, 166, 165, 3, 3, 11, 166, 165, 165, 165, 1852 11, 232, 165, 165, 165, 251, 252, 251, 251, 251, 1853 165, 165, 165, 165, 165, 165, 11, 165, 11, 238, 1854 238, 11, 232, 168, 3, 259, 168, 11, 11, 11, 1855 11, 3, 243, 243, 11, 243, 11, 243, 248, 3, 1856 164, 256, 11, 256, 11, 233, 3, 259, 164, 243, 1857 244, 244, 244, 235, 240, 241, 240, 11, 232, 236, 1858 165, 242, 242, 3, 236, 253, 165, 165, 11, 166, 1859 165, 165, 166, 165, 3, 259, 165, 164, 165, 3, 1860 259, 165, 3, 259, 165, 3, 259, 165, 3, 165, 1861 3, 165, 165, 7, 165, 166, 165, 165, 165, 11, 1862 165, 165, 11, 3, 166, 168, 168, 168, 168, 3, 1863 3, 165, 166, 3, 165, 11, 166, 164, 3, 259, 1864 7, 7, 3, 3, 3, 11, 11, 11, 165, 165, 1865 166, 3, 168, 166, 167, 165, 166, 3, 168, 3, 1866 3, 3, 165, 3, 3, 3, 164, 3, 3, 6, 1867 6, 6, 5, 165, 10, 165, 3, 166, 3, 165, 1868 165, 165, 165, 165, 165, 165, 11, 165, 165, 166, 1869 11, 3, 239, 165, 7, 165, 3, 3, 165, 3, 1870 3, 3, 3, 3, 166, 3, 259, 11, 3, 259, 1871 166, 3, 259, 166, 3, 259, 166, 3, 259, 3, 1872 167, 7, 7, 3, 3, 8, 9, 3, 3, 165, 1873 8, 7, 166, 259, 165, 167, 3, 10, 7, 10, 1874 7, 165, 165, 3, 3, 165, 3, 165, 3, 11, 1875 165, 166, 165, 165, 165, 165, 165, 165, 3, 3, 1876 11, 166, 3, 165, 167, 169, 3, 3, 165, 3, 1877 3, 165, 167, 169, 3, 165, 165, 165, 3, 165, 1878 165, 165, 11, 5, 3, 3, 6, 6, 6, 6, 1879 3, 3, 3, 3, 3, 3, 165, 165, 3, 3, 1880 3, 167, 165, 165, 167, 3, 166, 165, 166, 3, 1881 166, 3, 166, 3, 166, 15, 16, 17, 19, 20, 1882 262, 165, 167, 8, 9, 3, 166, 8, 165, 167, 1883 6, 6, 167, 6, 165, 3, 167, 165, 3, 3, 1884 6, 6, 6, 166, 259, 166, 259, 3, 166, 259, 1885 166, 3, 168, 167, 3, 165, 167, 167, 167, 3, 1886 167, 3, 165, 167, 167, 6, 6, 6, 6, 6, 1887 6, 165, 167, 168, 167, 3, 3, 165, 265, 3, 1888 3, 19, 262, 167, 3, 164, 3, 167, 3, 167, 1889 3, 167, 3, 165, 165, 7, 19, 262, 167, 3, 1890 7, 165, 19, 262, 3, 265, 3, 167, 3, 166, 1891 3, 166, 3, 166, 3, 165, 167, 169, 3, 165, 1892 167, 3, 259, 165, 165, 165, 167, 3, 165, 165, 1893 6, 3, 165, 3, 165, 165, 165, 15, 266, 167, 1894 11, 167, 266, 167, 266, 167, 266, 167, 3, 3, 1895 165, 165, 167, 7, 165, 165, 165, 265, 167, 3, 1896 167, 3, 167, 3, 167, 3, 167, 167, 3, 259, 1897 165, 166, 3, 3, 3, 165, 3, 3, 165, 3, 1898 3, 3, 3, 15, 165, 266, 266, 15, 15, 3, 1899 3, 3, 3, 3, 165, 167, 167, 167, 167, 166, 1900 3, 3, 3, 3, 164, 3, 3, 167, 11, 167, 1901 165, 3, 165, 3 1902 }; 1903 1904 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ 1905 static const yytype_int16 yyr1[] = 1906 { 1907 0, 170, 171, 171, 171, 171, 171, 171, 171, 171, 1908 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1909 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1910 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1911 171, 172, 171, 173, 171, 174, 171, 171, 171, 171, 1912 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1913 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1914 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1915 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1916 171, 175, 171, 176, 171, 177, 171, 178, 171, 179, 1917 171, 180, 171, 181, 171, 182, 171, 183, 171, 184, 1918 171, 185, 171, 186, 171, 187, 171, 188, 171, 189, 1919 171, 190, 171, 191, 171, 192, 171, 193, 171, 194, 1920 171, 171, 171, 171, 171, 171, 171, 171, 171, 195, 1921 171, 196, 171, 197, 171, 198, 171, 199, 171, 200, 1922 171, 201, 171, 202, 171, 203, 171, 171, 171, 171, 1923 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1924 171, 171, 171, 171, 204, 171, 171, 205, 171, 171, 1925 206, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1926 207, 171, 208, 171, 209, 171, 210, 171, 171, 171, 1927 171, 171, 171, 171, 171, 171, 171, 171, 211, 171, 1928 212, 171, 213, 171, 214, 171, 215, 171, 171, 171, 1929 171, 171, 171, 171, 171, 171, 171, 171, 171, 216, 1930 171, 171, 171, 171, 171, 217, 171, 218, 171, 219, 1931 171, 220, 171, 221, 171, 222, 171, 223, 171, 224, 1932 171, 225, 171, 226, 171, 227, 171, 228, 171, 229, 1933 171, 230, 171, 231, 171, 171, 171, 171, 171, 171, 1934 171, 171, 171, 171, 171, 171, 171, 171, 171, 171, 1935 171, 171, 171, 171, 171, 171, 171, 171, 171, 232, 1936 232, 232, 232, 233, 233, 234, 234, 234, 235, 236, 1937 236, 237, 237, 238, 238, 239, 241, 240, 240, 242, 1938 242, 242, 243, 244, 244, 244, 245, 245, 245, 245, 1939 247, 246, 246, 249, 248, 250, 248, 252, 251, 253, 1940 253, 255, 254, 256, 256, 257, 258, 259, 259, 261, 1941 260, 262, 262, 262, 262, 262, 263, 263, 263, 263, 1942 264, 264, 264, 265, 265, 266, 266 1943 }; 1944 1945 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ 1946 static const yytype_int8 yyr2[] = 1947 { 1948 0, 2, 1, 1, 1, 1, 1, 2, 3, 3, 1949 2, 3, 3, 3, 3, 3, 3, 3, 2, 8, 1950 8, 8, 9, 9, 9, 7, 4, 8, 8, 5, 1951 7, 8, 5, 5, 5, 5, 5, 5, 6, 5, 1952 3, 0, 3, 0, 3, 0, 3, 4, 4, 7, 1953 3, 5, 5, 5, 2, 2, 2, 3, 2, 2, 1954 2, 2, 2, 2, 2, 3, 3, 1, 1, 1, 1955 1, 2, 2, 2, 2, 1, 1, 1, 1, 3, 1956 8, 8, 7, 10, 11, 5, 7, 9, 9, 9, 1957 6, 0, 3, 0, 3, 0, 3, 0, 3, 0, 1958 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 1959 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 1960 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 1961 3, 4, 4, 4, 4, 8, 8, 8, 8, 0, 1962 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 1963 3, 0, 3, 0, 3, 0, 3, 3, 6, 9, 1964 9, 4, 6, 4, 6, 4, 6, 4, 6, 2, 1965 4, 2, 4, 2, 0, 3, 2, 0, 3, 2, 1966 0, 3, 3, 5, 8, 8, 8, 8, 8, 8, 1967 0, 3, 0, 3, 0, 3, 0, 3, 4, 4, 1968 5, 5, 5, 5, 5, 9, 9, 9, 0, 3, 1969 0, 3, 0, 3, 0, 3, 0, 3, 5, 6, 1970 6, 6, 6, 6, 6, 6, 6, 6, 6, 0, 1971 3, 4, 5, 5, 5, 0, 3, 0, 3, 0, 1972 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 1973 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 1974 3, 0, 3, 0, 3, 4, 5, 5, 5, 5, 1975 5, 5, 7, 8, 7, 8, 6, 6, 6, 5, 1976 5, 5, 5, 4, 1, 4, 4, 4, 4, 3, 1977 7, 7, 5, 3, 7, 3, 7, 7, 4, 1, 1978 1, 1, 1, 3, 1, 3, 0, 2, 1, 3, 1979 7, 7, 3, 4, 6, 1, 4, 3, 7, 5, 1980 0, 5, 1, 0, 4, 0, 8, 0, 7, 1, 1981 5, 0, 13, 2, 1, 3, 5, 0, 1, 0, 1982 2, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1983 0, 1, 1, 0, 1, 0, 1 1984 }; 1985 1986 1987 enum { YYENOMEM = -2 }; 1988 1989 #define yyerrok (yyerrstatus = 0) 1990 #define yyclearin (yychar = YYEMPTY) 1991 1992 #define YYACCEPT goto yyacceptlab 1993 #define YYABORT goto yyabortlab 1994 #define YYERROR goto yyerrorlab 1995 #define YYNOMEM goto yyexhaustedlab 1996 1997 1998 #define YYRECOVERING() (!!yyerrstatus) 1999 2000 #define YYBACKUP(Token, Value) \ 2001 do \ 2002 if (yychar == YYEMPTY) \ 2003 { \ 2004 yychar = (Token); \ 2005 yylval = (Value); \ 2006 YYPOPSTACK (yylen); \ 2007 yystate = *yyssp; \ 2008 goto yybackup; \ 2009 } \ 2010 else \ 2011 { \ 2012 yyerror (YY_("syntax error: cannot back up")); \ 2013 YYERROR; \ 2014 } \ 2015 while (0) 2016 2017 /* Backward compatibility with an undocumented macro. 2018 Use YYerror or YYUNDEF. */ 2019 #define YYERRCODE YYUNDEF 2020 2021 2022 /* Enable debugging if requested. */ 2023 #if YYDEBUG 2024 2025 # ifndef YYFPRINTF 2026 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 2027 # define YYFPRINTF fprintf 2028 # endif 2029 2030 # define YYDPRINTF(Args) \ 2031 do { \ 2032 if (yydebug) \ 2033 YYFPRINTF Args; \ 2034 } while (0) 2035 2036 2037 2038 2039 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ 2040 do { \ 2041 if (yydebug) \ 2042 { \ 2043 YYFPRINTF (stderr, "%s ", Title); \ 2044 yy_symbol_print (stderr, \ 2045 Kind, Value); \ 2046 YYFPRINTF (stderr, "\n"); \ 2047 } \ 2048 } while (0) 2049 2050 2051 /*-----------------------------------. 2052 | Print this symbol's value on YYO. | 2053 `-----------------------------------*/ 2054 2055 static void 2056 yy_symbol_value_print (FILE *yyo, 2057 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 2058 { 2059 FILE *yyoutput = yyo; 2060 YY_USE (yyoutput); 2061 if (!yyvaluep) 2062 return; 2063 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2064 YY_USE (yykind); 2065 YY_IGNORE_MAYBE_UNINITIALIZED_END 2066 } 2067 2068 2069 /*---------------------------. 2070 | Print this symbol on YYO. | 2071 `---------------------------*/ 2072 2073 static void 2074 yy_symbol_print (FILE *yyo, 2075 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep) 2076 { 2077 YYFPRINTF (yyo, "%s %s (", 2078 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); 2079 2080 yy_symbol_value_print (yyo, yykind, yyvaluep); 2081 YYFPRINTF (yyo, ")"); 2082 } 2083 2084 /*------------------------------------------------------------------. 2085 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 2086 | TOP (included). | 2087 `------------------------------------------------------------------*/ 2088 2089 static void 2090 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) 2091 { 2092 YYFPRINTF (stderr, "Stack now"); 2093 for (; yybottom <= yytop; yybottom++) 2094 { 2095 int yybot = *yybottom; 2096 YYFPRINTF (stderr, " %d", yybot); 2097 } 2098 YYFPRINTF (stderr, "\n"); 2099 } 2100 2101 # define YY_STACK_PRINT(Bottom, Top) \ 2102 do { \ 2103 if (yydebug) \ 2104 yy_stack_print ((Bottom), (Top)); \ 2105 } while (0) 2106 2107 2108 /*------------------------------------------------. 2109 | Report that the YYRULE is going to be reduced. | 2110 `------------------------------------------------*/ 2111 2112 static void 2113 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, 2114 int yyrule) 2115 { 2116 int yylno = yyrline[yyrule]; 2117 int yynrhs = yyr2[yyrule]; 2118 int yyi; 2119 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", 2120 yyrule - 1, yylno); 2121 /* The symbols being reduced. */ 2122 for (yyi = 0; yyi < yynrhs; yyi++) 2123 { 2124 YYFPRINTF (stderr, " $%d = ", yyi + 1); 2125 yy_symbol_print (stderr, 2126 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), 2127 &yyvsp[(yyi + 1) - (yynrhs)]); 2128 YYFPRINTF (stderr, "\n"); 2129 } 2130 } 2131 2132 # define YY_REDUCE_PRINT(Rule) \ 2133 do { \ 2134 if (yydebug) \ 2135 yy_reduce_print (yyssp, yyvsp, Rule); \ 2136 } while (0) 2137 2138 /* Nonzero means print parse trace. It is left uninitialized so that 2139 multiple parsers can coexist. */ 2140 int yydebug; 2141 #else /* !YYDEBUG */ 2142 # define YYDPRINTF(Args) ((void) 0) 2143 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) 2144 # define YY_STACK_PRINT(Bottom, Top) 2145 # define YY_REDUCE_PRINT(Rule) 2146 #endif /* !YYDEBUG */ 2147 2148 2149 /* YYINITDEPTH -- initial size of the parser's stacks. */ 2150 #ifndef YYINITDEPTH 2151 # define YYINITDEPTH 200 2152 #endif 2153 2154 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 2155 if the built-in stack extension method is used). 2156 2157 Do not make this value too large; the results are undefined if 2158 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 2159 evaluated with infinite-precision integer arithmetic. */ 2160 2161 #ifndef YYMAXDEPTH 2162 # define YYMAXDEPTH 10000 2163 #endif 2164 2165 2166 2167 2168 2169 2170 /*-----------------------------------------------. 2171 | Release the memory associated to this symbol. | 2172 `-----------------------------------------------*/ 2173 2174 static void 2175 yydestruct (const char *yymsg, 2176 yysymbol_kind_t yykind, YYSTYPE *yyvaluep) 2177 { 2178 YY_USE (yyvaluep); 2179 if (!yymsg) 2180 yymsg = "Deleting"; 2181 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); 2182 2183 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2184 YY_USE (yykind); 2185 YY_IGNORE_MAYBE_UNINITIALIZED_END 2186 } 2187 2188 2189 /* Lookahead token kind. */ 2190 int yychar; 2191 2192 /* The semantic value of the lookahead symbol. */ 2193 YYSTYPE yylval; 2194 /* Number of syntax errors so far. */ 2195 int yynerrs; 2196 2197 2198 2199 2200 /*----------. 2201 | yyparse. | 2202 `----------*/ 2203 2204 int 2205 yyparse (void) 2206 { 2207 yy_state_fast_t yystate = 0; 2208 /* Number of tokens to shift before error messages enabled. */ 2209 int yyerrstatus = 0; 2210 2211 /* Refer to the stacks through separate pointers, to allow yyoverflow 2212 to reallocate them elsewhere. */ 2213 2214 /* Their size. */ 2215 YYPTRDIFF_T yystacksize = YYINITDEPTH; 2216 2217 /* The state stack: array, bottom, top. */ 2218 yy_state_t yyssa[YYINITDEPTH]; 2219 yy_state_t *yyss = yyssa; 2220 yy_state_t *yyssp = yyss; 2221 2222 /* The semantic value stack: array, bottom, top. */ 2223 YYSTYPE yyvsa[YYINITDEPTH]; 2224 YYSTYPE *yyvs = yyvsa; 2225 YYSTYPE *yyvsp = yyvs; 2226 2227 int yyn; 2228 /* The return value of yyparse. */ 2229 int yyresult; 2230 /* Lookahead symbol kind. */ 2231 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; 2232 /* The variables used to return semantic value and location from the 2233 action routines. */ 2234 YYSTYPE yyval; 2235 2236 2237 2238 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 2239 2240 /* The number of symbols on the RHS of the reduced rule. 2241 Keep to zero when no symbol should be popped. */ 2242 int yylen = 0; 2243 2244 YYDPRINTF ((stderr, "Starting parse\n")); 2245 2246 yychar = YYEMPTY; /* Cause a token to be read. */ 2247 2248 goto yysetstate; 2249 2250 2251 /*------------------------------------------------------------. 2252 | yynewstate -- push a new state, which is found in yystate. | 2253 `------------------------------------------------------------*/ 2254 yynewstate: 2255 /* In all cases, when you get here, the value and location stacks 2256 have just been pushed. So pushing a state here evens the stacks. */ 2257 yyssp++; 2258 2259 2260 /*--------------------------------------------------------------------. 2261 | yysetstate -- set current state (the top of the stack) to yystate. | 2262 `--------------------------------------------------------------------*/ 2263 yysetstate: 2264 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 2265 YY_ASSERT (0 <= yystate && yystate < YYNSTATES); 2266 YY_IGNORE_USELESS_CAST_BEGIN 2267 *yyssp = YY_CAST (yy_state_t, yystate); 2268 YY_IGNORE_USELESS_CAST_END 2269 YY_STACK_PRINT (yyss, yyssp); 2270 2271 if (yyss + yystacksize - 1 <= yyssp) 2272 #if !defined yyoverflow && !defined YYSTACK_RELOCATE 2273 YYNOMEM; 2274 #else 2275 { 2276 /* Get the current used size of the three stacks, in elements. */ 2277 YYPTRDIFF_T yysize = yyssp - yyss + 1; 2278 2279 # if defined yyoverflow 2280 { 2281 /* Give user a chance to reallocate the stack. Use copies of 2282 these so that the &'s don't force the real ones into 2283 memory. */ 2284 yy_state_t *yyss1 = yyss; 2285 YYSTYPE *yyvs1 = yyvs; 2286 2287 /* Each stack pointer address is followed by the size of the 2288 data in use in that stack, in bytes. This used to be a 2289 conditional around just the two extra args, but that might 2290 be undefined if yyoverflow is a macro. */ 2291 yyoverflow (YY_("memory exhausted"), 2292 &yyss1, yysize * YYSIZEOF (*yyssp), 2293 &yyvs1, yysize * YYSIZEOF (*yyvsp), 2294 &yystacksize); 2295 yyss = yyss1; 2296 yyvs = yyvs1; 2297 } 2298 # else /* defined YYSTACK_RELOCATE */ 2299 /* Extend the stack our own way. */ 2300 if (YYMAXDEPTH <= yystacksize) 2301 YYNOMEM; 2302 yystacksize *= 2; 2303 if (YYMAXDEPTH < yystacksize) 2304 yystacksize = YYMAXDEPTH; 2305 2306 { 2307 yy_state_t *yyss1 = yyss; 2308 union yyalloc *yyptr = 2309 YY_CAST (union yyalloc *, 2310 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); 2311 if (! yyptr) 2312 YYNOMEM; 2313 YYSTACK_RELOCATE (yyss_alloc, yyss); 2314 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 2315 # undef YYSTACK_RELOCATE 2316 if (yyss1 != yyssa) 2317 YYSTACK_FREE (yyss1); 2318 } 2319 # endif 2320 2321 yyssp = yyss + yysize - 1; 2322 yyvsp = yyvs + yysize - 1; 2323 2324 YY_IGNORE_USELESS_CAST_BEGIN 2325 YYDPRINTF ((stderr, "Stack size increased to %ld\n", 2326 YY_CAST (long, yystacksize))); 2327 YY_IGNORE_USELESS_CAST_END 2328 2329 if (yyss + yystacksize - 1 <= yyssp) 2330 YYABORT; 2331 } 2332 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ 2333 2334 2335 if (yystate == YYFINAL) 2336 YYACCEPT; 2337 2338 goto yybackup; 2339 2340 2341 /*-----------. 2342 | yybackup. | 2343 `-----------*/ 2344 yybackup: 2345 /* Do appropriate processing given the current state. Read a 2346 lookahead token if we need one and don't already have one. */ 2347 2348 /* First try to decide what to do without reference to lookahead token. */ 2349 yyn = yypact[yystate]; 2350 if (yypact_value_is_default (yyn)) 2351 goto yydefault; 2352 2353 /* Not known => get a lookahead token if don't already have one. */ 2354 2355 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ 2356 if (yychar == YYEMPTY) 2357 { 2358 YYDPRINTF ((stderr, "Reading a token\n")); 2359 yychar = yylex (); 2360 } 2361 2362 if (yychar <= YYEOF) 2363 { 2364 yychar = YYEOF; 2365 yytoken = YYSYMBOL_YYEOF; 2366 YYDPRINTF ((stderr, "Now at end of input.\n")); 2367 } 2368 else if (yychar == YYerror) 2369 { 2370 /* The scanner already issued an error message, process directly 2371 to error recovery. But do not keep the error token as 2372 lookahead, it is too special and may lead us to an endless 2373 loop in error recovery. */ 2374 yychar = YYUNDEF; 2375 yytoken = YYSYMBOL_YYerror; 2376 goto yyerrlab1; 2377 } 2378 else 2379 { 2380 yytoken = YYTRANSLATE (yychar); 2381 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 2382 } 2383 2384 /* If the proper action on seeing token YYTOKEN is to reduce or to 2385 detect an error, take that action. */ 2386 yyn += yytoken; 2387 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 2388 goto yydefault; 2389 yyn = yytable[yyn]; 2390 if (yyn <= 0) 2391 { 2392 if (yytable_value_is_error (yyn)) 2393 goto yyerrlab; 2394 yyn = -yyn; 2395 goto yyreduce; 2396 } 2397 2398 /* Count tokens shifted since error; after three, turn off error 2399 status. */ 2400 if (yyerrstatus) 2401 yyerrstatus--; 2402 2403 /* Shift the lookahead token. */ 2404 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 2405 yystate = yyn; 2406 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 2407 *++yyvsp = yylval; 2408 YY_IGNORE_MAYBE_UNINITIALIZED_END 2409 2410 /* Discard the shifted token. */ 2411 yychar = YYEMPTY; 2412 goto yynewstate; 2413 2414 2415 /*-----------------------------------------------------------. 2416 | yydefault -- do the default action for the current state. | 2417 `-----------------------------------------------------------*/ 2418 yydefault: 2419 yyn = yydefact[yystate]; 2420 if (yyn == 0) 2421 goto yyerrlab; 2422 goto yyreduce; 2423 2424 2425 /*-----------------------------. 2426 | yyreduce -- do a reduction. | 2427 `-----------------------------*/ 2428 yyreduce: 2429 /* yyn is the number of a rule to reduce with. */ 2430 yylen = yyr2[yyn]; 2431 2432 /* If YYLEN is nonzero, implement the default value of the action: 2433 '$$ = $1'. 2434 2435 Otherwise, the following line sets YYVAL to garbage. 2436 This behavior is undocumented and Bison 2437 users should not rely upon it. Assigning to YYVAL 2438 unconditionally makes the parser a bit smaller, and it avoids a 2439 GCC warning that YYVAL may be used uninitialized. */ 2440 yyval = yyvsp[1-yylen]; 2441 2442 2443 YY_REDUCE_PRINT (yyn); 2444 switch (yyn) 2445 { 2446 case 2: /* statement: UNKNOWN_OPCODE */ 2447 #line 185 "./config/rx-parse.y" 2448 { as_bad (_("Unknown opcode: %s"), rx_init_start); } 2449 #line 2450 "config/rx-parse.c" 2450 break; 2451 2452 case 3: /* statement: BRK */ 2453 #line 190 "./config/rx-parse.y" 2454 { B1 (0x00); } 2455 #line 2456 "config/rx-parse.c" 2456 break; 2457 2458 case 4: /* statement: DBT */ 2459 #line 193 "./config/rx-parse.y" 2460 { B1 (0x01); } 2461 #line 2462 "config/rx-parse.c" 2462 break; 2463 2464 case 5: /* statement: RTS */ 2465 #line 196 "./config/rx-parse.y" 2466 { B1 (0x02); } 2467 #line 2468 "config/rx-parse.c" 2468 break; 2469 2470 case 6: /* statement: NOP */ 2471 #line 199 "./config/rx-parse.y" 2472 { B1 (0x03); } 2473 #line 2474 "config/rx-parse.c" 2474 break; 2475 2476 case 7: /* statement: BRA EXPR */ 2477 #line 204 "./config/rx-parse.y" 2478 { if (rx_disp3op ((yyvsp[0].exp))) 2479 { B1 (0x08); rx_disp3 ((yyvsp[0].exp), 5); } 2480 else if (rx_intop ((yyvsp[0].exp), 8, 8)) 2481 { B1 (0x2e); PC1 ((yyvsp[0].exp)); } 2482 else if (rx_intop ((yyvsp[0].exp), 16, 16)) 2483 { B1 (0x38); PC2 ((yyvsp[0].exp)); } 2484 else if (rx_intop ((yyvsp[0].exp), 24, 24)) 2485 { B1 (0x04); PC3 ((yyvsp[0].exp)); } 2486 else 2487 { rx_relax (RX_RELAX_BRANCH, 0); 2488 rx_linkrelax_branch (); 2489 /* We'll convert this to a longer one later if needed. */ 2490 B1 (0x08); rx_disp3 ((yyvsp[0].exp), 5); } } 2491 #line 2492 "config/rx-parse.c" 2492 break; 2493 2494 case 8: /* statement: BRA DOT_A EXPR */ 2495 #line 219 "./config/rx-parse.y" 2496 { B1 (0x04); PC3 ((yyvsp[0].exp)); } 2497 #line 2498 "config/rx-parse.c" 2498 break; 2499 2500 case 9: /* statement: BRA DOT_S EXPR */ 2501 #line 222 "./config/rx-parse.y" 2502 { B1 (0x08); rx_disp3 ((yyvsp[0].exp), 5); } 2503 #line 2504 "config/rx-parse.c" 2504 break; 2505 2506 case 10: /* statement: BSR EXPR */ 2507 #line 227 "./config/rx-parse.y" 2508 { if (rx_intop ((yyvsp[0].exp), 16, 16)) 2509 { B1 (0x39); PC2 ((yyvsp[0].exp)); } 2510 else if (rx_intop ((yyvsp[0].exp), 24, 24)) 2511 { B1 (0x05); PC3 ((yyvsp[0].exp)); } 2512 else 2513 { rx_relax (RX_RELAX_BRANCH, 0); 2514 rx_linkrelax_branch (); 2515 B1 (0x39); PC2 ((yyvsp[0].exp)); } } 2516 #line 2517 "config/rx-parse.c" 2517 break; 2518 2519 case 11: /* statement: BSR DOT_A EXPR */ 2520 #line 236 "./config/rx-parse.y" 2521 { B1 (0x05), PC3 ((yyvsp[0].exp)); } 2522 #line 2523 "config/rx-parse.c" 2523 break; 2524 2525 case 12: /* statement: BCND DOT_S EXPR */ 2526 #line 241 "./config/rx-parse.y" 2527 { if ((yyvsp[-2].regno) == COND_EQ || (yyvsp[-2].regno) == COND_NE) 2528 { B1 ((yyvsp[-2].regno) == COND_EQ ? 0x10 : 0x18); rx_disp3 ((yyvsp[0].exp), 5); } 2529 else 2530 as_bad (_("Only BEQ and BNE may have .S")); } 2531 #line 2532 "config/rx-parse.c" 2532 break; 2533 2534 case 13: /* statement: BCND DOT_B EXPR */ 2535 #line 249 "./config/rx-parse.y" 2536 { B1 (0x20); F ((yyvsp[-2].regno), 4, 4); PC1 ((yyvsp[0].exp)); } 2537 #line 2538 "config/rx-parse.c" 2538 break; 2539 2540 case 14: /* statement: BRA DOT_B EXPR */ 2541 #line 252 "./config/rx-parse.y" 2542 { B1 (0x2e), PC1 ((yyvsp[0].exp)); } 2543 #line 2544 "config/rx-parse.c" 2544 break; 2545 2546 case 15: /* statement: BRA DOT_W EXPR */ 2547 #line 257 "./config/rx-parse.y" 2548 { B1 (0x38), PC2 ((yyvsp[0].exp)); } 2549 #line 2550 "config/rx-parse.c" 2550 break; 2551 2552 case 16: /* statement: BSR DOT_W EXPR */ 2553 #line 259 "./config/rx-parse.y" 2554 { B1 (0x39), PC2 ((yyvsp[0].exp)); } 2555 #line 2556 "config/rx-parse.c" 2556 break; 2557 2558 case 17: /* statement: BCND DOT_W EXPR */ 2559 #line 261 "./config/rx-parse.y" 2560 { if ((yyvsp[-2].regno) == COND_EQ || (yyvsp[-2].regno) == COND_NE) 2561 { B1 ((yyvsp[-2].regno) == COND_EQ ? 0x3a : 0x3b); PC2 ((yyvsp[0].exp)); } 2562 else 2563 as_bad (_("Only BEQ and BNE may have .W")); } 2564 #line 2565 "config/rx-parse.c" 2565 break; 2566 2567 case 18: /* statement: BCND EXPR */ 2568 #line 266 "./config/rx-parse.y" 2569 { if ((yyvsp[-1].regno) == COND_EQ || (yyvsp[-1].regno) == COND_NE) 2570 { 2571 rx_relax (RX_RELAX_BRANCH, 0); 2572 rx_linkrelax_branch (); 2573 B1 ((yyvsp[-1].regno) == COND_EQ ? 0x10 : 0x18); rx_disp3 ((yyvsp[0].exp), 5); 2574 } 2575 else 2576 { 2577 rx_relax (RX_RELAX_BRANCH, 0); 2578 /* This is because we might turn it into a 2579 jump-over-jump long branch. */ 2580 rx_linkrelax_branch (); 2581 B1 (0x20); F ((yyvsp[-1].regno), 4, 4); PC1 ((yyvsp[0].exp)); 2582 } } 2583 #line 2584 "config/rx-parse.c" 2584 break; 2585 2586 case 19: /* statement: MOV DOT_B '#' EXPR ',' '[' REG ']' */ 2587 #line 284 "./config/rx-parse.y" 2588 { B2 (0xf8, 0x04); F ((yyvsp[-1].regno), 8, 4); IMMB ((yyvsp[-4].exp), 12);} 2589 #line 2590 "config/rx-parse.c" 2590 break; 2591 2592 case 20: /* statement: MOV DOT_W '#' EXPR ',' '[' REG ']' */ 2593 #line 287 "./config/rx-parse.y" 2594 { B2 (0xf8, 0x01); F ((yyvsp[-1].regno), 8, 4); IMMW ((yyvsp[-4].exp), 12);} 2595 #line 2596 "config/rx-parse.c" 2596 break; 2597 2598 case 21: /* statement: MOV DOT_L '#' EXPR ',' '[' REG ']' */ 2599 #line 290 "./config/rx-parse.y" 2600 { B2 (0xf8, 0x02); F ((yyvsp[-1].regno), 8, 4); IMM ((yyvsp[-4].exp), 12);} 2601 #line 2602 "config/rx-parse.c" 2602 break; 2603 2604 case 22: /* statement: MOV DOT_B '#' EXPR ',' disp '[' REG ']' */ 2605 #line 294 "./config/rx-parse.y" 2606 { if ((yyvsp[-1].regno) <= 7 && rx_uintop ((yyvsp[-5].exp), 8) && rx_disp5op0 (&(yyvsp[-3].exp), BSIZE)) 2607 { B2 (0x3c, 0); rx_field5s2 ((yyvsp[-3].exp)); F ((yyvsp[-1].regno), 9, 3); O1 ((yyvsp[-5].exp)); } 2608 else 2609 { B2 (0xf8, 0x04); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, BSIZE); O1 ((yyvsp[-5].exp)); 2610 if ((yyvsp[-5].exp).X_op != O_constant && (yyvsp[-5].exp).X_op != O_big) rx_linkrelax_imm (12); } } 2611 #line 2612 "config/rx-parse.c" 2612 break; 2613 2614 case 23: /* statement: MOV DOT_W '#' EXPR ',' disp '[' REG ']' */ 2615 #line 301 "./config/rx-parse.y" 2616 { if ((yyvsp[-1].regno) <= 7 && rx_uintop ((yyvsp[-5].exp), 8) && rx_disp5op0 (&(yyvsp[-3].exp), WSIZE)) 2617 { B2 (0x3d, 0); rx_field5s2 ((yyvsp[-3].exp)); F ((yyvsp[-1].regno), 9, 3); O1 ((yyvsp[-5].exp)); } 2618 else 2619 { B2 (0xf8, 0x01); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, WSIZE); IMMW ((yyvsp[-5].exp), 12); } } 2620 #line 2621 "config/rx-parse.c" 2621 break; 2622 2623 case 24: /* statement: MOV DOT_L '#' EXPR ',' disp '[' REG ']' */ 2624 #line 307 "./config/rx-parse.y" 2625 { if ((yyvsp[-1].regno) <= 7 && rx_uintop ((yyvsp[-5].exp), 8) && rx_disp5op0 (&(yyvsp[-3].exp), LSIZE)) 2626 { B2 (0x3e, 0); rx_field5s2 ((yyvsp[-3].exp)); F ((yyvsp[-1].regno), 9, 3); O1 ((yyvsp[-5].exp)); } 2627 else 2628 { B2 (0xf8, 0x02); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, LSIZE); IMM ((yyvsp[-5].exp), 12); } } 2629 #line 2630 "config/rx-parse.c" 2630 break; 2631 2632 case 25: /* statement: RTSD '#' EXPR ',' REG '-' REG */ 2633 #line 315 "./config/rx-parse.y" 2634 { B2 (0x3f, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); rtsd_immediate ((yyvsp[-4].exp)); 2635 if ((yyvsp[-2].regno) == 0) 2636 rx_error (_("RTSD cannot pop R0")); 2637 if ((yyvsp[-2].regno) > (yyvsp[0].regno)) 2638 rx_error (_("RTSD first reg must be <= second reg")); } 2639 #line 2640 "config/rx-parse.c" 2640 break; 2641 2642 case 26: /* statement: CMP REG ',' REG */ 2643 #line 324 "./config/rx-parse.y" 2644 { B2 (0x47, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2645 #line 2646 "config/rx-parse.c" 2646 break; 2647 2648 case 27: /* statement: CMP disp '[' REG ']' DOT_UB ',' REG */ 2649 #line 329 "./config/rx-parse.y" 2650 { B2 (0x44, 0); F ((yyvsp[-4].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-6].exp), 6, BSIZE); } 2651 #line 2652 "config/rx-parse.c" 2652 break; 2653 2654 case 28: /* statement: CMP disp '[' REG ']' memex ',' REG */ 2655 #line 332 "./config/rx-parse.y" 2656 { B3 (MEMEX, 0x04, 0); F ((yyvsp[-2].regno), 8, 2); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); } 2657 #line 2658 "config/rx-parse.c" 2658 break; 2659 2660 case 29: /* statement: MOVU bw REG ',' REG */ 2661 #line 337 "./config/rx-parse.y" 2662 { B2 (0x5b, 0x00); F ((yyvsp[-3].regno), 5, 1); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2663 #line 2664 "config/rx-parse.c" 2664 break; 2665 2666 case 30: /* statement: MOVU bw '[' REG ']' ',' REG */ 2667 #line 342 "./config/rx-parse.y" 2668 { B2 (0x58, 0x00); F ((yyvsp[-5].regno), 5, 1); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2669 #line 2670 "config/rx-parse.c" 2670 break; 2671 2672 case 31: /* statement: MOVU bw EXPR '[' REG ']' ',' REG */ 2673 #line 345 "./config/rx-parse.y" 2674 { if ((yyvsp[-3].regno) <= 7 && (yyvsp[0].regno) <= 7 && rx_disp5op (&(yyvsp[-5].exp), (yyvsp[-6].regno))) 2675 { B2 (0xb0, 0); F ((yyvsp[-6].regno), 4, 1); F ((yyvsp[-3].regno), 9, 3); F ((yyvsp[0].regno), 13, 3); rx_field5s ((yyvsp[-5].exp)); } 2676 else 2677 { B2 (0x58, 0x00); F ((yyvsp[-6].regno), 5, 1); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-5].exp), 6, (yyvsp[-6].regno)); } } 2678 #line 2679 "config/rx-parse.c" 2679 break; 2680 2681 case 32: /* statement: SUB '#' EXPR ',' REG */ 2682 #line 353 "./config/rx-parse.y" 2683 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2684 { B2 (0x60, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2685 else 2686 /* This is really an add, but we negate the immediate. */ 2687 { B2 (0x70, 0); F ((yyvsp[0].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); NIMM ((yyvsp[-2].exp), 6); } } 2688 #line 2689 "config/rx-parse.c" 2689 break; 2690 2691 case 33: /* statement: CMP '#' EXPR ',' REG */ 2692 #line 360 "./config/rx-parse.y" 2693 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2694 { B2 (0x61, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2695 else if (rx_uintop ((yyvsp[-2].exp), 8)) 2696 { B2 (0x75, 0x50); F ((yyvsp[0].regno), 12, 4); UO1 ((yyvsp[-2].exp)); } 2697 else 2698 { B2 (0x74, 0x00); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } } 2699 #line 2700 "config/rx-parse.c" 2700 break; 2701 2702 case 34: /* statement: ADD '#' EXPR ',' REG */ 2703 #line 368 "./config/rx-parse.y" 2704 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2705 { B2 (0x62, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2706 else 2707 { B2 (0x70, 0); F ((yyvsp[0].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } } 2708 #line 2709 "config/rx-parse.c" 2709 break; 2710 2711 case 35: /* statement: MUL '#' EXPR ',' REG */ 2712 #line 374 "./config/rx-parse.y" 2713 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2714 { B2 (0x63, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2715 else 2716 { B2 (0x74, 0x10); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } } 2717 #line 2718 "config/rx-parse.c" 2718 break; 2719 2720 case 36: /* statement: AND_ '#' EXPR ',' REG */ 2721 #line 380 "./config/rx-parse.y" 2722 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2723 { B2 (0x64, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2724 else 2725 { B2 (0x74, 0x20); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } } 2726 #line 2727 "config/rx-parse.c" 2727 break; 2728 2729 case 37: /* statement: OR '#' EXPR ',' REG */ 2730 #line 386 "./config/rx-parse.y" 2731 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2732 { B2 (0x65, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2733 else 2734 { B2 (0x74, 0x30); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-2].exp), 6); } } 2735 #line 2736 "config/rx-parse.c" 2736 break; 2737 2738 case 38: /* statement: MOV DOT_L '#' EXPR ',' REG */ 2739 #line 392 "./config/rx-parse.y" 2740 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2741 { B2 (0x66, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2742 else if (rx_uintop ((yyvsp[-2].exp), 8)) 2743 { B2 (0x75, 0x40); F ((yyvsp[0].regno), 12, 4); UO1 ((yyvsp[-2].exp)); } 2744 else 2745 { B2 (0xfb, 0x02); F ((yyvsp[0].regno), 8, 4); IMM ((yyvsp[-2].exp), 12); } } 2746 #line 2747 "config/rx-parse.c" 2747 break; 2748 2749 case 39: /* statement: MOV '#' EXPR ',' REG */ 2750 #line 400 "./config/rx-parse.y" 2751 { if (rx_uintop ((yyvsp[-2].exp), 4)) 2752 { B2 (0x66, 0); FE ((yyvsp[-2].exp), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2753 else if (rx_uintop ((yyvsp[-2].exp), 8)) 2754 { B2 (0x75, 0x40); F ((yyvsp[0].regno), 12, 4); UO1 ((yyvsp[-2].exp)); } 2755 else 2756 { B2 (0xfb, 0x02); F ((yyvsp[0].regno), 8, 4); IMM ((yyvsp[-2].exp), 12); } } 2757 #line 2758 "config/rx-parse.c" 2758 break; 2759 2760 case 40: /* statement: RTSD '#' EXPR */ 2761 #line 410 "./config/rx-parse.y" 2762 { B1 (0x67); rtsd_immediate ((yyvsp[0].exp)); } 2763 #line 2764 "config/rx-parse.c" 2764 break; 2765 2766 case 41: /* $@1: %empty */ 2767 #line 414 "./config/rx-parse.y" 2768 { sub_op = 0; } 2769 #line 2770 "config/rx-parse.c" 2770 break; 2771 2772 case 43: /* $@2: %empty */ 2773 #line 415 "./config/rx-parse.y" 2774 { sub_op = 1; } 2775 #line 2776 "config/rx-parse.c" 2776 break; 2777 2778 case 45: /* $@3: %empty */ 2779 #line 416 "./config/rx-parse.y" 2780 { sub_op = 2; } 2781 #line 2782 "config/rx-parse.c" 2782 break; 2783 2784 case 47: /* statement: PUSHM REG '-' REG */ 2785 #line 421 "./config/rx-parse.y" 2786 { 2787 if ((yyvsp[-2].regno) == (yyvsp[0].regno)) 2788 { B2 (0x7e, 0x80); F (LSIZE, 10, 2); F ((yyvsp[-2].regno), 12, 4); } 2789 else 2790 { B2 (0x6e, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2791 if ((yyvsp[-2].regno) == 0) 2792 rx_error (_("PUSHM cannot push R0")); 2793 if ((yyvsp[-2].regno) > (yyvsp[0].regno)) 2794 rx_error (_("PUSHM first reg must be <= second reg")); } 2795 #line 2796 "config/rx-parse.c" 2796 break; 2797 2798 case 48: /* statement: POPM REG '-' REG */ 2799 #line 434 "./config/rx-parse.y" 2800 { 2801 if ((yyvsp[-2].regno) == (yyvsp[0].regno)) 2802 { B2 (0x7e, 0xb0); F ((yyvsp[-2].regno), 12, 4); } 2803 else 2804 { B2 (0x6f, 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 2805 if ((yyvsp[-2].regno) == 0) 2806 rx_error (_("POPM cannot pop R0")); 2807 if ((yyvsp[-2].regno) > (yyvsp[0].regno)) 2808 rx_error (_("POPM first reg must be <= second reg")); } 2809 #line 2810 "config/rx-parse.c" 2810 break; 2811 2812 case 49: /* statement: ADD '#' EXPR ',' REG ',' REG */ 2813 #line 447 "./config/rx-parse.y" 2814 { B2 (0x70, 0x00); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); IMM ((yyvsp[-4].exp), 6); } 2815 #line 2816 "config/rx-parse.c" 2816 break; 2817 2818 case 50: /* statement: INT '#' EXPR */ 2819 #line 452 "./config/rx-parse.y" 2820 { B2(0x75, 0x60), UO1 ((yyvsp[0].exp)); } 2821 #line 2822 "config/rx-parse.c" 2822 break; 2823 2824 case 51: /* statement: BSET '#' EXPR ',' REG */ 2825 #line 457 "./config/rx-parse.y" 2826 { B2 (0x78, 0); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); } 2827 #line 2828 "config/rx-parse.c" 2828 break; 2829 2830 case 52: /* statement: BCLR '#' EXPR ',' REG */ 2831 #line 459 "./config/rx-parse.y" 2832 { B2 (0x7a, 0); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); } 2833 #line 2834 "config/rx-parse.c" 2834 break; 2835 2836 case 53: /* statement: BTST '#' EXPR ',' REG */ 2837 #line 464 "./config/rx-parse.y" 2838 { B2 (0x7c, 0x00); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); } 2839 #line 2840 "config/rx-parse.c" 2840 break; 2841 2842 case 54: /* statement: SAT REG */ 2843 #line 469 "./config/rx-parse.y" 2844 { B2 (0x7e, 0x30); F ((yyvsp[0].regno), 12, 4); } 2845 #line 2846 "config/rx-parse.c" 2846 break; 2847 2848 case 55: /* statement: RORC REG */ 2849 #line 471 "./config/rx-parse.y" 2850 { B2 (0x7e, 0x40); F ((yyvsp[0].regno), 12, 4); } 2851 #line 2852 "config/rx-parse.c" 2852 break; 2853 2854 case 56: /* statement: ROLC REG */ 2855 #line 473 "./config/rx-parse.y" 2856 { B2 (0x7e, 0x50); F ((yyvsp[0].regno), 12, 4); } 2857 #line 2858 "config/rx-parse.c" 2858 break; 2859 2860 case 57: /* statement: PUSH bwl REG */ 2861 #line 478 "./config/rx-parse.y" 2862 { B2 (0x7e, 0x80); F ((yyvsp[-1].regno), 10, 2); F ((yyvsp[0].regno), 12, 4); } 2863 #line 2864 "config/rx-parse.c" 2864 break; 2865 2866 case 58: /* statement: POP REG */ 2867 #line 483 "./config/rx-parse.y" 2868 { B2 (0x7e, 0xb0); F ((yyvsp[0].regno), 12, 4); } 2869 #line 2870 "config/rx-parse.c" 2870 break; 2871 2872 case 59: /* statement: PUSHC CREG */ 2873 #line 488 "./config/rx-parse.y" 2874 { if ((yyvsp[0].regno) == 13) 2875 { rx_check_v2 (); } 2876 if ((yyvsp[0].regno) < 16) 2877 { B2 (0x7e, 0xc0); F ((yyvsp[0].regno), 12, 4); } 2878 else 2879 as_bad (_("PUSHC can only push the first 16 control registers")); } 2880 #line 2881 "config/rx-parse.c" 2881 break; 2882 2883 case 60: /* statement: POPC CREG */ 2884 #line 498 "./config/rx-parse.y" 2885 { if ((yyvsp[0].regno) == 13) 2886 { rx_check_v2 (); } 2887 if ((yyvsp[0].regno) < 16) 2888 { B2 (0x7e, 0xe0); F ((yyvsp[0].regno), 12, 4); } 2889 else 2890 as_bad (_("POPC can only pop the first 16 control registers")); } 2891 #line 2892 "config/rx-parse.c" 2892 break; 2893 2894 case 61: /* statement: SETPSW flag */ 2895 #line 508 "./config/rx-parse.y" 2896 { B2 (0x7f, 0xa0); F ((yyvsp[0].regno), 12, 4); } 2897 #line 2898 "config/rx-parse.c" 2898 break; 2899 2900 case 62: /* statement: CLRPSW flag */ 2901 #line 510 "./config/rx-parse.y" 2902 { B2 (0x7f, 0xb0); F ((yyvsp[0].regno), 12, 4); } 2903 #line 2904 "config/rx-parse.c" 2904 break; 2905 2906 case 63: /* statement: JMP REG */ 2907 #line 515 "./config/rx-parse.y" 2908 { B2 (0x7f, 0x00); F ((yyvsp[0].regno), 12, 4); } 2909 #line 2910 "config/rx-parse.c" 2910 break; 2911 2912 case 64: /* statement: JSR REG */ 2913 #line 517 "./config/rx-parse.y" 2914 { B2 (0x7f, 0x10); F ((yyvsp[0].regno), 12, 4); } 2915 #line 2916 "config/rx-parse.c" 2916 break; 2917 2918 case 65: /* statement: BRA opt_l REG */ 2919 #line 519 "./config/rx-parse.y" 2920 { B2 (0x7f, 0x40); F ((yyvsp[0].regno), 12, 4); } 2921 #line 2922 "config/rx-parse.c" 2922 break; 2923 2924 case 66: /* statement: BSR opt_l REG */ 2925 #line 521 "./config/rx-parse.y" 2926 { B2 (0x7f, 0x50); F ((yyvsp[0].regno), 12, 4); } 2927 #line 2928 "config/rx-parse.c" 2928 break; 2929 2930 case 67: /* statement: SCMPU */ 2931 #line 526 "./config/rx-parse.y" 2932 { B2 (0x7f, 0x83); rx_note_string_insn_use (); } 2933 #line 2934 "config/rx-parse.c" 2934 break; 2935 2936 case 68: /* statement: SMOVU */ 2937 #line 528 "./config/rx-parse.y" 2938 { B2 (0x7f, 0x87); rx_note_string_insn_use (); } 2939 #line 2940 "config/rx-parse.c" 2940 break; 2941 2942 case 69: /* statement: SMOVB */ 2943 #line 530 "./config/rx-parse.y" 2944 { B2 (0x7f, 0x8b); rx_note_string_insn_use (); } 2945 #line 2946 "config/rx-parse.c" 2946 break; 2947 2948 case 70: /* statement: SMOVF */ 2949 #line 532 "./config/rx-parse.y" 2950 { B2 (0x7f, 0x8f); rx_note_string_insn_use (); } 2951 #line 2952 "config/rx-parse.c" 2952 break; 2953 2954 case 71: /* statement: SUNTIL bwl */ 2955 #line 537 "./config/rx-parse.y" 2956 { B2 (0x7f, 0x80); F ((yyvsp[0].regno), 14, 2); rx_note_string_insn_use (); } 2957 #line 2958 "config/rx-parse.c" 2958 break; 2959 2960 case 72: /* statement: SWHILE bwl */ 2961 #line 539 "./config/rx-parse.y" 2962 { B2 (0x7f, 0x84); F ((yyvsp[0].regno), 14, 2); rx_note_string_insn_use (); } 2963 #line 2964 "config/rx-parse.c" 2964 break; 2965 2966 case 73: /* statement: SSTR bwl */ 2967 #line 541 "./config/rx-parse.y" 2968 { B2 (0x7f, 0x88); F ((yyvsp[0].regno), 14, 2); } 2969 #line 2970 "config/rx-parse.c" 2970 break; 2971 2972 case 74: /* statement: RMPA bwl */ 2973 #line 546 "./config/rx-parse.y" 2974 { B2 (0x7f, 0x8c); F ((yyvsp[0].regno), 14, 2); rx_note_string_insn_use (); } 2975 #line 2976 "config/rx-parse.c" 2976 break; 2977 2978 case 75: /* statement: RTFI */ 2979 #line 551 "./config/rx-parse.y" 2980 { B2 (0x7f, 0x94); } 2981 #line 2982 "config/rx-parse.c" 2982 break; 2983 2984 case 76: /* statement: RTE */ 2985 #line 553 "./config/rx-parse.y" 2986 { B2 (0x7f, 0x95); } 2987 #line 2988 "config/rx-parse.c" 2988 break; 2989 2990 case 77: /* statement: WAIT */ 2991 #line 555 "./config/rx-parse.y" 2992 { B2 (0x7f, 0x96); } 2993 #line 2994 "config/rx-parse.c" 2994 break; 2995 2996 case 78: /* statement: SATR */ 2997 #line 557 "./config/rx-parse.y" 2998 { B2 (0x7f, 0x93); } 2999 #line 3000 "config/rx-parse.c" 3000 break; 3001 3002 case 79: /* statement: MVTIPL '#' EXPR */ 3003 #line 562 "./config/rx-parse.y" 3004 { B3 (0x75, 0x70, 0x00); FE ((yyvsp[0].exp), 20, 4); } 3005 #line 3006 "config/rx-parse.c" 3006 break; 3007 3008 case 80: /* statement: MOV bwl REG ',' EXPR '[' REG ']' */ 3009 #line 568 "./config/rx-parse.y" 3010 { if ((yyvsp[-5].regno) <= 7 && (yyvsp[-1].regno) <= 7 && rx_disp5op (&(yyvsp[-3].exp), (yyvsp[-6].regno))) 3011 { B2 (0x80, 0); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-1].regno), 9, 3); F ((yyvsp[-5].regno), 13, 3); rx_field5s ((yyvsp[-3].exp)); } 3012 else 3013 { B2 (0xc3, 0x00); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-1].regno), 8, 4); F ((yyvsp[-5].regno), 12, 4); DSP ((yyvsp[-3].exp), 4, (yyvsp[-6].regno)); }} 3014 #line 3015 "config/rx-parse.c" 3015 break; 3016 3017 case 81: /* statement: MOV bwl EXPR '[' REG ']' ',' REG */ 3018 #line 576 "./config/rx-parse.y" 3019 { if ((yyvsp[-3].regno) <= 7 && (yyvsp[0].regno) <= 7 && rx_disp5op (&(yyvsp[-5].exp), (yyvsp[-6].regno))) 3020 { B2 (0x88, 0); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-3].regno), 9, 3); F ((yyvsp[0].regno), 13, 3); rx_field5s ((yyvsp[-5].exp)); } 3021 else 3022 { B2 (0xcc, 0x00); F ((yyvsp[-6].regno), 2, 2); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-5].exp), 6, (yyvsp[-6].regno)); } } 3023 #line 3024 "config/rx-parse.c" 3024 break; 3025 3026 case 82: /* statement: MOV bwl REG ',' '[' REG ']' */ 3027 #line 590 "./config/rx-parse.y" 3028 { B2 (0xc3, 0x00); F ((yyvsp[-5].regno), 2, 2); F ((yyvsp[-1].regno), 8, 4); F ((yyvsp[-4].regno), 12, 4); } 3029 #line 3030 "config/rx-parse.c" 3030 break; 3031 3032 case 83: /* statement: MOV bwl '[' REG ']' ',' disp '[' REG ']' */ 3033 #line 595 "./config/rx-parse.y" 3034 { B2 (0xc0, 0); F ((yyvsp[-8].regno), 2, 2); F ((yyvsp[-6].regno), 8, 4); F ((yyvsp[-1].regno), 12, 4); DSP ((yyvsp[-3].exp), 4, (yyvsp[-8].regno)); } 3035 #line 3036 "config/rx-parse.c" 3036 break; 3037 3038 case 84: /* statement: MOV bwl EXPR '[' REG ']' ',' disp '[' REG ']' */ 3039 #line 600 "./config/rx-parse.y" 3040 { B2 (0xc0, 0x00); F ((yyvsp[-9].regno), 2, 2); F ((yyvsp[-6].regno), 8, 4); F ((yyvsp[-1].regno), 12, 4); DSP ((yyvsp[-8].exp), 6, (yyvsp[-9].regno)); DSP ((yyvsp[-3].exp), 4, (yyvsp[-9].regno)); } 3041 #line 3042 "config/rx-parse.c" 3042 break; 3043 3044 case 85: /* statement: MOV bwl REG ',' REG */ 3045 #line 605 "./config/rx-parse.y" 3046 { B2 (0xcf, 0x00); F ((yyvsp[-3].regno), 2, 2); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 3047 #line 3048 "config/rx-parse.c" 3048 break; 3049 3050 case 86: /* statement: MOV bwl '[' REG ']' ',' REG */ 3051 #line 610 "./config/rx-parse.y" 3052 { B2 (0xcc, 0x00); F ((yyvsp[-5].regno), 2, 2); F ((yyvsp[-3].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 3053 #line 3054 "config/rx-parse.c" 3054 break; 3055 3056 case 87: /* statement: BSET '#' EXPR ',' disp '[' REG ']' DOT_B */ 3057 #line 615 "./config/rx-parse.y" 3058 { B2 (0xf0, 0x00); F ((yyvsp[-2].regno), 8, 4); FE ((yyvsp[-6].exp), 13, 3); DSP ((yyvsp[-4].exp), 6, BSIZE); } 3059 #line 3060 "config/rx-parse.c" 3060 break; 3061 3062 case 88: /* statement: BCLR '#' EXPR ',' disp '[' REG ']' DOT_B */ 3063 #line 617 "./config/rx-parse.y" 3064 { B2 (0xf0, 0x08); F ((yyvsp[-2].regno), 8, 4); FE ((yyvsp[-6].exp), 13, 3); DSP ((yyvsp[-4].exp), 6, BSIZE); } 3065 #line 3066 "config/rx-parse.c" 3066 break; 3067 3068 case 89: /* statement: BTST '#' EXPR ',' disp '[' REG ']' DOT_B */ 3069 #line 619 "./config/rx-parse.y" 3070 { B2 (0xf4, 0x00); F ((yyvsp[-2].regno), 8, 4); FE ((yyvsp[-6].exp), 13, 3); DSP ((yyvsp[-4].exp), 6, BSIZE); } 3071 #line 3072 "config/rx-parse.c" 3072 break; 3073 3074 case 90: /* statement: PUSH bwl disp '[' REG ']' */ 3075 #line 624 "./config/rx-parse.y" 3076 { B2 (0xf4, 0x08); F ((yyvsp[-4].regno), 14, 2); F ((yyvsp[-1].regno), 8, 4); DSP ((yyvsp[-3].exp), 6, (yyvsp[-4].regno)); } 3077 #line 3078 "config/rx-parse.c" 3078 break; 3079 3080 case 91: /* $@4: %empty */ 3081 #line 628 "./config/rx-parse.y" 3082 { sub_op = 0; } 3083 #line 3084 "config/rx-parse.c" 3084 break; 3085 3086 case 93: /* $@5: %empty */ 3087 #line 629 "./config/rx-parse.y" 3088 { sub_op = 1; sub_op2 = 1; } 3089 #line 3090 "config/rx-parse.c" 3090 break; 3091 3092 case 95: /* $@6: %empty */ 3093 #line 630 "./config/rx-parse.y" 3094 { sub_op = 2; } 3095 #line 3096 "config/rx-parse.c" 3096 break; 3097 3098 case 97: /* $@7: %empty */ 3099 #line 631 "./config/rx-parse.y" 3100 { sub_op = 3; sub_op2 = 2; } 3101 #line 3102 "config/rx-parse.c" 3102 break; 3103 3104 case 99: /* $@8: %empty */ 3105 #line 632 "./config/rx-parse.y" 3106 { sub_op = 4; } 3107 #line 3108 "config/rx-parse.c" 3108 break; 3109 3110 case 101: /* $@9: %empty */ 3111 #line 633 "./config/rx-parse.y" 3112 { sub_op = 5; } 3113 #line 3114 "config/rx-parse.c" 3114 break; 3115 3116 case 103: /* $@10: %empty */ 3117 #line 634 "./config/rx-parse.y" 3118 { sub_op = 6; } 3119 #line 3120 "config/rx-parse.c" 3120 break; 3121 3122 case 105: /* $@11: %empty */ 3123 #line 635 "./config/rx-parse.y" 3124 { sub_op = 7; } 3125 #line 3126 "config/rx-parse.c" 3126 break; 3127 3128 case 107: /* $@12: %empty */ 3129 #line 636 "./config/rx-parse.y" 3130 { sub_op = 8; } 3131 #line 3132 "config/rx-parse.c" 3132 break; 3133 3134 case 109: /* $@13: %empty */ 3135 #line 637 "./config/rx-parse.y" 3136 { sub_op = 9; } 3137 #line 3138 "config/rx-parse.c" 3138 break; 3139 3140 case 111: /* $@14: %empty */ 3141 #line 638 "./config/rx-parse.y" 3142 { sub_op = 12; } 3143 #line 3144 "config/rx-parse.c" 3144 break; 3145 3146 case 113: /* $@15: %empty */ 3147 #line 639 "./config/rx-parse.y" 3148 { sub_op = 13; } 3149 #line 3150 "config/rx-parse.c" 3150 break; 3151 3152 case 115: /* $@16: %empty */ 3153 #line 640 "./config/rx-parse.y" 3154 { sub_op = 14; sub_op2 = 0; } 3155 #line 3156 "config/rx-parse.c" 3156 break; 3157 3158 case 117: /* $@17: %empty */ 3159 #line 641 "./config/rx-parse.y" 3160 { sub_op = 14; sub_op2 = 0; } 3161 #line 3162 "config/rx-parse.c" 3162 break; 3163 3164 case 119: /* $@18: %empty */ 3165 #line 642 "./config/rx-parse.y" 3166 { sub_op = 15; sub_op2 = 1; } 3167 #line 3168 "config/rx-parse.c" 3168 break; 3169 3170 case 121: /* $@19: %empty */ 3171 #line 646 "./config/rx-parse.y" 3172 { sub_op = 6; } 3173 #line 3174 "config/rx-parse.c" 3174 break; 3175 3176 case 123: /* $@20: %empty */ 3177 #line 647 "./config/rx-parse.y" 3178 { sub_op = 7; } 3179 #line 3180 "config/rx-parse.c" 3180 break; 3181 3182 case 125: /* $@21: %empty */ 3183 #line 648 "./config/rx-parse.y" 3184 { sub_op = 16; } 3185 #line 3186 "config/rx-parse.c" 3186 break; 3187 3188 case 127: /* $@22: %empty */ 3189 #line 649 "./config/rx-parse.y" 3190 { sub_op = 17; } 3191 #line 3192 "config/rx-parse.c" 3192 break; 3193 3194 case 129: /* $@23: %empty */ 3195 #line 650 "./config/rx-parse.y" 3196 { sub_op = 21; } 3197 #line 3198 "config/rx-parse.c" 3198 break; 3199 3200 case 131: /* statement: BSET REG ',' REG */ 3201 #line 655 "./config/rx-parse.y" 3202 { id24 (1, 0x63, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); } 3203 #line 3204 "config/rx-parse.c" 3204 break; 3205 3206 case 132: /* statement: BCLR REG ',' REG */ 3207 #line 657 "./config/rx-parse.y" 3208 { id24 (1, 0x67, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); } 3209 #line 3210 "config/rx-parse.c" 3210 break; 3211 3212 case 133: /* statement: BTST REG ',' REG */ 3213 #line 659 "./config/rx-parse.y" 3214 { id24 (1, 0x6b, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); } 3215 #line 3216 "config/rx-parse.c" 3216 break; 3217 3218 case 134: /* statement: BNOT REG ',' REG */ 3219 #line 661 "./config/rx-parse.y" 3220 { id24 (1, 0x6f, 0x00); F ((yyvsp[0].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); } 3221 #line 3222 "config/rx-parse.c" 3222 break; 3223 3224 case 135: /* statement: BSET REG ',' disp '[' REG ']' opt_b */ 3225 #line 664 "./config/rx-parse.y" 3226 { id24 (1, 0x60, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); } 3227 #line 3228 "config/rx-parse.c" 3228 break; 3229 3230 case 136: /* statement: BCLR REG ',' disp '[' REG ']' opt_b */ 3231 #line 666 "./config/rx-parse.y" 3232 { id24 (1, 0x64, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); } 3233 #line 3234 "config/rx-parse.c" 3234 break; 3235 3236 case 137: /* statement: BTST REG ',' disp '[' REG ']' opt_b */ 3237 #line 668 "./config/rx-parse.y" 3238 { id24 (1, 0x68, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); } 3239 #line 3240 "config/rx-parse.c" 3240 break; 3241 3242 case 138: /* statement: BNOT REG ',' disp '[' REG ']' opt_b */ 3243 #line 670 "./config/rx-parse.y" 3244 { id24 (1, 0x6c, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); } 3245 #line 3246 "config/rx-parse.c" 3246 break; 3247 3248 case 139: /* $@24: %empty */ 3249 #line 674 "./config/rx-parse.y" 3250 { sub_op = 0; } 3251 #line 3252 "config/rx-parse.c" 3252 break; 3253 3254 case 141: /* $@25: %empty */ 3255 #line 675 "./config/rx-parse.y" 3256 { sub_op = 1; } 3257 #line 3258 "config/rx-parse.c" 3258 break; 3259 3260 case 143: /* $@26: %empty */ 3261 #line 676 "./config/rx-parse.y" 3262 { sub_op = 2; } 3263 #line 3264 "config/rx-parse.c" 3264 break; 3265 3266 case 145: /* $@27: %empty */ 3267 #line 677 "./config/rx-parse.y" 3268 { sub_op = 3; } 3269 #line 3270 "config/rx-parse.c" 3270 break; 3271 3272 case 147: /* $@28: %empty */ 3273 #line 678 "./config/rx-parse.y" 3274 { sub_op = 4; } 3275 #line 3276 "config/rx-parse.c" 3276 break; 3277 3278 case 149: /* $@29: %empty */ 3279 #line 679 "./config/rx-parse.y" 3280 { sub_op = 8; } 3281 #line 3282 "config/rx-parse.c" 3282 break; 3283 3284 case 151: /* $@30: %empty */ 3285 #line 680 "./config/rx-parse.y" 3286 { sub_op = 5; } 3287 #line 3288 "config/rx-parse.c" 3288 break; 3289 3290 case 153: /* $@31: %empty */ 3291 #line 681 "./config/rx-parse.y" 3292 { sub_op = 9; } 3293 #line 3294 "config/rx-parse.c" 3294 break; 3295 3296 case 155: /* $@32: %empty */ 3297 #line 682 "./config/rx-parse.y" 3298 { sub_op = 6; } 3299 #line 3300 "config/rx-parse.c" 3300 break; 3301 3302 case 157: /* statement: SCCND DOT_L REG */ 3303 #line 690 "./config/rx-parse.y" 3304 { id24 (1, 0xdb, 0x00); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 16, 4); } 3305 #line 3306 "config/rx-parse.c" 3306 break; 3307 3308 case 158: /* statement: SCCND bwl disp '[' REG ']' */ 3309 #line 692 "./config/rx-parse.y" 3310 { id24 (1, 0xd0, 0x00); F ((yyvsp[-5].regno), 20, 4); F ((yyvsp[-4].regno), 12, 2); F ((yyvsp[-1].regno), 16, 4); DSP ((yyvsp[-3].exp), 14, (yyvsp[-4].regno)); } 3311 #line 3312 "config/rx-parse.c" 3312 break; 3313 3314 case 159: /* statement: BMCND '#' EXPR ',' disp '[' REG ']' opt_b */ 3315 #line 697 "./config/rx-parse.y" 3316 { id24 (1, 0xe0, 0x00); F ((yyvsp[-8].regno), 20, 4); FE ((yyvsp[-6].exp), 11, 3); 3317 F ((yyvsp[-2].regno), 16, 4); DSP ((yyvsp[-4].exp), 14, BSIZE); } 3318 #line 3319 "config/rx-parse.c" 3319 break; 3320 3321 case 160: /* statement: BNOT '#' EXPR ',' disp '[' REG ']' opt_b */ 3322 #line 703 "./config/rx-parse.y" 3323 { id24 (1, 0xe0, 0x0f); FE ((yyvsp[-6].exp), 11, 3); F ((yyvsp[-2].regno), 16, 4); 3324 DSP ((yyvsp[-4].exp), 14, BSIZE); } 3325 #line 3326 "config/rx-parse.c" 3326 break; 3327 3328 case 161: /* statement: MULHI REG ',' REG */ 3329 #line 709 "./config/rx-parse.y" 3330 { id24 (2, 0x00, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3331 #line 3332 "config/rx-parse.c" 3332 break; 3333 3334 case 162: /* statement: MULHI REG ',' REG ',' ACC */ 3335 #line 711 "./config/rx-parse.y" 3336 { rx_check_v2 (); id24 (2, 0x00, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3337 #line 3338 "config/rx-parse.c" 3338 break; 3339 3340 case 163: /* statement: MULLO REG ',' REG */ 3341 #line 713 "./config/rx-parse.y" 3342 { id24 (2, 0x01, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3343 #line 3344 "config/rx-parse.c" 3344 break; 3345 3346 case 164: /* statement: MULLO REG ',' REG ',' ACC */ 3347 #line 715 "./config/rx-parse.y" 3348 { rx_check_v2 (); id24 (2, 0x01, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3349 #line 3350 "config/rx-parse.c" 3350 break; 3351 3352 case 165: /* statement: MACHI REG ',' REG */ 3353 #line 717 "./config/rx-parse.y" 3354 { id24 (2, 0x04, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3355 #line 3356 "config/rx-parse.c" 3356 break; 3357 3358 case 166: /* statement: MACHI REG ',' REG ',' ACC */ 3359 #line 719 "./config/rx-parse.y" 3360 { rx_check_v2 (); id24 (2, 0x04, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3361 #line 3362 "config/rx-parse.c" 3362 break; 3363 3364 case 167: /* statement: MACLO REG ',' REG */ 3365 #line 721 "./config/rx-parse.y" 3366 { id24 (2, 0x05, 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3367 #line 3368 "config/rx-parse.c" 3368 break; 3369 3370 case 168: /* statement: MACLO REG ',' REG ',' ACC */ 3371 #line 723 "./config/rx-parse.y" 3372 { rx_check_v2 (); id24 (2, 0x05, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3373 #line 3374 "config/rx-parse.c" 3374 break; 3375 3376 case 169: /* statement: MVTACHI REG */ 3377 #line 729 "./config/rx-parse.y" 3378 { id24 (2, 0x17, 0x00); F ((yyvsp[0].regno), 20, 4); } 3379 #line 3380 "config/rx-parse.c" 3380 break; 3381 3382 case 170: /* statement: MVTACHI REG ',' ACC */ 3383 #line 731 "./config/rx-parse.y" 3384 { rx_check_v2 (); id24 (2, 0x17, 0x00); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 16, 1); } 3385 #line 3386 "config/rx-parse.c" 3386 break; 3387 3388 case 171: /* statement: MVTACLO REG */ 3389 #line 733 "./config/rx-parse.y" 3390 { id24 (2, 0x17, 0x10); F ((yyvsp[0].regno), 20, 4); } 3391 #line 3392 "config/rx-parse.c" 3392 break; 3393 3394 case 172: /* statement: MVTACLO REG ',' ACC */ 3395 #line 735 "./config/rx-parse.y" 3396 { rx_check_v2 (); id24 (2, 0x17, 0x10); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 16, 1); } 3397 #line 3398 "config/rx-parse.c" 3398 break; 3399 3400 case 173: /* statement: MVFACHI REG */ 3401 #line 737 "./config/rx-parse.y" 3402 { id24 (2, 0x1f, 0x00); F ((yyvsp[0].regno), 20, 4); } 3403 #line 3404 "config/rx-parse.c" 3404 break; 3405 3406 case 174: /* $@33: %empty */ 3407 #line 738 "./config/rx-parse.y" 3408 { sub_op = 0; } 3409 #line 3410 "config/rx-parse.c" 3410 break; 3411 3412 case 176: /* statement: MVFACMI REG */ 3413 #line 740 "./config/rx-parse.y" 3414 { id24 (2, 0x1f, 0x20); F ((yyvsp[0].regno), 20, 4); } 3415 #line 3416 "config/rx-parse.c" 3416 break; 3417 3418 case 177: /* $@34: %empty */ 3419 #line 741 "./config/rx-parse.y" 3420 { sub_op = 2; } 3421 #line 3422 "config/rx-parse.c" 3422 break; 3423 3424 case 179: /* statement: MVFACLO REG */ 3425 #line 743 "./config/rx-parse.y" 3426 { id24 (2, 0x1f, 0x10); F ((yyvsp[0].regno), 20, 4); } 3427 #line 3428 "config/rx-parse.c" 3428 break; 3429 3430 case 180: /* $@35: %empty */ 3431 #line 744 "./config/rx-parse.y" 3432 { sub_op = 1; } 3433 #line 3434 "config/rx-parse.c" 3434 break; 3435 3436 case 182: /* statement: RACW '#' EXPR */ 3437 #line 746 "./config/rx-parse.y" 3438 { id24 (2, 0x18, 0x00); 3439 if (rx_uintop ((yyvsp[0].exp), 4) && exp_val((yyvsp[0].exp)) == 1) 3440 ; 3441 else if (rx_uintop ((yyvsp[0].exp), 4) && exp_val((yyvsp[0].exp)) == 2) 3442 F (1, 19, 1); 3443 else 3444 as_bad (_("RACW expects #1 or #2"));} 3445 #line 3446 "config/rx-parse.c" 3446 break; 3447 3448 case 183: /* statement: RACW '#' EXPR ',' ACC */ 3449 #line 754 "./config/rx-parse.y" 3450 { rx_check_v2 (); id24 (2, 0x18, 0x00); F ((yyvsp[0].regno), 16, 1); 3451 if (rx_uintop ((yyvsp[-2].exp), 4) && exp_val((yyvsp[-2].exp)) == 1) 3452 ; 3453 else if (rx_uintop ((yyvsp[-2].exp), 4) && exp_val((yyvsp[-2].exp)) == 2) 3454 F (1, 19, 1); 3455 else 3456 as_bad (_("RACW expects #1 or #2"));} 3457 #line 3458 "config/rx-parse.c" 3458 break; 3459 3460 case 184: /* statement: MOV bwl REG ',' '[' REG '+' ']' */ 3461 #line 765 "./config/rx-parse.y" 3462 { id24 (2, 0x20, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[-5].regno), 20, 4); } 3463 #line 3464 "config/rx-parse.c" 3464 break; 3465 3466 case 185: /* statement: MOV bwl REG ',' '[' '-' REG ']' */ 3467 #line 767 "./config/rx-parse.y" 3468 { id24 (2, 0x24, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-1].regno), 16, 4); F ((yyvsp[-5].regno), 20, 4); } 3469 #line 3470 "config/rx-parse.c" 3470 break; 3471 3472 case 186: /* statement: MOV bwl '[' REG '+' ']' ',' REG */ 3473 #line 772 "./config/rx-parse.y" 3474 { id24 (2, 0x28, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3475 #line 3476 "config/rx-parse.c" 3476 break; 3477 3478 case 187: /* statement: MOV bwl '[' '-' REG ']' ',' REG */ 3479 #line 774 "./config/rx-parse.y" 3480 { id24 (2, 0x2c, 0); F ((yyvsp[-6].regno), 14, 2); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3481 #line 3482 "config/rx-parse.c" 3482 break; 3483 3484 case 188: /* statement: MOVU bw '[' REG '+' ']' ',' REG */ 3485 #line 779 "./config/rx-parse.y" 3486 { id24 (2, 0x38, 0); F ((yyvsp[-6].regno), 15, 1); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3487 #line 3488 "config/rx-parse.c" 3488 break; 3489 3490 case 189: /* statement: MOVU bw '[' '-' REG ']' ',' REG */ 3491 #line 781 "./config/rx-parse.y" 3492 { id24 (2, 0x3c, 0); F ((yyvsp[-6].regno), 15, 1); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3493 #line 3494 "config/rx-parse.c" 3494 break; 3495 3496 case 190: /* $@36: %empty */ 3497 #line 785 "./config/rx-parse.y" 3498 { sub_op = 6; } 3499 #line 3500 "config/rx-parse.c" 3500 break; 3501 3502 case 192: /* $@37: %empty */ 3503 #line 786 "./config/rx-parse.y" 3504 { sub_op = 4; } 3505 #line 3506 "config/rx-parse.c" 3506 break; 3507 3508 case 194: /* $@38: %empty */ 3509 #line 787 "./config/rx-parse.y" 3510 { sub_op = 5; } 3511 #line 3512 "config/rx-parse.c" 3512 break; 3513 3514 case 196: /* $@39: %empty */ 3515 #line 788 "./config/rx-parse.y" 3516 { sub_op = 7; } 3517 #line 3518 "config/rx-parse.c" 3518 break; 3519 3520 case 198: /* statement: MVTC REG ',' CREG */ 3521 #line 793 "./config/rx-parse.y" 3522 { if ((yyvsp[0].regno) == 13) 3523 rx_check_v2 (); 3524 id24 (2, 0x68, 0x00); F ((yyvsp[0].regno) % 16, 20, 4); F ((yyvsp[0].regno) / 16, 15, 1); 3525 F ((yyvsp[-2].regno), 16, 4); } 3526 #line 3527 "config/rx-parse.c" 3527 break; 3528 3529 case 199: /* statement: MVFC CREG ',' REG */ 3530 #line 801 "./config/rx-parse.y" 3531 { if ((yyvsp[-2].regno) == 13) 3532 rx_check_v2 (); 3533 id24 (2, 0x6a, 0); F ((yyvsp[-2].regno), 15, 5); F ((yyvsp[0].regno), 20, 4); } 3534 #line 3535 "config/rx-parse.c" 3535 break; 3536 3537 case 200: /* statement: ROTL '#' EXPR ',' REG */ 3538 #line 808 "./config/rx-parse.y" 3539 { id24 (2, 0x6e, 0); FE ((yyvsp[-2].exp), 15, 5); F ((yyvsp[0].regno), 20, 4); } 3540 #line 3541 "config/rx-parse.c" 3541 break; 3542 3543 case 201: /* statement: ROTR '#' EXPR ',' REG */ 3544 #line 810 "./config/rx-parse.y" 3545 { id24 (2, 0x6c, 0); FE ((yyvsp[-2].exp), 15, 5); F ((yyvsp[0].regno), 20, 4); } 3546 #line 3547 "config/rx-parse.c" 3547 break; 3548 3549 case 202: /* statement: MVTC '#' EXPR ',' CREG */ 3550 #line 815 "./config/rx-parse.y" 3551 { if ((yyvsp[0].regno) == 13) 3552 rx_check_v2 (); 3553 id24 (2, 0x73, 0x00); F ((yyvsp[0].regno), 19, 5); IMM ((yyvsp[-2].exp), 12); } 3554 #line 3555 "config/rx-parse.c" 3555 break; 3556 3557 case 203: /* statement: BMCND '#' EXPR ',' REG */ 3558 #line 822 "./config/rx-parse.y" 3559 { id24 (2, 0xe0, 0x00); F ((yyvsp[-4].regno), 16, 4); FE ((yyvsp[-2].exp), 11, 5); 3560 F ((yyvsp[0].regno), 20, 4); } 3561 #line 3562 "config/rx-parse.c" 3562 break; 3563 3564 case 204: /* statement: BNOT '#' EXPR ',' REG */ 3565 #line 828 "./config/rx-parse.y" 3566 { id24 (2, 0xe0, 0xf0); FE ((yyvsp[-2].exp), 11, 5); F ((yyvsp[0].regno), 20, 4); } 3567 #line 3568 "config/rx-parse.c" 3568 break; 3569 3570 case 205: /* statement: MOV bwl REG ',' '[' REG ',' REG ']' */ 3571 #line 833 "./config/rx-parse.y" 3572 { id24 (3, 0x00, 0); F ((yyvsp[-7].regno), 10, 2); F ((yyvsp[-3].regno), 12, 4); F ((yyvsp[-1].regno), 16, 4); F ((yyvsp[-6].regno), 20, 4); } 3573 #line 3574 "config/rx-parse.c" 3574 break; 3575 3576 case 206: /* statement: MOV bwl '[' REG ',' REG ']' ',' REG */ 3577 #line 836 "./config/rx-parse.y" 3578 { id24 (3, 0x40, 0); F ((yyvsp[-7].regno), 10, 2); F ((yyvsp[-5].regno), 12, 4); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3579 #line 3580 "config/rx-parse.c" 3580 break; 3581 3582 case 207: /* statement: MOVU bw '[' REG ',' REG ']' ',' REG */ 3583 #line 839 "./config/rx-parse.y" 3584 { id24 (3, 0xc0, 0); F ((yyvsp[-7].regno), 10, 2); F ((yyvsp[-5].regno), 12, 4); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3585 #line 3586 "config/rx-parse.c" 3586 break; 3587 3588 case 208: /* $@40: %empty */ 3589 #line 843 "./config/rx-parse.y" 3590 { sub_op = 0; } 3591 #line 3592 "config/rx-parse.c" 3592 break; 3593 3594 case 210: /* $@41: %empty */ 3595 #line 844 "./config/rx-parse.y" 3596 { sub_op = 2; } 3597 #line 3598 "config/rx-parse.c" 3598 break; 3599 3600 case 212: /* $@42: %empty */ 3601 #line 845 "./config/rx-parse.y" 3602 { sub_op = 3; } 3603 #line 3604 "config/rx-parse.c" 3604 break; 3605 3606 case 214: /* $@43: %empty */ 3607 #line 846 "./config/rx-parse.y" 3608 { sub_op = 4; } 3609 #line 3610 "config/rx-parse.c" 3610 break; 3611 3612 case 216: /* $@44: %empty */ 3613 #line 847 "./config/rx-parse.y" 3614 { sub_op = 5; } 3615 #line 3616 "config/rx-parse.c" 3616 break; 3617 3618 case 218: /* statement: SBB '#' EXPR ',' REG */ 3619 #line 853 "./config/rx-parse.y" 3620 { id24 (2, 0x70, 0x20); F ((yyvsp[0].regno), 20, 4); NBIMM ((yyvsp[-2].exp), 12); } 3621 #line 3622 "config/rx-parse.c" 3622 break; 3623 3624 case 219: /* statement: MOVCO REG ',' '[' REG ']' */ 3625 #line 858 "./config/rx-parse.y" 3626 { rx_check_v2 (); B3 (0xfd, 0x27, 0x00); F ((yyvsp[-1].regno), 16, 4); F ((yyvsp[-4].regno), 20, 4); } 3627 #line 3628 "config/rx-parse.c" 3628 break; 3629 3630 case 220: /* statement: MOVLI '[' REG ']' ',' REG */ 3631 #line 863 "./config/rx-parse.y" 3632 { rx_check_v2 (); B3 (0xfd, 0x2f, 0x00); F ((yyvsp[-3].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 3633 #line 3634 "config/rx-parse.c" 3634 break; 3635 3636 case 221: /* statement: EMACA REG ',' REG ',' ACC */ 3637 #line 868 "./config/rx-parse.y" 3638 { rx_check_v2 (); id24 (2, 0x07, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3639 #line 3640 "config/rx-parse.c" 3640 break; 3641 3642 case 222: /* statement: EMSBA REG ',' REG ',' ACC */ 3643 #line 870 "./config/rx-parse.y" 3644 { rx_check_v2 (); id24 (2, 0x47, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3645 #line 3646 "config/rx-parse.c" 3646 break; 3647 3648 case 223: /* statement: EMULA REG ',' REG ',' ACC */ 3649 #line 872 "./config/rx-parse.y" 3650 { rx_check_v2 (); id24 (2, 0x03, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3651 #line 3652 "config/rx-parse.c" 3652 break; 3653 3654 case 224: /* statement: MACLH REG ',' REG ',' ACC */ 3655 #line 874 "./config/rx-parse.y" 3656 { rx_check_v2 (); id24 (2, 0x06, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3657 #line 3658 "config/rx-parse.c" 3658 break; 3659 3660 case 225: /* statement: MSBHI REG ',' REG ',' ACC */ 3661 #line 876 "./config/rx-parse.y" 3662 { rx_check_v2 (); id24 (2, 0x44, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3663 #line 3664 "config/rx-parse.c" 3664 break; 3665 3666 case 226: /* statement: MSBLH REG ',' REG ',' ACC */ 3667 #line 878 "./config/rx-parse.y" 3668 { rx_check_v2 (); id24 (2, 0x46, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3669 #line 3670 "config/rx-parse.c" 3670 break; 3671 3672 case 227: /* statement: MSBLO REG ',' REG ',' ACC */ 3673 #line 880 "./config/rx-parse.y" 3674 { rx_check_v2 (); id24 (2, 0x45, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3675 #line 3676 "config/rx-parse.c" 3676 break; 3677 3678 case 228: /* statement: MULLH REG ',' REG ',' ACC */ 3679 #line 882 "./config/rx-parse.y" 3680 { rx_check_v2 (); id24 (2, 0x02, 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 1); } 3681 #line 3682 "config/rx-parse.c" 3682 break; 3683 3684 case 229: /* $@45: %empty */ 3685 #line 883 "./config/rx-parse.y" 3686 { sub_op = 3; } 3687 #line 3688 "config/rx-parse.c" 3688 break; 3689 3690 case 231: /* statement: MVTACGU REG ',' ACC */ 3691 #line 885 "./config/rx-parse.y" 3692 { rx_check_v2 (); id24 (2, 0x17, 0x30); F ((yyvsp[0].regno), 16, 1); F ((yyvsp[-2].regno), 20, 4); } 3693 #line 3694 "config/rx-parse.c" 3694 break; 3695 3696 case 232: /* statement: RACL '#' EXPR ',' ACC */ 3697 #line 887 "./config/rx-parse.y" 3698 { rx_check_v2 (); id24 (2, 0x19, 0x00); F ((yyvsp[0].regno), 16, 1); 3699 if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 1) 3700 ; 3701 else if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 2) 3702 F (1, 19, 1); 3703 else 3704 as_bad (_("RACL expects #1 or #2"));} 3705 #line 3706 "config/rx-parse.c" 3706 break; 3707 3708 case 233: /* statement: RDACL '#' EXPR ',' ACC */ 3709 #line 895 "./config/rx-parse.y" 3710 { rx_check_v2 (); id24 (2, 0x19, 0x40); F ((yyvsp[0].regno), 16, 1); 3711 if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 1) 3712 ; 3713 else if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 2) 3714 F (1, 19, 1); 3715 else 3716 as_bad (_("RDACL expects #1 or #2"));} 3717 #line 3718 "config/rx-parse.c" 3718 break; 3719 3720 case 234: /* statement: RDACW '#' EXPR ',' ACC */ 3721 #line 903 "./config/rx-parse.y" 3722 { rx_check_v2 (); id24 (2, 0x18, 0x40); F ((yyvsp[0].regno), 16, 1); 3723 if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 1) 3724 ; 3725 else if (rx_uintop ((yyvsp[-2].exp), 4) && (yyvsp[-2].exp).X_add_number == 2) 3726 F (1, 19, 1); 3727 else 3728 as_bad (_("RDACW expects #1 or #2"));} 3729 #line 3730 "config/rx-parse.c" 3730 break; 3731 3732 case 235: /* $@46: %empty */ 3733 #line 912 "./config/rx-parse.y" 3734 { rx_check_v3(); sub_op = 1; } 3735 #line 3736 "config/rx-parse.c" 3736 break; 3737 3738 case 237: /* $@47: %empty */ 3739 #line 913 "./config/rx-parse.y" 3740 { rx_check_v3(); sub_op = 0; } 3741 #line 3742 "config/rx-parse.c" 3742 break; 3743 3744 case 239: /* $@48: %empty */ 3745 #line 916 "./config/rx-parse.y" 3746 { rx_check_v3(); sub_op = 1; } 3747 #line 3748 "config/rx-parse.c" 3748 break; 3749 3750 case 241: /* $@49: %empty */ 3751 #line 917 "./config/rx-parse.y" 3752 { rx_check_v3(); sub_op = 0; } 3753 #line 3754 "config/rx-parse.c" 3754 break; 3755 3756 case 243: /* $@50: %empty */ 3757 #line 920 "./config/rx-parse.y" 3758 { rx_check_dfpu(); sub_op = 0x0c; sub_op2 = 0x01; } 3759 #line 3760 "config/rx-parse.c" 3760 break; 3761 3762 case 245: /* $@51: %empty */ 3763 #line 921 "./config/rx-parse.y" 3764 { rx_check_dfpu(); sub_op = 0x0c; sub_op2 = 0x02; } 3765 #line 3766 "config/rx-parse.c" 3766 break; 3767 3768 case 247: /* $@52: %empty */ 3769 #line 922 "./config/rx-parse.y" 3770 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x0d; } 3771 #line 3772 "config/rx-parse.c" 3772 break; 3773 3774 case 249: /* $@53: %empty */ 3775 #line 923 "./config/rx-parse.y" 3776 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x00; } 3777 #line 3778 "config/rx-parse.c" 3778 break; 3779 3780 case 251: /* $@54: %empty */ 3781 #line 924 "./config/rx-parse.y" 3782 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x0c; } 3783 #line 3784 "config/rx-parse.c" 3784 break; 3785 3786 case 253: /* $@55: %empty */ 3787 #line 925 "./config/rx-parse.y" 3788 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x08;} 3789 #line 3790 "config/rx-parse.c" 3790 break; 3791 3792 case 255: /* $@56: %empty */ 3793 #line 926 "./config/rx-parse.y" 3794 { rx_check_dfpu(); sub_op = 0x0d; sub_op2 = 0x09; } 3795 #line 3796 "config/rx-parse.c" 3796 break; 3797 3798 case 257: /* $@57: %empty */ 3799 #line 927 "./config/rx-parse.y" 3800 { rx_check_dfpu(); sub_op = 0x00; } 3801 #line 3802 "config/rx-parse.c" 3802 break; 3803 3804 case 259: /* $@58: %empty */ 3805 #line 928 "./config/rx-parse.y" 3806 { rx_check_dfpu(); sub_op = 0x05; } 3807 #line 3808 "config/rx-parse.c" 3808 break; 3809 3810 case 261: /* $@59: %empty */ 3811 #line 929 "./config/rx-parse.y" 3812 { rx_check_dfpu(); sub_op = 0x02; } 3813 #line 3814 "config/rx-parse.c" 3814 break; 3815 3816 case 263: /* $@60: %empty */ 3817 #line 930 "./config/rx-parse.y" 3818 { rx_check_dfpu(); sub_op = 0x01; } 3819 #line 3820 "config/rx-parse.c" 3820 break; 3821 3822 case 265: /* statement: DCMP DREG ',' DREG */ 3823 #line 931 "./config/rx-parse.y" 3824 { rx_check_dfpu(); 3825 B4(0x76, 0x90, 0x08, 0x00); F((yyvsp[-3].regno), 24, 4); F((yyvsp[-2].regno), 28, 4); F((yyvsp[0].regno), 16, 4); } 3826 #line 3827 "config/rx-parse.c" 3827 break; 3828 3829 case 266: /* statement: DMOV DOT_D REG ',' DREGH */ 3830 #line 934 "./config/rx-parse.y" 3831 { rx_check_dfpu(); 3832 B4(0xfd, 0x77, 0x80, 0x03); F((yyvsp[-2].regno), 20, 4); F((yyvsp[0].regno), 24, 4); } 3833 #line 3834 "config/rx-parse.c" 3834 break; 3835 3836 case 267: /* statement: DMOV DOT_L REG ',' DREGH */ 3837 #line 937 "./config/rx-parse.y" 3838 { rx_check_dfpu(); 3839 B4(0xfd, 0x77, 0x80, 0x02); F((yyvsp[-2].regno), 20, 4); F((yyvsp[0].regno), 24, 4); } 3840 #line 3841 "config/rx-parse.c" 3841 break; 3842 3843 case 268: /* statement: DMOV DOT_L REG ',' DREGL */ 3844 #line 940 "./config/rx-parse.y" 3845 { rx_check_dfpu(); 3846 B4(0xfd, 0x77, 0x80, 0x00); F((yyvsp[-2].regno), 20, 4); F((yyvsp[0].regno), 24, 4); } 3847 #line 3848 "config/rx-parse.c" 3848 break; 3849 3850 case 269: /* statement: DMOV DOT_L DREGH ',' REG */ 3851 #line 943 "./config/rx-parse.y" 3852 { rx_check_dfpu(); 3853 B4(0xfd, 0x75, 0x80, 0x02); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); } 3854 #line 3855 "config/rx-parse.c" 3855 break; 3856 3857 case 270: /* statement: DMOV DOT_L DREGL ',' REG */ 3858 #line 946 "./config/rx-parse.y" 3859 { rx_check_dfpu(); 3860 B4(0xfd, 0x75, 0x80, 0x00); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); } 3861 #line 3862 "config/rx-parse.c" 3862 break; 3863 3864 case 271: /* statement: DMOV DOT_D DREG ',' DREG */ 3865 #line 949 "./config/rx-parse.y" 3866 { rx_check_dfpu(); 3867 B4(0x76, 0x90, 0x0c, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno), 24, 4); } 3868 #line 3869 "config/rx-parse.c" 3869 break; 3870 3871 case 272: /* statement: DMOV DOT_D DREG ',' '[' REG ']' */ 3872 #line 952 "./config/rx-parse.y" 3873 { rx_check_dfpu(); 3874 B4(0xfc, 0x78, 0x08, 0x00); F((yyvsp[-1].regno), 16, 4); F((yyvsp[-4].regno), 24, 4); } 3875 #line 3876 "config/rx-parse.c" 3876 break; 3877 3878 case 273: /* statement: DMOV DOT_D DREG ',' disp '[' REG ']' */ 3879 #line 955 "./config/rx-parse.y" 3880 { rx_check_dfpu(); 3881 B3(0xfc, 0x78, 0x08); F((yyvsp[-1].regno), 16, 4); DSP((yyvsp[-3].exp), 14, DSIZE); 3882 POST((yyvsp[-5].regno) << 4); } 3883 #line 3884 "config/rx-parse.c" 3884 break; 3885 3886 case 274: /* statement: DMOV DOT_D '[' REG ']' ',' DREG */ 3887 #line 959 "./config/rx-parse.y" 3888 { rx_check_dfpu(); 3889 B4(0xfc, 0xc8, 0x08, 0x00); F((yyvsp[-3].regno), 16, 4); F((yyvsp[0].regno), 24, 4); } 3890 #line 3891 "config/rx-parse.c" 3891 break; 3892 3893 case 275: /* statement: DMOV DOT_D disp '[' REG ']' ',' DREG */ 3894 #line 962 "./config/rx-parse.y" 3895 { rx_check_dfpu(); 3896 B3(0xfc, 0xc8, 0x08); F((yyvsp[-3].regno), 16, 4); DSP((yyvsp[-5].exp), 14, DSIZE); 3897 POST((yyvsp[0].regno) << 4); } 3898 #line 3899 "config/rx-parse.c" 3899 break; 3900 3901 case 276: /* statement: DMOV DOT_D '#' EXPR ',' DREGH */ 3902 #line 966 "./config/rx-parse.y" 3903 { rx_check_dfpu(); 3904 B3(0xf9, 0x03, 0x03); F((yyvsp[0].regno), 16, 4); IMM((yyvsp[-2].exp), -1); } 3905 #line 3906 "config/rx-parse.c" 3906 break; 3907 3908 case 277: /* statement: DMOV DOT_L '#' EXPR ',' DREGH */ 3909 #line 969 "./config/rx-parse.y" 3910 { rx_check_dfpu(); 3911 B3(0xf9, 0x03, 0x02); F((yyvsp[0].regno), 16, 4); IMM((yyvsp[-2].exp), -1); } 3912 #line 3913 "config/rx-parse.c" 3913 break; 3914 3915 case 278: /* statement: DMOV DOT_L '#' EXPR ',' DREGL */ 3916 #line 972 "./config/rx-parse.y" 3917 { rx_check_dfpu(); 3918 B3(0xf9, 0x03, 0x00); F((yyvsp[0].regno), 16, 4); IMM((yyvsp[-2].exp), -1); } 3919 #line 3920 "config/rx-parse.c" 3920 break; 3921 3922 case 279: /* statement: DPOPM DOT_D DREG '-' DREG */ 3923 #line 975 "./config/rx-parse.y" 3924 { rx_check_dfpu(); 3925 B3(0x75, 0xb8, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); } 3926 #line 3927 "config/rx-parse.c" 3927 break; 3928 3929 case 280: /* statement: DPOPM DOT_L DCREG '-' DCREG */ 3930 #line 978 "./config/rx-parse.y" 3931 { rx_check_dfpu(); 3932 B3(0x75, 0xa8, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); } 3933 #line 3934 "config/rx-parse.c" 3934 break; 3935 3936 case 281: /* statement: DPUSHM DOT_D DREG '-' DREG */ 3937 #line 981 "./config/rx-parse.y" 3938 { rx_check_dfpu(); 3939 B3(0x75, 0xb0, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); } 3940 #line 3941 "config/rx-parse.c" 3941 break; 3942 3943 case 282: /* statement: DPUSHM DOT_L DCREG '-' DCREG */ 3944 #line 984 "./config/rx-parse.y" 3945 { rx_check_dfpu(); 3946 B3(0x75, 0xa0, 0x00); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno) - (yyvsp[-2].regno), 20, 4); } 3947 #line 3948 "config/rx-parse.c" 3948 break; 3949 3950 case 283: /* statement: MVFDC DCREG ',' REG */ 3951 #line 987 "./config/rx-parse.y" 3952 { rx_check_dfpu(); 3953 B4(0xfd, 0x75, 0x80, 0x04); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); } 3954 #line 3955 "config/rx-parse.c" 3955 break; 3956 3957 case 284: /* statement: MVFDR */ 3958 #line 990 "./config/rx-parse.y" 3959 { rx_check_dfpu(); B3(0x75, 0x90, 0x1b); } 3960 #line 3961 "config/rx-parse.c" 3961 break; 3962 3963 case 285: /* statement: MVTDC REG ',' DCREG */ 3964 #line 992 "./config/rx-parse.y" 3965 { rx_check_dfpu(); 3966 B4(0xfd, 0x77, 0x80, 0x04); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); } 3967 #line 3968 "config/rx-parse.c" 3968 break; 3969 3970 case 286: /* statement: FTOD REG ',' DREG */ 3971 #line 995 "./config/rx-parse.y" 3972 { rx_check_dfpu(); 3973 B4(0xfd, 0x77, 0x80, 0x0a); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); } 3974 #line 3975 "config/rx-parse.c" 3975 break; 3976 3977 case 287: /* statement: ITOD REG ',' DREG */ 3978 #line 998 "./config/rx-parse.y" 3979 { rx_check_dfpu(); 3980 B4(0xfd, 0x77, 0x80, 0x09); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); } 3981 #line 3982 "config/rx-parse.c" 3982 break; 3983 3984 case 288: /* statement: UTOD REG ',' DREG */ 3985 #line 1001 "./config/rx-parse.y" 3986 { rx_check_dfpu(); 3987 B4(0xfd, 0x77, 0x80, 0x0d); F((yyvsp[-2].regno), 24, 4); F((yyvsp[0].regno), 20, 4); } 3988 #line 3989 "config/rx-parse.c" 3989 break; 3990 3991 case 289: /* op_subadd: REG ',' REG */ 3992 #line 1012 "./config/rx-parse.y" 3993 { B2 (0x43 + (sub_op<<2), 0); F ((yyvsp[-2].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); } 3994 #line 3995 "config/rx-parse.c" 3995 break; 3996 3997 case 290: /* op_subadd: disp '[' REG ']' DOT_UB ',' REG */ 3998 #line 1014 "./config/rx-parse.y" 3999 { B2 (0x40 + (sub_op<<2), 0); F ((yyvsp[-4].regno), 8, 4); F ((yyvsp[0].regno), 12, 4); DSP ((yyvsp[-6].exp), 6, BSIZE); } 4000 #line 4001 "config/rx-parse.c" 4001 break; 4002 4003 case 291: /* op_subadd: disp '[' REG ']' memex ',' REG */ 4004 #line 1016 "./config/rx-parse.y" 4005 { B3 (MEMEX, sub_op<<2, 0); F ((yyvsp[-2].regno), 8, 2); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); } 4006 #line 4007 "config/rx-parse.c" 4007 break; 4008 4009 case 292: /* op_subadd: REG ',' REG ',' REG */ 4010 #line 1018 "./config/rx-parse.y" 4011 { id24 (4, sub_op<<4, 0), F ((yyvsp[0].regno), 12, 4), F ((yyvsp[-4].regno), 16, 4), F ((yyvsp[-2].regno), 20, 4); } 4012 #line 4013 "config/rx-parse.c" 4013 break; 4014 4015 case 293: /* op_dp20_rm_l: REG ',' REG */ 4016 #line 1025 "./config/rx-parse.y" 4017 { id24 (1, 0x03 + (sub_op<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4018 #line 4019 "config/rx-parse.c" 4019 break; 4020 4021 case 294: /* op_dp20_rm_l: disp '[' REG ']' opt_l ',' REG */ 4022 #line 1027 "./config/rx-parse.y" 4023 { B4 (MEMEX, 0xa0, 0x00 + sub_op, 0x00); 4024 F ((yyvsp[-4].regno), 24, 4); F ((yyvsp[0].regno), 28, 4); DSP ((yyvsp[-6].exp), 14, LSIZE); } 4025 #line 4026 "config/rx-parse.c" 4026 break; 4027 4028 case 295: /* op_dp20_rm: REG ',' REG */ 4029 #line 1035 "./config/rx-parse.y" 4030 { id24 (1, 0x03 + (sub_op<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4031 #line 4032 "config/rx-parse.c" 4032 break; 4033 4034 case 296: /* op_dp20_rm: disp '[' REG ']' DOT_UB ',' REG */ 4035 #line 1037 "./config/rx-parse.y" 4036 { id24 (1, 0x00 + (sub_op<<2), 0x00); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, BSIZE); } 4037 #line 4038 "config/rx-parse.c" 4038 break; 4039 4040 case 297: /* op_dp20_rm: disp '[' REG ']' memex ',' REG */ 4041 #line 1039 "./config/rx-parse.y" 4042 { B4 (MEMEX, 0x20 + ((yyvsp[-2].regno) << 6), 0x00 + sub_op, 0x00); 4043 F ((yyvsp[-4].regno), 24, 4); F ((yyvsp[0].regno), 28, 4); DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); } 4044 #line 4045 "config/rx-parse.c" 4045 break; 4046 4047 case 298: /* op_dp20_i: '#' EXPR ',' REG */ 4048 #line 1045 "./config/rx-parse.y" 4049 { id24 (2, 0x70, sub_op<<4); F ((yyvsp[0].regno), 20, 4); IMM ((yyvsp[-2].exp), 12); } 4050 #line 4051 "config/rx-parse.c" 4051 break; 4052 4053 case 303: /* op_dp20_rr: REG ',' REG */ 4054 #line 1060 "./config/rx-parse.y" 4055 { id24 (1, 0x03 + (sub_op<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4056 #line 4057 "config/rx-parse.c" 4057 break; 4058 4059 case 304: /* op_dp20_rr: REG */ 4060 #line 1062 "./config/rx-parse.y" 4061 { B2 (0x7e, sub_op2 << 4); F ((yyvsp[0].regno), 12, 4); } 4062 #line 4063 "config/rx-parse.c" 4063 break; 4064 4065 case 305: /* op_dp20_r: REG ',' REG */ 4066 #line 1067 "./config/rx-parse.y" 4067 { id24 (1, 0x4b + (sub_op2<<2), 0x00); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4068 #line 4069 "config/rx-parse.c" 4069 break; 4070 4071 case 306: /* $@61: %empty */ 4072 #line 1071 "./config/rx-parse.y" 4073 { rx_check_v2 (); } 4074 #line 4075 "config/rx-parse.c" 4075 break; 4076 4077 case 309: /* op_xchg: REG ',' REG */ 4078 #line 1079 "./config/rx-parse.y" 4079 { id24 (1, 0x03 + (sub_op<<2), 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4080 #line 4081 "config/rx-parse.c" 4081 break; 4082 4083 case 310: /* op_xchg: disp '[' REG ']' DOT_UB ',' REG */ 4084 #line 1081 "./config/rx-parse.y" 4085 { id24 (1, 0x00 + (sub_op<<2), 0); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, BSIZE); } 4086 #line 4087 "config/rx-parse.c" 4087 break; 4088 4089 case 311: /* op_xchg: disp '[' REG ']' memex ',' REG */ 4090 #line 1083 "./config/rx-parse.y" 4091 { B4 (MEMEX, 0x20, 0x00 + sub_op, 0); F ((yyvsp[-2].regno), 8, 2); F ((yyvsp[-4].regno), 24, 4); F ((yyvsp[0].regno), 28, 4); 4092 DSP ((yyvsp[-6].exp), 14, sizemap[(yyvsp[-2].regno)]); } 4093 #line 4094 "config/rx-parse.c" 4094 break; 4095 4096 case 312: /* op_shift_rot: REG ',' REG */ 4097 #line 1090 "./config/rx-parse.y" 4098 { id24 (2, 0x60 + sub_op, 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4099 #line 4100 "config/rx-parse.c" 4100 break; 4101 4102 case 313: /* op_shift: '#' EXPR ',' REG */ 4103 #line 1094 "./config/rx-parse.y" 4104 { B2 (0x68 + (sub_op<<1), 0); FE ((yyvsp[-2].exp), 7, 5); F ((yyvsp[0].regno), 12, 4); } 4105 #line 4106 "config/rx-parse.c" 4106 break; 4107 4108 case 314: /* op_shift: '#' EXPR ',' REG ',' REG */ 4109 #line 1096 "./config/rx-parse.y" 4110 { id24 (2, 0x80 + (sub_op << 5), 0); FE ((yyvsp[-4].exp), 11, 5); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4111 #line 4112 "config/rx-parse.c" 4112 break; 4113 4114 case 316: /* float3_op: '#' EXPR ',' REG */ 4115 #line 1102 "./config/rx-parse.y" 4116 { rx_check_float_support (); id24 (2, 0x72, sub_op << 4); F ((yyvsp[0].regno), 20, 4); O4 ((yyvsp[-2].exp)); } 4117 #line 4118 "config/rx-parse.c" 4118 break; 4119 4120 case 317: /* float3_op: REG ',' REG */ 4121 #line 1104 "./config/rx-parse.y" 4122 { rx_check_float_support (); id24 (1, 0x83 + (sub_op << 2), 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4123 #line 4124 "config/rx-parse.c" 4124 break; 4125 4126 case 318: /* float3_op: disp '[' REG ']' opt_l ',' REG */ 4127 #line 1106 "./config/rx-parse.y" 4128 { rx_check_float_support (); id24 (1, 0x80 + (sub_op << 2), 0); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, LSIZE); } 4129 #line 4130 "config/rx-parse.c" 4130 break; 4131 4132 case 319: /* float3_op: REG ',' REG ',' REG */ 4133 #line 1108 "./config/rx-parse.y" 4134 { rx_check_v2 (); id24 (4, 0x80 + (sub_op << 4), 0 ); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[-2].regno), 20, 4); F ((yyvsp[0].regno), 12, 4); } 4135 #line 4136 "config/rx-parse.c" 4136 break; 4137 4138 case 320: /* $@62: %empty */ 4139 #line 1112 "./config/rx-parse.y" 4140 { rx_check_float_support (); } 4141 #line 4142 "config/rx-parse.c" 4142 break; 4143 4144 case 321: /* float2_op: $@62 '#' EXPR ',' REG */ 4145 #line 1114 "./config/rx-parse.y" 4146 { id24 (2, 0x72, sub_op << 4); F ((yyvsp[0].regno), 20, 4); O4 ((yyvsp[-2].exp)); } 4147 #line 4148 "config/rx-parse.c" 4148 break; 4149 4150 case 323: /* $@63: %empty */ 4151 #line 1119 "./config/rx-parse.y" 4152 { rx_check_float_support (); } 4153 #line 4154 "config/rx-parse.c" 4154 break; 4155 4156 case 324: /* float2_op_ni: $@63 REG ',' REG */ 4157 #line 1121 "./config/rx-parse.y" 4158 { id24 (1, 0x83 + (sub_op << 2), 0); F ((yyvsp[-2].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); } 4159 #line 4160 "config/rx-parse.c" 4160 break; 4161 4162 case 325: /* $@64: %empty */ 4163 #line 1122 "./config/rx-parse.y" 4164 { rx_check_float_support (); } 4165 #line 4166 "config/rx-parse.c" 4166 break; 4167 4168 case 326: /* float2_op_ni: $@64 disp '[' REG ']' opt_l ',' REG */ 4169 #line 1124 "./config/rx-parse.y" 4170 { id24 (1, 0x80 + (sub_op << 2), 0); F ((yyvsp[-4].regno), 16, 4); F ((yyvsp[0].regno), 20, 4); DSP ((yyvsp[-6].exp), 14, LSIZE); } 4171 #line 4172 "config/rx-parse.c" 4172 break; 4173 4174 case 327: /* $@65: %empty */ 4175 #line 1128 "./config/rx-parse.y" 4176 { rx_check_v2 (); } 4177 #line 4178 "config/rx-parse.c" 4178 break; 4179 4180 case 328: /* mvfa_op: $@65 '#' EXPR ',' ACC ',' REG */ 4181 #line 1130 "./config/rx-parse.y" 4182 { id24 (2, 0x1e, sub_op << 4); F ((yyvsp[0].regno), 20, 4); F ((yyvsp[-2].regno), 16, 1); 4183 if (rx_uintop ((yyvsp[-4].exp), 4)) 4184 { 4185 switch (exp_val ((yyvsp[-4].exp))) 4186 { 4187 case 0: 4188 F (1, 15, 1); 4189 break; 4190 case 1: 4191 F (1, 15, 1); 4192 F (1, 17, 1); 4193 break; 4194 case 2: 4195 break; 4196 default: 4197 as_bad (_("IMM expects #0 to #2"));} 4198 } else 4199 as_bad (_("IMM expects #0 to #2"));} 4200 #line 4201 "config/rx-parse.c" 4201 break; 4202 4203 case 330: /* op_xor: REG ',' REG ',' REG */ 4204 #line 1153 "./config/rx-parse.y" 4205 { rx_check_v3(); B3(0xff,0x60,0x00), F ((yyvsp[0].regno), 12, 4), F ((yyvsp[-4].regno), 16, 4), F ((yyvsp[-2].regno), 20, 4); } 4206 #line 4207 "config/rx-parse.c" 4207 break; 4208 4209 case 331: /* $@66: %empty */ 4210 #line 1157 "./config/rx-parse.y" 4211 { rx_check_v3(); } 4212 #line 4213 "config/rx-parse.c" 4213 break; 4214 4215 case 332: /* op_bfield: $@66 '#' EXPR ',' '#' EXPR ',' '#' EXPR ',' REG ',' REG */ 4216 #line 1159 "./config/rx-parse.y" 4217 { rx_range((yyvsp[-10].exp), 0, 31); rx_range((yyvsp[-7].exp), 0, 31); rx_range((yyvsp[-4].exp), 1, 31); 4218 B3(0xfc, 0x5a + (sub_op << 2), 0); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno), 20, 4); 4219 rx_bfield((yyvsp[-10].exp), (yyvsp[-7].exp), (yyvsp[-4].exp));} 4220 #line 4221 "config/rx-parse.c" 4221 break; 4222 4223 case 333: /* op_save_rstr: '#' EXPR */ 4224 #line 1166 "./config/rx-parse.y" 4225 { B3(0xfd,0x76,0xe0 + (sub_op << 4)); UO1((yyvsp[0].exp)); } 4226 #line 4227 "config/rx-parse.c" 4227 break; 4228 4229 case 334: /* op_save_rstr: REG */ 4230 #line 1168 "./config/rx-parse.y" 4231 { B4(0xfd,0x76,0xc0 + (sub_op << 4), 0x00); F((yyvsp[0].regno), 20, 4); } 4232 #line 4233 "config/rx-parse.c" 4233 break; 4234 4235 case 335: /* double2_op: DREG ',' DREG */ 4236 #line 1173 "./config/rx-parse.y" 4237 { B4(0x76, 0x90, sub_op, sub_op2); F((yyvsp[-2].regno), 16, 4); F((yyvsp[0].regno), 24, 4);} 4238 #line 4239 "config/rx-parse.c" 4239 break; 4240 4241 case 336: /* double3_op: DREG ',' DREG ',' DREG */ 4242 #line 1177 "./config/rx-parse.y" 4243 { B4(0x76, 0x90, sub_op, 0x00); F((yyvsp[-4].regno), 28, 4); F((yyvsp[-2].regno), 16,4); F((yyvsp[0].regno), 24, 4);} 4244 #line 4245 "config/rx-parse.c" 4245 break; 4246 4247 case 337: /* disp: %empty */ 4248 #line 1181 "./config/rx-parse.y" 4249 { (yyval.exp) = zero_expr (); } 4250 #line 4251 "config/rx-parse.c" 4251 break; 4252 4253 case 338: /* disp: EXPR */ 4254 #line 1182 "./config/rx-parse.y" 4255 { (yyval.exp) = (yyvsp[0].exp); } 4256 #line 4257 "config/rx-parse.c" 4257 break; 4258 4259 case 339: /* $@67: %empty */ 4260 #line 1185 "./config/rx-parse.y" 4261 { need_flag = 1; } 4262 #line 4263 "config/rx-parse.c" 4263 break; 4264 4265 case 340: /* flag: $@67 FLAG */ 4266 #line 1185 "./config/rx-parse.y" 4267 { need_flag = 0; (yyval.regno) = (yyvsp[0].regno); } 4268 #line 4269 "config/rx-parse.c" 4269 break; 4270 4271 case 341: /* memex: DOT_B */ 4272 #line 1190 "./config/rx-parse.y" 4273 { (yyval.regno) = 0; } 4274 #line 4275 "config/rx-parse.c" 4275 break; 4276 4277 case 342: /* memex: DOT_W */ 4278 #line 1191 "./config/rx-parse.y" 4279 { (yyval.regno) = 1; } 4280 #line 4281 "config/rx-parse.c" 4281 break; 4282 4283 case 343: /* memex: %empty */ 4284 #line 1192 "./config/rx-parse.y" 4285 { (yyval.regno) = 2; } 4286 #line 4287 "config/rx-parse.c" 4287 break; 4288 4289 case 344: /* memex: DOT_L */ 4290 #line 1193 "./config/rx-parse.y" 4291 { (yyval.regno) = 2; } 4292 #line 4293 "config/rx-parse.c" 4293 break; 4294 4295 case 345: /* memex: DOT_UW */ 4296 #line 1194 "./config/rx-parse.y" 4297 { (yyval.regno) = 3; } 4298 #line 4299 "config/rx-parse.c" 4299 break; 4300 4301 case 346: /* bwl: %empty */ 4302 #line 1197 "./config/rx-parse.y" 4303 { (yyval.regno) = LSIZE; } 4304 #line 4305 "config/rx-parse.c" 4305 break; 4306 4307 case 347: /* bwl: DOT_B */ 4308 #line 1198 "./config/rx-parse.y" 4309 { (yyval.regno) = BSIZE; } 4310 #line 4311 "config/rx-parse.c" 4311 break; 4312 4313 case 348: /* bwl: DOT_W */ 4314 #line 1199 "./config/rx-parse.y" 4315 { (yyval.regno) = WSIZE; } 4316 #line 4317 "config/rx-parse.c" 4317 break; 4318 4319 case 349: /* bwl: DOT_L */ 4320 #line 1200 "./config/rx-parse.y" 4321 { (yyval.regno) = LSIZE; } 4322 #line 4323 "config/rx-parse.c" 4323 break; 4324 4325 case 350: /* bw: %empty */ 4326 #line 1203 "./config/rx-parse.y" 4327 { (yyval.regno) = 1; } 4328 #line 4329 "config/rx-parse.c" 4329 break; 4330 4331 case 351: /* bw: DOT_B */ 4332 #line 1204 "./config/rx-parse.y" 4333 { (yyval.regno) = 0; } 4334 #line 4335 "config/rx-parse.c" 4335 break; 4336 4337 case 352: /* bw: DOT_W */ 4338 #line 1205 "./config/rx-parse.y" 4339 { (yyval.regno) = 1; } 4340 #line 4341 "config/rx-parse.c" 4341 break; 4342 4343 case 353: /* opt_l: %empty */ 4344 #line 1208 "./config/rx-parse.y" 4345 {} 4346 #line 4347 "config/rx-parse.c" 4347 break; 4348 4349 case 354: /* opt_l: DOT_L */ 4350 #line 1209 "./config/rx-parse.y" 4351 {} 4352 #line 4353 "config/rx-parse.c" 4353 break; 4354 4355 case 355: /* opt_b: %empty */ 4356 #line 1212 "./config/rx-parse.y" 4357 {} 4358 #line 4359 "config/rx-parse.c" 4359 break; 4360 4361 case 356: /* opt_b: DOT_B */ 4362 #line 1213 "./config/rx-parse.y" 4363 {} 4364 #line 4365 "config/rx-parse.c" 4365 break; 4366 4367 4368 #line 4369 "config/rx-parse.c" 4369 4370 default: break; 4371 } 4372 /* User semantic actions sometimes alter yychar, and that requires 4373 that yytoken be updated with the new translation. We take the 4374 approach of translating immediately before every use of yytoken. 4375 One alternative is translating here after every semantic action, 4376 but that translation would be missed if the semantic action invokes 4377 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or 4378 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an 4379 incorrect destructor might then be invoked immediately. In the 4380 case of YYERROR or YYBACKUP, subsequent parser actions might lead 4381 to an incorrect destructor call or verbose syntax error message 4382 before the lookahead is translated. */ 4383 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); 4384 4385 YYPOPSTACK (yylen); 4386 yylen = 0; 4387 4388 *++yyvsp = yyval; 4389 4390 /* Now 'shift' the result of the reduction. Determine what state 4391 that goes to, based on the state we popped back to and the rule 4392 number reduced by. */ 4393 { 4394 const int yylhs = yyr1[yyn] - YYNTOKENS; 4395 const int yyi = yypgoto[yylhs] + *yyssp; 4396 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp 4397 ? yytable[yyi] 4398 : yydefgoto[yylhs]); 4399 } 4400 4401 goto yynewstate; 4402 4403 4404 /*--------------------------------------. 4405 | yyerrlab -- here on detecting error. | 4406 `--------------------------------------*/ 4407 yyerrlab: 4408 /* Make sure we have latest lookahead translation. See comments at 4409 user semantic actions for why this is necessary. */ 4410 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); 4411 /* If not already recovering from an error, report this error. */ 4412 if (!yyerrstatus) 4413 { 4414 ++yynerrs; 4415 yyerror (YY_("syntax error")); 4416 } 4417 4418 if (yyerrstatus == 3) 4419 { 4420 /* If just tried and failed to reuse lookahead token after an 4421 error, discard it. */ 4422 4423 if (yychar <= YYEOF) 4424 { 4425 /* Return failure if at end of input. */ 4426 if (yychar == YYEOF) 4427 YYABORT; 4428 } 4429 else 4430 { 4431 yydestruct ("Error: discarding", 4432 yytoken, &yylval); 4433 yychar = YYEMPTY; 4434 } 4435 } 4436 4437 /* Else will try to reuse lookahead token after shifting the error 4438 token. */ 4439 goto yyerrlab1; 4440 4441 4442 /*---------------------------------------------------. 4443 | yyerrorlab -- error raised explicitly by YYERROR. | 4444 `---------------------------------------------------*/ 4445 yyerrorlab: 4446 /* Pacify compilers when the user code never invokes YYERROR and the 4447 label yyerrorlab therefore never appears in user code. */ 4448 if (0) 4449 YYERROR; 4450 ++yynerrs; 4451 4452 /* Do not reclaim the symbols of the rule whose action triggered 4453 this YYERROR. */ 4454 YYPOPSTACK (yylen); 4455 yylen = 0; 4456 YY_STACK_PRINT (yyss, yyssp); 4457 yystate = *yyssp; 4458 goto yyerrlab1; 4459 4460 4461 /*-------------------------------------------------------------. 4462 | yyerrlab1 -- common code for both syntax error and YYERROR. | 4463 `-------------------------------------------------------------*/ 4464 yyerrlab1: 4465 yyerrstatus = 3; /* Each real token shifted decrements this. */ 4466 4467 /* Pop stack until we find a state that shifts the error token. */ 4468 for (;;) 4469 { 4470 yyn = yypact[yystate]; 4471 if (!yypact_value_is_default (yyn)) 4472 { 4473 yyn += YYSYMBOL_YYerror; 4474 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) 4475 { 4476 yyn = yytable[yyn]; 4477 if (0 < yyn) 4478 break; 4479 } 4480 } 4481 4482 /* Pop the current state because it cannot handle the error token. */ 4483 if (yyssp == yyss) 4484 YYABORT; 4485 4486 4487 yydestruct ("Error: popping", 4488 YY_ACCESSING_SYMBOL (yystate), yyvsp); 4489 YYPOPSTACK (1); 4490 yystate = *yyssp; 4491 YY_STACK_PRINT (yyss, yyssp); 4492 } 4493 4494 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN 4495 *++yyvsp = yylval; 4496 YY_IGNORE_MAYBE_UNINITIALIZED_END 4497 4498 4499 /* Shift the error token. */ 4500 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); 4501 4502 yystate = yyn; 4503 goto yynewstate; 4504 4505 4506 /*-------------------------------------. 4507 | yyacceptlab -- YYACCEPT comes here. | 4508 `-------------------------------------*/ 4509 yyacceptlab: 4510 yyresult = 0; 4511 goto yyreturnlab; 4512 4513 4514 /*-----------------------------------. 4515 | yyabortlab -- YYABORT comes here. | 4516 `-----------------------------------*/ 4517 yyabortlab: 4518 yyresult = 1; 4519 goto yyreturnlab; 4520 4521 4522 /*-----------------------------------------------------------. 4523 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | 4524 `-----------------------------------------------------------*/ 4525 yyexhaustedlab: 4526 yyerror (YY_("memory exhausted")); 4527 yyresult = 2; 4528 goto yyreturnlab; 4529 4530 4531 /*----------------------------------------------------------. 4532 | yyreturnlab -- parsing is finished, clean up and return. | 4533 `----------------------------------------------------------*/ 4534 yyreturnlab: 4535 if (yychar != YYEMPTY) 4536 { 4537 /* Make sure we have latest lookahead translation. See comments at 4538 user semantic actions for why this is necessary. */ 4539 yytoken = YYTRANSLATE (yychar); 4540 yydestruct ("Cleanup: discarding lookahead", 4541 yytoken, &yylval); 4542 } 4543 /* Do not reclaim the symbols of the rule whose action triggered 4544 this YYABORT or YYACCEPT. */ 4545 YYPOPSTACK (yylen); 4546 YY_STACK_PRINT (yyss, yyssp); 4547 while (yyssp != yyss) 4548 { 4549 yydestruct ("Cleanup: popping", 4550 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp); 4551 YYPOPSTACK (1); 4552 } 4553 #ifndef yyoverflow 4554 if (yyss != yyssa) 4555 YYSTACK_FREE (yyss); 4556 #endif 4557 4558 return yyresult; 4559 } 4560 4561 #line 1216 "./config/rx-parse.y" 4562 4563 /* ====================================================================== */ 4564 4565 static struct 4566 { 4567 const char * string; 4568 int token; 4569 int val; 4570 } 4571 token_table[] = 4572 { 4573 { "r0", REG, 0 }, 4574 { "r1", REG, 1 }, 4575 { "r2", REG, 2 }, 4576 { "r3", REG, 3 }, 4577 { "r4", REG, 4 }, 4578 { "r5", REG, 5 }, 4579 { "r6", REG, 6 }, 4580 { "r7", REG, 7 }, 4581 { "r8", REG, 8 }, 4582 { "r9", REG, 9 }, 4583 { "r10", REG, 10 }, 4584 { "r11", REG, 11 }, 4585 { "r12", REG, 12 }, 4586 { "r13", REG, 13 }, 4587 { "r14", REG, 14 }, 4588 { "r15", REG, 15 }, 4589 4590 { "psw", CREG, 0 }, 4591 { "pc", CREG, 1 }, 4592 { "usp", CREG, 2 }, 4593 { "fpsw", CREG, 3 }, 4594 /* reserved */ 4595 /* reserved */ 4596 /* reserved */ 4597 { "wr", CREG, 7 }, 4598 4599 { "bpsw", CREG, 8 }, 4600 { "bpc", CREG, 9 }, 4601 { "isp", CREG, 10 }, 4602 { "fintv", CREG, 11 }, 4603 { "intb", CREG, 12 }, 4604 { "extb", CREG, 13 }, 4605 4606 { "pbp", CREG, 16 }, 4607 { "pben", CREG, 17 }, 4608 4609 { "bbpsw", CREG, 24 }, 4610 { "bbpc", CREG, 25 }, 4611 4612 { "dr0", DREG, 0 }, 4613 { "dr1", DREG, 1 }, 4614 { "dr2", DREG, 2 }, 4615 { "dr3", DREG, 3 }, 4616 { "dr4", DREG, 4 }, 4617 { "dr5", DREG, 5 }, 4618 { "dr6", DREG, 6 }, 4619 { "dr7", DREG, 7 }, 4620 { "dr8", DREG, 8 }, 4621 { "dr9", DREG, 9 }, 4622 { "dr10", DREG, 10 }, 4623 { "dr11", DREG, 11 }, 4624 { "dr12", DREG, 12 }, 4625 { "dr13", DREG, 13 }, 4626 { "dr14", DREG, 14 }, 4627 { "dr15", DREG, 15 }, 4628 4629 { "drh0", DREGH, 0 }, 4630 { "drh1", DREGH, 1 }, 4631 { "drh2", DREGH, 2 }, 4632 { "drh3", DREGH, 3 }, 4633 { "drh4", DREGH, 4 }, 4634 { "drh5", DREGH, 5 }, 4635 { "drh6", DREGH, 6 }, 4636 { "drh7", DREGH, 7 }, 4637 { "drh8", DREGH, 8 }, 4638 { "drh9", DREGH, 9 }, 4639 { "drh10", DREGH, 10 }, 4640 { "drh11", DREGH, 11 }, 4641 { "drh12", DREGH, 12 }, 4642 { "drh13", DREGH, 13 }, 4643 { "drh14", DREGH, 14 }, 4644 { "drh15", DREGH, 15 }, 4645 4646 { "drl0", DREGL, 0 }, 4647 { "drl1", DREGL, 1 }, 4648 { "drl2", DREGL, 2 }, 4649 { "drl3", DREGL, 3 }, 4650 { "drl4", DREGL, 4 }, 4651 { "drl5", DREGL, 5 }, 4652 { "drl6", DREGL, 6 }, 4653 { "drl7", DREGL, 7 }, 4654 { "drl8", DREGL, 8 }, 4655 { "drl9", DREGL, 9 }, 4656 { "drl10", DREGL, 10 }, 4657 { "drl11", DREGL, 11 }, 4658 { "drl12", DREGL, 12 }, 4659 { "drl13", DREGL, 13 }, 4660 { "drl14", DREGL, 14 }, 4661 { "drl15", DREGL, 15 }, 4662 4663 { "DPSW", DCREG, 0 }, 4664 { "DCMR", DCREG, 1 }, 4665 { "DECNT", DCREG, 2 }, 4666 { "DEPC", DCREG, 3 }, 4667 { "DCR0", DCREG, 0 }, 4668 { "DCR1", DCREG, 1 }, 4669 { "DCR2", DCREG, 2 }, 4670 { "DCR3", DCREG, 3 }, 4671 4672 { ".s", DOT_S, 0 }, 4673 { ".b", DOT_B, 0 }, 4674 { ".w", DOT_W, 0 }, 4675 { ".l", DOT_L, 0 }, 4676 { ".a", DOT_A , 0}, 4677 { ".ub", DOT_UB, 0 }, 4678 { ".uw", DOT_UW , 0}, 4679 { ".d", DOT_D , 0}, 4680 4681 { "c", FLAG, 0 }, 4682 { "z", FLAG, 1 }, 4683 { "s", FLAG, 2 }, 4684 { "o", FLAG, 3 }, 4685 { "i", FLAG, 8 }, 4686 { "u", FLAG, 9 }, 4687 4688 { "a0", ACC, 0 }, 4689 { "a1", ACC, 1 }, 4690 4691 #define OPC(x) { #x, x, IS_OPCODE } 4692 OPC(ABS), 4693 OPC(ADC), 4694 OPC(ADD), 4695 { "and", AND_, IS_OPCODE }, 4696 OPC(BCLR), 4697 OPC(BCND), 4698 OPC(BFMOV), 4699 OPC(BFMOVZ), 4700 OPC(BMCND), 4701 OPC(BNOT), 4702 OPC(BRA), 4703 OPC(BRK), 4704 OPC(BSET), 4705 OPC(BSR), 4706 OPC(BTST), 4707 OPC(CLRPSW), 4708 OPC(CMP), 4709 OPC(DABS), 4710 OPC(DADD), 4711 OPC(DBT), 4712 OPC(DDIV), 4713 OPC(DIV), 4714 OPC(DIVU), 4715 OPC(DMOV), 4716 OPC(DMUL), 4717 OPC(DNEG), 4718 OPC(DPOPM), 4719 OPC(DPUSHM), 4720 OPC(DROUND), 4721 OPC(DSQRT), 4722 OPC(DSUB), 4723 OPC(DTOF), 4724 OPC(DTOI), 4725 OPC(DTOU), 4726 OPC(EDIV), 4727 OPC(EDIVU), 4728 OPC(EMACA), 4729 OPC(EMSBA), 4730 OPC(EMUL), 4731 OPC(EMULA), 4732 OPC(EMULU), 4733 OPC(FADD), 4734 OPC(FCMP), 4735 OPC(FDIV), 4736 OPC(FMUL), 4737 OPC(FREIT), 4738 OPC(FSQRT), 4739 OPC(FTOD), 4740 OPC(FTOU), 4741 OPC(FSUB), 4742 OPC(FTOI), 4743 OPC(INT), 4744 OPC(ITOD), 4745 OPC(ITOF), 4746 OPC(JMP), 4747 OPC(JSR), 4748 OPC(MVFACGU), 4749 OPC(MVFACHI), 4750 OPC(MVFACMI), 4751 OPC(MVFACLO), 4752 OPC(MVFC), 4753 OPC(MVFDC), 4754 OPC(MVFDR), 4755 OPC(MVTDC), 4756 OPC(MVTACGU), 4757 OPC(MVTACHI), 4758 OPC(MVTACLO), 4759 OPC(MVTC), 4760 OPC(MVTIPL), 4761 OPC(MACHI), 4762 OPC(MACLO), 4763 OPC(MACLH), 4764 OPC(MAX), 4765 OPC(MIN), 4766 OPC(MOV), 4767 OPC(MOVCO), 4768 OPC(MOVLI), 4769 OPC(MOVU), 4770 OPC(MSBHI), 4771 OPC(MSBLH), 4772 OPC(MSBLO), 4773 OPC(MUL), 4774 OPC(MULHI), 4775 OPC(MULLH), 4776 OPC(MULLO), 4777 OPC(MULU), 4778 OPC(NEG), 4779 OPC(NOP), 4780 OPC(NOT), 4781 OPC(OR), 4782 OPC(POP), 4783 OPC(POPC), 4784 OPC(POPM), 4785 OPC(PUSH), 4786 OPC(PUSHA), 4787 OPC(PUSHC), 4788 OPC(PUSHM), 4789 OPC(RACL), 4790 OPC(RACW), 4791 OPC(RDACL), 4792 OPC(RDACW), 4793 OPC(REIT), 4794 OPC(REVL), 4795 OPC(REVW), 4796 OPC(RMPA), 4797 OPC(ROLC), 4798 OPC(RORC), 4799 OPC(ROTL), 4800 OPC(ROTR), 4801 OPC(ROUND), 4802 OPC(RSTR), 4803 OPC(RTE), 4804 OPC(RTFI), 4805 OPC(RTS), 4806 OPC(RTSD), 4807 OPC(SAT), 4808 OPC(SATR), 4809 OPC(SAVE), 4810 OPC(SBB), 4811 OPC(SCCND), 4812 OPC(SCMPU), 4813 OPC(SETPSW), 4814 OPC(SHAR), 4815 OPC(SHLL), 4816 OPC(SHLR), 4817 OPC(SMOVB), 4818 OPC(SMOVF), 4819 OPC(SMOVU), 4820 OPC(SSTR), 4821 OPC(STNZ), 4822 OPC(STOP), 4823 OPC(STZ), 4824 OPC(SUB), 4825 OPC(SUNTIL), 4826 OPC(SWHILE), 4827 OPC(TST), 4828 OPC(UTOD), 4829 OPC(UTOF), 4830 OPC(WAIT), 4831 OPC(XCHG), 4832 OPC(XOR), 4833 }; 4834 4835 #define NUM_TOKENS (sizeof (token_table) / sizeof (token_table[0])) 4836 4837 static struct 4838 { 4839 const char * string; 4840 int token; 4841 } 4842 condition_opcode_table[] = 4843 { 4844 { "b", BCND }, 4845 { "bm", BMCND }, 4846 { "sc", SCCND }, 4847 }; 4848 4849 #define NUM_CONDITION_OPCODES (sizeof (condition_opcode_table) / sizeof (condition_opcode_table[0])) 4850 4851 struct condition_symbol 4852 { 4853 const char * string; 4854 int val; 4855 }; 4856 4857 static struct condition_symbol condition_table[] = 4858 { 4859 { "z", 0 }, 4860 { "eq", 0 }, 4861 { "geu", 2 }, 4862 { "c", 2 }, 4863 { "gtu", 4 }, 4864 { "pz", 6 }, 4865 { "ge", 8 }, 4866 { "gt", 10 }, 4867 { "o", 12}, 4868 /* always = 14 */ 4869 { "nz", 1 }, 4870 { "ne", 1 }, 4871 { "ltu", 3 }, 4872 { "nc", 3 }, 4873 { "leu", 5 }, 4874 { "n", 7 }, 4875 { "lt", 9 }, 4876 { "le", 11 }, 4877 { "no", 13 }, 4878 /* never = 15 */ 4879 }; 4880 4881 static struct condition_symbol double_condition_table[] = 4882 { 4883 { "un", 1 }, 4884 { "eq", 2 }, 4885 { "lt", 4 }, 4886 { "le", 6 }, 4887 }; 4888 4889 #define NUM_CONDITIONS (sizeof (condition_table) / sizeof (condition_table[0])) 4890 #define NUM_DOUBLE_CONDITIONS (sizeof (double_condition_table) / sizeof (double_condition_table[0])) 4891 4892 void 4893 rx_lex_init (char * beginning, char * ending) 4894 { 4895 rx_init_start = beginning; 4896 rx_lex_start = beginning; 4897 rx_lex_end = ending; 4898 rx_in_brackets = 0; 4899 rx_last_token = 0; 4900 4901 setbuf (stdout, 0); 4902 } 4903 4904 static int 4905 check_condition (const char * base, struct condition_symbol *t, unsigned int num) 4906 { 4907 char * cp; 4908 unsigned int i; 4909 4910 if ((unsigned) (rx_lex_end - rx_lex_start) < strlen (base) + 1) 4911 return 0; 4912 if (memcmp (rx_lex_start, base, strlen (base))) 4913 return 0; 4914 cp = rx_lex_start + strlen (base); 4915 for (i = 0; i < num; i ++) 4916 { 4917 if (strcasecmp (cp, t[i].string) == 0) 4918 { 4919 rx_lval.regno = t[i].val; 4920 return 1; 4921 } 4922 } 4923 return 0; 4924 } 4925 4926 static int 4927 rx_lex (void) 4928 { 4929 unsigned int ci; 4930 char * save_input_pointer; 4931 4932 while (ISSPACE (*rx_lex_start) 4933 && rx_lex_start != rx_lex_end) 4934 rx_lex_start ++; 4935 4936 rx_last_exp_start = rx_lex_start; 4937 4938 if (rx_lex_start == rx_lex_end) 4939 return 0; 4940 4941 if (ISALPHA (*rx_lex_start) 4942 || (rx_pid_register != -1 && memcmp (rx_lex_start, "%pidreg", 7) == 0) 4943 || (rx_gp_register != -1 && memcmp (rx_lex_start, "%gpreg", 6) == 0) 4944 || (*rx_lex_start == '.' && ISALPHA (rx_lex_start[1]))) 4945 { 4946 unsigned int i; 4947 char * e; 4948 char save; 4949 4950 for (e = rx_lex_start + 1; 4951 e < rx_lex_end && ISALNUM (*e); 4952 e ++) 4953 ; 4954 save = *e; 4955 *e = 0; 4956 4957 if (strcmp (rx_lex_start, "%pidreg") == 0) 4958 { 4959 { 4960 rx_lval.regno = rx_pid_register; 4961 *e = save; 4962 rx_lex_start = e; 4963 rx_last_token = REG; 4964 return REG; 4965 } 4966 } 4967 4968 if (strcmp (rx_lex_start, "%gpreg") == 0) 4969 { 4970 { 4971 rx_lval.regno = rx_gp_register; 4972 *e = save; 4973 rx_lex_start = e; 4974 rx_last_token = REG; 4975 return REG; 4976 } 4977 } 4978 4979 if (rx_last_token == 0) 4980 { 4981 for (ci = 0; ci < NUM_CONDITION_OPCODES; ci ++) 4982 if (check_condition (condition_opcode_table[ci].string, 4983 condition_table, NUM_CONDITIONS)) 4984 { 4985 *e = save; 4986 rx_lex_start = e; 4987 rx_last_token = condition_opcode_table[ci].token; 4988 return condition_opcode_table[ci].token; 4989 } 4990 if (check_condition ("dcmp", double_condition_table, 4991 NUM_DOUBLE_CONDITIONS)) 4992 { 4993 *e = save; 4994 rx_lex_start = e; 4995 rx_last_token = DCMP; 4996 return DCMP; 4997 } 4998 } 4999 5000 for (i = 0; i < NUM_TOKENS; i++) 5001 if (strcasecmp (rx_lex_start, token_table[i].string) == 0 5002 && !(token_table[i].val == IS_OPCODE && rx_last_token != 0) 5003 && !(token_table[i].token == FLAG && !need_flag)) 5004 { 5005 rx_lval.regno = token_table[i].val; 5006 *e = save; 5007 rx_lex_start = e; 5008 rx_last_token = token_table[i].token; 5009 return token_table[i].token; 5010 } 5011 *e = save; 5012 } 5013 5014 if (rx_last_token == 0) 5015 { 5016 rx_last_token = UNKNOWN_OPCODE; 5017 return UNKNOWN_OPCODE; 5018 } 5019 5020 if (rx_last_token == UNKNOWN_OPCODE) 5021 return 0; 5022 5023 if (*rx_lex_start == '[') 5024 rx_in_brackets = 1; 5025 if (*rx_lex_start == ']') 5026 rx_in_brackets = 0; 5027 5028 if (rx_in_brackets 5029 || rx_last_token == REG || rx_last_token == DREG || rx_last_token == DCREG 5030 || strchr ("[],#", *rx_lex_start)) 5031 { 5032 rx_last_token = *rx_lex_start; 5033 return *rx_lex_start ++; 5034 } 5035 5036 save_input_pointer = input_line_pointer; 5037 input_line_pointer = rx_lex_start; 5038 rx_lval.exp.X_md = 0; 5039 expression (&rx_lval.exp); 5040 5041 /* We parse but ignore any :<size> modifier on expressions. */ 5042 if (*input_line_pointer == ':') 5043 { 5044 char *cp; 5045 5046 for (cp = input_line_pointer + 1; *cp && cp < rx_lex_end; cp++) 5047 if (!ISDIGIT (*cp)) 5048 break; 5049 if (cp > input_line_pointer+1) 5050 input_line_pointer = cp; 5051 } 5052 5053 rx_lex_start = input_line_pointer; 5054 input_line_pointer = save_input_pointer; 5055 rx_last_token = EXPR; 5056 return EXPR; 5057 } 5058 5059 int 5060 rx_error (const char * str) 5061 { 5062 int len; 5063 5064 len = rx_last_exp_start - rx_init_start; 5065 5066 as_bad ("%s", rx_init_start); 5067 as_bad ("%*s^ %s", len, "", str); 5068 return 0; 5069 } 5070 5071 static int 5072 rx_intop (expressionS exp, int nbits, int opbits) 5073 { 5074 valueT v; 5075 valueT mask, msb; 5076 5077 if (exp.X_op == O_big) 5078 { 5079 if (nbits == 32) 5080 return 1; 5081 if (exp.X_add_number == -1) 5082 return 0; 5083 } 5084 else if (exp.X_op != O_constant) 5085 return 0; 5086 v = exp.X_add_number; 5087 5088 msb = (valueT) 1 << (opbits - 1); 5089 mask = (msb << 1) - 1; 5090 5091 if ((v & msb) && ! (v & ~mask)) 5092 v -= mask + 1; 5093 5094 switch (nbits) 5095 { 5096 case 4: 5097 return v + 0x8 <= 0x7 + 0x8; 5098 case 5: 5099 return v + 0x10 <= 0xf + 0x10; 5100 case 8: 5101 return v + 0x80 <= 0x7f + 0x80; 5102 case 16: 5103 return v + 0x8000 <= 0x7fff + 0x8000; 5104 case 24: 5105 return v + 0x800000 <= 0x7fffff + 0x800000; 5106 case 32: 5107 return 1; 5108 default: 5109 printf ("rx_intop passed %d\n", nbits); 5110 abort (); 5111 } 5112 return 1; 5113 } 5114 5115 static int 5116 rx_uintop (expressionS exp, int nbits) 5117 { 5118 valueT v; 5119 5120 if (exp.X_op != O_constant) 5121 return 0; 5122 v = exp.X_add_number; 5123 5124 switch (nbits) 5125 { 5126 case 4: 5127 return v <= 0xf; 5128 case 8: 5129 return v <= 0xff; 5130 case 16: 5131 return v <= 0xffff; 5132 case 24: 5133 return v <= 0xffffff; 5134 default: 5135 printf ("rx_uintop passed %d\n", nbits); 5136 abort (); 5137 } 5138 return 1; 5139 } 5140 5141 static int 5142 rx_disp3op (expressionS exp) 5143 { 5144 valueT v; 5145 5146 if (exp.X_op != O_constant) 5147 return 0; 5148 v = exp.X_add_number; 5149 if (v < 3 || v > 10) 5150 return 0; 5151 return 1; 5152 } 5153 5154 static int 5155 rx_disp5op (expressionS * exp, int msize) 5156 { 5157 valueT v; 5158 5159 if (exp->X_op != O_constant) 5160 return 0; 5161 v = exp->X_add_number; 5162 5163 switch (msize) 5164 { 5165 case BSIZE: 5166 if (v <= 31) 5167 return 1; 5168 break; 5169 case WSIZE: 5170 if (v & 1) 5171 return 0; 5172 if (v <= 63) 5173 { 5174 exp->X_add_number >>= 1; 5175 return 1; 5176 } 5177 break; 5178 case LSIZE: 5179 if (v & 3) 5180 return 0; 5181 if (v <= 127) 5182 { 5183 exp->X_add_number >>= 2; 5184 return 1; 5185 } 5186 break; 5187 } 5188 return 0; 5189 } 5190 5191 /* Just like the above, but allows a zero displacement. */ 5192 5193 static int 5194 rx_disp5op0 (expressionS * exp, int msize) 5195 { 5196 if (exp->X_op != O_constant) 5197 return 0; 5198 if (exp->X_add_number == 0) 5199 return 1; 5200 return rx_disp5op (exp, msize); 5201 } 5202 5203 static int 5204 exp_val (expressionS exp) 5205 { 5206 if (exp.X_op != O_constant) 5207 { 5208 rx_error (_("constant expected")); 5209 return 0; 5210 } 5211 return exp.X_add_number; 5212 } 5213 5214 static expressionS 5215 zero_expr (void) 5216 { 5217 /* Static, so program load sets it to all zeros, which is what we want. */ 5218 static expressionS zero; 5219 zero.X_op = O_constant; 5220 return zero; 5221 } 5222 5223 static int 5224 immediate (expressionS exp, int type, int pos, int bits) 5225 { 5226 /* We will emit constants ourselves here, so negate them. */ 5227 if (type == RXREL_NEGATIVE && exp.X_op == O_constant) 5228 exp.X_add_number = - exp.X_add_number; 5229 if (type == RXREL_NEGATIVE_BORROW) 5230 { 5231 if (exp.X_op == O_constant) 5232 exp.X_add_number = - exp.X_add_number - 1; 5233 else 5234 rx_error (_("sbb cannot use symbolic immediates")); 5235 } 5236 5237 if (pos >= 0 && rx_intop (exp, 8, bits)) 5238 { 5239 rx_op (exp, 1, type); 5240 return 1; 5241 } 5242 else if (pos >= 0 && rx_intop (exp, 16, bits)) 5243 { 5244 rx_op (exp, 2, type); 5245 return 2; 5246 } 5247 else if (pos >= 0 && rx_uintop (exp, 16) && bits == 16) 5248 { 5249 rx_op (exp, 2, type); 5250 return 2; 5251 } 5252 else if (pos >= 0 && rx_intop (exp, 24, bits)) 5253 { 5254 rx_op (exp, 3, type); 5255 return 3; 5256 } 5257 else if (pos < 0 || rx_intop (exp, 32, bits)) 5258 { 5259 rx_op (exp, 4, type); 5260 return 0; 5261 } 5262 else if (type == RXREL_SIGNED && pos >= 0) 5263 { 5264 /* This is a symbolic immediate, we will relax it later. */ 5265 rx_relax (RX_RELAX_IMM, pos); 5266 rx_op (exp, linkrelax ? 4 : 1, type); 5267 return 1; 5268 } 5269 else 5270 { 5271 /* Let the linker deal with it. */ 5272 rx_op (exp, 4, type); 5273 return 0; 5274 } 5275 } 5276 5277 static int 5278 displacement (expressionS exp, int msize) 5279 { 5280 valueT val; 5281 int vshift = 0; 5282 5283 if (exp.X_op == O_symbol 5284 && exp.X_md) 5285 { 5286 switch (exp.X_md) 5287 { 5288 case BFD_RELOC_GPREL16: 5289 switch (msize) 5290 { 5291 case BSIZE: 5292 exp.X_md = BFD_RELOC_RX_GPRELB; 5293 break; 5294 case WSIZE: 5295 exp.X_md = BFD_RELOC_RX_GPRELW; 5296 break; 5297 case LSIZE: 5298 exp.X_md = BFD_RELOC_RX_GPRELL; 5299 break; 5300 } 5301 O2 (exp); 5302 return 2; 5303 } 5304 } 5305 5306 if (exp.X_op == O_subtract) 5307 { 5308 exp.X_md = BFD_RELOC_RX_DIFF; 5309 O2 (exp); 5310 return 2; 5311 } 5312 5313 if (exp.X_op != O_constant) 5314 { 5315 rx_error (_("displacements must be constants")); 5316 return -1; 5317 } 5318 val = exp.X_add_number; 5319 5320 if (val == 0) 5321 return 0; 5322 5323 switch (msize) 5324 { 5325 case BSIZE: 5326 break; 5327 case WSIZE: 5328 if (val & 1) 5329 rx_error (_("word displacement not word-aligned")); 5330 vshift = 1; 5331 break; 5332 case LSIZE: 5333 if (val & 3) 5334 rx_error (_("long displacement not long-aligned")); 5335 vshift = 2; 5336 break; 5337 case DSIZE: 5338 if (val & 7) 5339 rx_error (_("double displacement not double-aligned")); 5340 vshift = 3; 5341 break; 5342 default: 5343 as_bad (_("displacement with unknown size (internal bug?)\n")); 5344 break; 5345 } 5346 5347 val >>= vshift; 5348 exp.X_add_number = val; 5349 5350 if (val <= 255 ) 5351 { 5352 O1 (exp); 5353 return 1; 5354 } 5355 5356 if (val <= 65535) 5357 { 5358 O2 (exp); 5359 return 2; 5360 } 5361 if ((offsetT) val < 0) 5362 rx_error (_("negative displacements not allowed")); 5363 else 5364 rx_error (_("displacement too large")); 5365 return -1; 5366 } 5367 5368 static void 5369 rtsd_immediate (expressionS exp) 5370 { 5371 valueT val; 5372 5373 if (exp.X_op != O_constant) 5374 { 5375 rx_error (_("rtsd size must be constant")); 5376 return; 5377 } 5378 val = exp.X_add_number; 5379 if (val & 3) 5380 rx_error (_("rtsd size must be multiple of 4")); 5381 5382 if (val > 1020) 5383 rx_error (_("rtsd size must be 0..1020")); 5384 5385 val >>= 2; 5386 exp.X_add_number = val; 5387 O1 (exp); 5388 } 5389 5390 static void 5391 rx_range (expressionS exp, int minv, int maxv) 5392 { 5393 offsetT val; 5394 5395 if (exp.X_op != O_constant) 5396 return; 5397 5398 val = exp.X_add_number; 5399 if (val < minv || val > maxv) 5400 as_warn (_("Value %ld out of range %d..%d"), (long) val, minv, maxv); 5401 } 5402 5403 static void 5404 rx_check_float_support (void) 5405 { 5406 if (rx_cpu == RX100 || rx_cpu == RX200) 5407 rx_error (_("target CPU type does not support floating point instructions")); 5408 } 5409 5410 static void 5411 rx_check_v2 (void) 5412 { 5413 if (rx_cpu < RXV2) 5414 rx_error (_("target CPU type does not support v2 instructions")); 5415 } 5416 5417 static void 5418 rx_check_v3 (void) 5419 { 5420 if (rx_cpu < RXV3) 5421 rx_error (_("target CPU type does not support v3 instructions")); 5422 } 5423 5424 static void 5425 rx_check_dfpu (void) 5426 { 5427 if (rx_cpu != RXV3FPU) 5428 rx_error (_("target CPU type does not support double float instructions")); 5429 } 5430
Indexes created Thu Apr 02 00:23:07 UTC 2026