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