OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-binutils/] [binutils-2.19.1/] [gas/] [bfin-parse.c] - Blame information for rev 13

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.