1 /* bfin-lex.l ADI Blackfin lexer
2 Copyright (C) 2005-2016 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
6 GAS 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 3, or (at your option)
9 any later version.
10
11 GAS 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 GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19 02110-1301, USA. */
20 %{
21
22 #include "as.h"
23 #include "bfin-defs.h"
24 #include "bfin-parse.h"
25
26 static long parse_int (char **end);
27 static int parse_halfreg (Register *r, int cl, char *hr);
28 static int parse_reg (Register *r, int type, char *rt);
29 int yylex (void);
30
31 #define _REG yylval.reg
32
33
34 %}
35
36 /* Define Start States ... Actually we will use exclusion.
37 If no start state is specified it should match any state
38 and <INITIAL> would match some keyword rules only with
39 initial. */
40 %s KEYWORD
41 %s FLAGS
42
43 %%
44 [sS][fF][tT][rR][eE][sS][eE][tT] _REG.regno = REG_sftreset; return REG;
45 [oO][mM][oO][dD][eE] _REG.regno = REG_omode; return REG;
46 [iI][dD][lL][eE]_[rR][eE][qQ] _REG.regno = REG_idle_req; return REG;
47 [hH][wW][eE][rR][rR][cC][aA][uU][sS][eE] _REG.regno = REG_hwerrcause; return REG;
48 [eE][xX][cC][aA][uU][sS][eE] _REG.regno = REG_excause; return REG;
49 [eE][mM][uU][cC][aA][uU][sS][eE] _REG.regno = REG_emucause; return REG;
50 <FLAGS>[zZ] return Z;
51 <FLAGS>[xX] return X;
52 [wW]32 yylval.value = M_W32; return MMOD;
53 [wW] return W;
54 [vV][iI][tT]_[mM][aA][xX] return VIT_MAX;
55 [vV] return V; /* Special: V is a statflag and a modifier. */
56 [uU][sS][pP] _REG.regno = REG_USP; return REG;
57 [tT][lL] return TL;
58 [tT][hH] return TH;
59 [tT][fF][uU] yylval.value = M_TFU; return MMOD;
60 [tT][eE][sS][tT][sS][eE][tT] return TESTSET;
61 <FLAGS>[tT] yylval.value = M_T; return MMOD;
62 <FLAGS>[sS] return S;
63 [sS][yY][sS][cC][fF][gG] _REG.regno = REG_SYSCFG; return REG;
64 [sS][tT][iI] return STI;
65 [sS][sS][yY][nN][cC] return SSYNC;
66 [sS][pP]"."[lL] _REG.regno = REG_SP; _REG.flags = F_REG_LOW; return HALF_REG;
67 [sS][pP]"."[hH] _REG.regno = REG_SP; _REG.flags = F_REG_HIGH; return HALF_REG;
68 [sS][pP] _REG.regno = REG_SP; return REG;
69 [sS][iI][gG][nN][bB][iI][tT][sS] return SIGNBITS;
70 [sS][iI][gG][nN] return SIGN;
71 [sS][eE][qQ][sS][tT][aA][tT] _REG.regno = REG_SEQSTAT; return REG;
72 [sS][eE][aA][rR][cC][hH] return SEARCH;
73 [sS][hH][iI][fF][tT] return SHIFT;
74 [sS][cC][oO] return SCO;
75
76 [sS][aA][aA] return SAA;
77 [sS]2[rR][nN][dD] yylval.value = M_S2RND; return MMOD;
78 [rR][tT][xX] return RTX;
79 [rR][tT][sS] return RTS;
80 [rR][tT][nN] return RTN;
81 [rR][tT][iI] return RTI;
82 [rR][tT][eE] return RTE;
83 [rR][oO][tT] return ROT;
84 [rR][nN][dD]20 return RND20;
85 [rR][nN][dD]12 return RND12;
86 [rR][nN][dD][lL] return RNDL;
87 [rR][nN][dD][hH] return RNDH;
88 [rR][nN][dD] return RND;
89
90 [rR][0-7]"."[lLhHbB] return parse_halfreg(&yylval.reg, T_REG_R, yytext);
91
92 [rR][eE][tT][sS] _REG.regno = REG_RETS; return REG;
93 [rR][eE][tT][iI] _REG.regno = REG_RETI; return REG;
94 [rR][eE][tT][xX] _REG.regno = REG_RETX; return REG;
95 [rR][eE][tT][nN] _REG.regno = REG_RETN; return REG;
96 [rR][eE][tT][eE] _REG.regno = REG_RETE; return REG;
97 [eE][mM][uU][dD][aA][tT] _REG.regno = REG_EMUDAT; return REG;
98 [rR][aA][iI][sS][eE] return RAISE;
99
100 [rR][0-7] return parse_reg (&yylval.reg, T_REG_R, yytext);
101
102 [rR] return R;
103 [pP][rR][nN][tT] return PRNT;
104 [pP][cC] return PC;
105 [pP][aA][cC][kK] return PACK;
106
107 [pP][0-5]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_P, yytext);
108 [pP][0-5] return parse_reg (&yylval.reg, T_REG_P, yytext);
109
110 [oO][uU][tT][cC] return OUTC;
111 [oO][nN][eE][sS] return ONES;
112
113 [nN][oO][tT] return NOT;
114 [nN][oO][pP] return NOP;
115 [mM][nN][oO][pP] return MNOP;
116 [nN][sS] return NS;
117
118
119 [mM][iI][nN] return MIN;
120 [mM][aA][xX] return MAX;
121
122 [mM][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_M, yytext);
123 [mM][0-3] return parse_reg (&yylval.reg, T_REG_M, yytext);
124
125 <FLAGS>[mM] return M;
126 [lL][tT] return LT;
127 [lL][sS][hH][iI][fF][tT] return LSHIFT;
128 [lL][sS][eE][tT][uU][pP] return LSETUP;
129 [lL][oO][oO][pP] return LOOP;
130 [lL][oO][oO][pP]_[bB][eE][gG][iI][nN] return LOOP_BEGIN;
131 [lL][oO][oO][pP]_[eE][nN][dD] return LOOP_END;
132
133 [lL][eE] return LE;
134 [lL][cC]0 _REG.regno = REG_LC0; return REG;
135 [lL][tT]0 _REG.regno = REG_LT0; return REG;
136 [lL][bB]0 _REG.regno = REG_LB0; return REG;
137 [lL][cC]1 _REG.regno = REG_LC1; return REG;
138 [lL][tT]1 _REG.regno = REG_LT1; return REG;
139 [lL][bB]1 _REG.regno = REG_LB1; return REG;
140
141 [lL][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_L, yytext);
142 [lL][0-3] return parse_reg (&yylval.reg, T_REG_L, yytext);
143 [lL][oO] return LO;
144 [jJ][uU][mM][pP]"."[sS] { BEGIN 0; return JUMP_DOT_S;}
145 [jJ][uU][mM][pP]"."[lL] { BEGIN 0; return JUMP_DOT_L;}
146 [jJ][uU][mM][pP] { BEGIN 0; return JUMP;}
147 [jJ][uU][mM][pP]"."[xX] { BEGIN 0; return JUMP_DOT_L; }
148 [iI][uU] yylval.value = M_IU; return MMOD;
149 [iI][sS][sS]2 yylval.value = M_ISS2; return MMOD;
150 [iI][sS] yylval.value = M_IS; return MMOD;
151 [iI][hH] yylval.value = M_IH; return MMOD;
152 [iI][fF] return IF;
153 [iI][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_I, yytext);
154 [iI][0-3] return parse_reg (&yylval.reg, T_REG_I, yytext);
155 [hH][lL][tT] return HLT;
156 [hH][iI] return HI;
157 [gG][tT] return GT;
158 [gG][eE] return GE;
159 [fF][uU] yylval.value = M_FU; return MMOD;
160 [fF][pP] _REG.regno = REG_FP; return REG;
161 [fF][pP]"."[lL] _REG.regno = REG_FP; _REG.flags = F_REG_LOW; return HALF_REG;
162 [fF][pP]"."[hH] _REG.regno = REG_FP; _REG.flags = F_REG_HIGH; return HALF_REG;
163
164 [eE][xX][tT][rR][aA][cC][tT] return EXTRACT;
165 [eE][xX][pP][aA][dD][jJ] return EXPADJ;
166 [eE][xX][cC][pP][tT] return EXCPT;
167 [eE][mM][uU][eE][xX][cC][pP][tT] return EMUEXCPT;
168 [dD][iI][vV][sS] return DIVS;
169 [dD][iI][vV][qQ] return DIVQ;
170 [dD][iI][sS][aA][lL][gG][nN][eE][xX][cC][pP][tT] return DISALGNEXCPT;
171 [dD][eE][pP][oO][sS][iI][tT] return DEPOSIT;
172 [dD][bB][gG][hH][aA][lL][tT] return DBGHALT;
173 [dD][bB][gG][cC][mM][pP][lL][xX] return DBGCMPLX;
174 [dD][bB][gG][aA][lL] return DBGAL;
175 [dD][bB][gG][aA][hH] return DBGAH;
176 [dD][bB][gG][aA] return DBGA;
177 [dD][bB][gG] return DBG;
178 [cC][yY][cC][lL][eE][sS]2 { _REG.regno = REG_CYCLES2; return REG; }
179 [cC][yY][cC][lL][eE][sS] { _REG.regno = REG_CYCLES; return REG; }
180 [cC][sS][yY][nN][cC] return CSYNC;
181 [cC][oO] return CO;
182 [cC][lL][iI] return CLI;
183
184 [cC][cC] _REG.regno = REG_CC; return CCREG;
185 [cC][aA][lL][lL]"."[xX] { BEGIN 0; return CALL;}
186 [cC][aA][lL][lL] { BEGIN 0; return CALL;}
187 [bB][yY][tT][eE][uU][nN][pP][aA][cC][kK] return BYTEUNPACK;
188 [bB][yY][tT][eE][pP][aA][cC][kK] return BYTEPACK;
189 [bB][yY][tT][eE][oO][pP]16[mM] return BYTEOP16M;
190 [bB][yY][tT][eE][oO][pP]16[pP] return BYTEOP16P;
191 [bB][yY][tT][eE][oO][pP]3[pP] return BYTEOP3P;
192 [bB][yY][tT][eE][oO][pP]2[pP] return BYTEOP2P;
193 [bB][yY][tT][eE][oO][pP]1[pP] return BYTEOP1P;
194 [bB][yY] return BY;
195 [bB][xX][oO][rR][sS][hH][iI][fF][tT] return BXORSHIFT;
196 [bB][xX][oO][rR] return BXOR;
197
198 [bB][rR][eE][vV] return BREV;
199 [bB][pP] return BP;
200 [bB][iI][tT][tT][sS][tT] return BITTST;
201 [bB][iI][tT][tT][gG][lL] return BITTGL;
202 [bB][iI][tT][sS][eE][tT] return BITSET;
203 [bB][iI][tT][mM][uU][xX] return BITMUX;
204 [bB][iI][tT][cC][lL][rR] return BITCLR;
205 [bB][0-3]"."[lLhH] return parse_halfreg (&yylval.reg, T_REG_B, yytext);
206 [bB][0-3] return parse_reg (&yylval.reg, T_REG_B, yytext);
207 [bB] return B;
208 [aA][zZ] _REG.regno = S_AZ; return STATUS_REG;
209 [aA][nN] _REG.regno = S_AN; return STATUS_REG;
210 [aA][cC]0_[cC][oO][pP][yY] _REG.regno = S_AC0_COPY; return STATUS_REG;
211 [vV]_[cC][oO][pP][yY] _REG.regno = S_V_COPY; return STATUS_REG;
212 [aA][qQ] _REG.regno = S_AQ; return STATUS_REG;
213 [aA][cC]0 _REG.regno = S_AC0; return STATUS_REG;
214 [aA][cC]1 _REG.regno = S_AC1; return STATUS_REG;
215 [aA][vV]0 _REG.regno = S_AV0; return STATUS_REG;
216 [aA][vV]0[sS] _REG.regno = S_AV0S; return STATUS_REG;
217 [aA][vV]1 _REG.regno = S_AV1; return STATUS_REG;
218 [aA][vV]1[sS] _REG.regno = S_AV1S; return STATUS_REG;
219 [vV][sS] _REG.regno = S_VS; return STATUS_REG;
220 [rR][nN][dD]_[mM][oO][dD] _REG.regno = S_RND_MOD; return STATUS_REG;
221
222
223 [aA][sS][tT][aA][tT] _REG.regno = REG_ASTAT; return REG;
224 [aA][sS][hH][iI][fF][tT] return ASHIFT;
225 [aA][sS][lL] return ASL;
226 [aA][sS][rR] return ASR;
227 [aA][lL][iI][gG][nN]8 return ALIGN8;
228 [aA][lL][iI][gG][nN]16 return ALIGN16;
229 [aA][lL][iI][gG][nN]24 return ALIGN24;
230 [aA]1"."[lL] return A_ONE_DOT_L;
231 [aA]0"."[lL] return A_ZERO_DOT_L;
232 [aA]1"."[hH] return A_ONE_DOT_H;
233 [aA]0"."[hH] return A_ZERO_DOT_H;
234 [aA][bB][sS] return ABS;
235 [aA][bB][oO][rR][tT] return ABORT;
236 [aA]1"."[xX] _REG.regno = REG_A1x; return REG;
237 [aA]1"."[wW] _REG.regno = REG_A1w; return REG;
238 [aA]1 _REG.regno = REG_A1; return REG_A_DOUBLE_ONE;
239 [aA]0"."[xX] _REG.regno = REG_A0x; return REG;
240 [aA]0"."[wW] _REG.regno = REG_A0w; return REG;
241 [aA]0 _REG.regno = REG_A0; return REG_A_DOUBLE_ZERO;
242 [Gg][Oo][Tt] return GOT;
243 [Gg][Oo][Tt]"17"[Mm]"4" return GOT17M4;
244 [Ff][Uu][Nn][Cc][Dd][Ee][Ss][Cc]"_"[Gg][Oo][Tt]"17"[Mm]"4" return FUNCDESC_GOT17M4;
245 [Pp][Ll][Tt][Pp][Cc] return PLTPC;
246
247
248 "~" return TILDA;
249 "|=" return _BAR_ASSIGN;
250 "|" return BAR;
251 "^=" return _CARET_ASSIGN;
252 "^" return CARET;
253 "]" return RBRACK;
254 "[" return LBRACK;
255 ">>>=" return _GREATER_GREATER_GREATER_THAN_ASSIGN;
256 ">>=" return _GREATER_GREATER_ASSIGN;
257 ">>>" return _GREATER_GREATER_GREATER;
258 ">>" return GREATER_GREATER;
259 "==" return _ASSIGN_ASSIGN;
260 "=" return ASSIGN;
261 "<=" return _LESS_THAN_ASSIGN;
262 "<<=" return _LESS_LESS_ASSIGN;
263 "<<" return LESS_LESS;
264 "<" return LESS_THAN;
265 "(" BEGIN(FLAGS); return LPAREN;
266 ")" BEGIN(INITIAL); return RPAREN;
267 ":" return COLON;
268 "/" return SLASH;
269 "-=" return _MINUS_ASSIGN;
270 "+|+" return _PLUS_BAR_PLUS;
271 "-|+" return _MINUS_BAR_PLUS;
272 "+|-" return _PLUS_BAR_MINUS;
273 "-|-" return _MINUS_BAR_MINUS;
274 "--" return _MINUS_MINUS;
275 "-" return MINUS;
276 "," return COMMA;
277 "+=" return _PLUS_ASSIGN;
278 "++" return _PLUS_PLUS;
279 "+" return PLUS;
280 "*=" return _STAR_ASSIGN;
281 "*" return STAR;
282 "&=" return _AMPERSAND_ASSIGN;
283 "&" return AMPERSAND;
284 "%" return PERCENT;
285 "!" return BANG;
286 ";" return SEMICOLON;
287 "=!" return _ASSIGN_BANG;
288 "||" return DOUBLE_BAR;
289 "@" return AT;
290 <KEYWORD>[pP][rR][eE][fF][eE][tT][cC][hH] return PREFETCH;
291 <KEYWORD>[uU][nN][lL][iI][nN][kK] return UNLINK;
292 <KEYWORD>[lL][iI][nN][kK] return LINK;
293 <KEYWORD>[iI][dD][lL][eE] return IDLE;
294 <KEYWORD>[iI][fF][lL][uU][sS][hH] return IFLUSH;
295 <KEYWORD>[fF][lL][uU][sS][hH][iI][nN][vV] return FLUSHINV;
296 <KEYWORD>[fF][lL][uU][sS][hH] return FLUSH;
297 ([0-9]+)|(0[xX][0-9a-fA-F]+)|([bhfodBHOFD]#[0-9a-fA-F]+)|(0"."[0-9]+) {
298 yylval.value = parse_int (&yytext);
299 return NUMBER;
300 }
301 [[:alpha:]\x80-\xff_$.][[:alnum:]\x80-\xff_$.]* {
302 yylval.symbol = symbol_find_or_make (yytext);
303 symbol_mark_used (yylval.symbol);
304 return SYMBOL;
305 }
306 [0-9][bfBF] {
307 char *name;
308 char *ref = strdup (yytext);
309 if (ref[1] == 'b' || ref[1] == 'B')
310 {
311 name = fb_label_name ((int) (ref[0] - '0'), 0);
312 yylval.symbol = symbol_find (name);
313
314 if ((yylval.symbol != NULL)
315 && (S_IS_DEFINED (yylval.symbol)))
316 return SYMBOL;
317 as_bad ("backward reference to unknown label %d:",
318 (int) (ref[0] - '0'));
319 }
320 else if (ref[1] == 'f' || ref[1] == 'F')
321 {
322 /* Forward reference. Expect symbol to be undefined or
323 unknown. undefined: seen it before. unknown: never seen
324 it before.
325
326 Construct a local label name, then an undefined symbol.
327 Just return it as never seen before. */
328
329 name = fb_label_name ((int) (ref[0] - '0'), 1);
330 yylval.symbol = symbol_find_or_make (name);
331 /* We have no need to check symbol properties. */
332 return SYMBOL;
333 }
334 }
335 [ \t\n] ;
336 "/*".*"*/" ;
337 . return yytext[0];
338 %%
339 static long parse_int (char **end)
340 {
341 char fmt = '\0';
342 int not_done = 1;
343 int shiftvalue = 0;
344 char * char_bag;
345 long value = 0;
346 char *arg = *end;
347
348 while (*arg && *arg == ' ')
349 arg++;
350
351 switch (*arg)
352 {
353 case '1':
354 case '2':
355 case '3':
356 case '4':
357 case '5':
358 case '6':
359 case '7':
360 case '8':
361 case '9':
362 fmt = 'd';
363 break;
364
365 case '0': /* Accept different formated integers hex octal and binary. */
366 {
367 char c = *++arg;
368 arg++;
369 if (c == 'x' || c == 'X') /* Hex input. */
370 fmt = 'h';
371 else if (c == 'b' || c == 'B')
372 fmt = 'b';
373 else if (c == '.')
374 fmt = 'f';
375 else
376 { /* Octal. */
377 arg--;
378 fmt = 'o';
379 }
380 break;
381 }
382
383 case 'd':
384 case 'D':
385 case 'h':
386 case 'H':
387 case 'o':
388 case 'O':
389 case 'b':
390 case 'B':
391 case 'f':
392 case 'F':
393 {
394 fmt = *arg++;
395 if (*arg == '#')
396 arg++;
397 }
398 }
399
400 switch (fmt)
401 {
402 case 'h':
403 case 'H':
404 shiftvalue = 4;
405 char_bag = "0123456789ABCDEFabcdef";
406 break;
407
408 case 'o':
409 case 'O':
410 shiftvalue = 3;
411 char_bag = "01234567";
412 break;
413
414 case 'b':
415 case 'B':
416 shiftvalue = 1;
417 char_bag = "01";
418 break;
419
420 /* The assembler allows for fractional constants to be created
421 by either the 0.xxxx or the f#xxxx format
422
423 i.e. 0.5 would result in 0x4000
424
425 note .5 would result in the identifier .5.
426
427 The assembler converts to fractional format 1.15 by the simple rule:
428
429 value = (short) (finput * (1 << 15)). */
430
431 case 'f':
432 case 'F':
433 {
434 float fval = 0.0;
435 float pos = 10.0;
436 while (1)
437 {
438 int c;
439 c = *arg++;
440
441 if (c >= '0' && c <= '9')
442 {
443 float digit = (c - '0') / pos;
444 fval = fval + digit;
445 pos = pos * 10.0;
446 }
447 else
448 {
449 *--arg = c;
450 value = (short) (fval * (1 << 15));
451 break;
452 }
453 }
454 *end = arg+1;
455 return value;
456 }
457
458 case 'd':
459 case 'D':
460 default:
461 {
462 while (1)
463 {
464 char c;
465 c = *arg++;
466 if (c >= '0' && c <= '9')
467 value = (value * 10) + (c - '0');
468 else
469 {
470 /* Constants that are suffixed with k|K are multiplied by 1024
471 This suffix is only allowed on decimal constants. */
472 if (c == 'k' || c == 'K')
473 value *= 1024;
474 else
475 *--arg = c;
476 break;
477 }
478 }
479 *end = arg+1;
480 return value;
481 }
482 }
483
484 while (not_done)
485 {
486 char c;
487 c = *arg++;
488 if (c == 0 || !strchr (char_bag, c))
489 {
490 not_done = 0;
491 *--arg = c;
492 }
493 else
494 {
495 if (c >= 'a' && c <= 'z')
496 c = c - ('a' - '9') + 1;
497 else if (c >= 'A' && c <= 'Z')
498 c = c - ('A' - '9') + 1;
499
500 c -= '0';
501 value = (value << shiftvalue) + c;
502 }
503 }
504 *end = arg+1;
505 return value;
506 }
507
508
parse_reg(Register * r,int cl,char * rt)509 static int parse_reg (Register *r, int cl, char *rt)
510 {
511 r->regno = cl | (rt[1] - '0');
512 r->flags = F_REG_NONE;
513 return REG;
514 }
515
parse_halfreg(Register * r,int cl,char * rt)516 static int parse_halfreg (Register *r, int cl, char *rt)
517 {
518 r->regno = cl | (rt[1] - '0');
519
520 switch (rt[3])
521 {
522 case 'b':
523 case 'B':
524 return BYTE_DREG;
525
526 case 'l':
527 case 'L':
528 r->flags = F_REG_LOW;
529 break;
530
531 case 'h':
532 case 'H':
533 r->flags = F_REG_HIGH;
534 break;
535 }
536
537 return HALF_REG;
538 }
539
540 /* Our start state is KEYWORD as we have
541 command keywords such as PREFETCH. */
542
543 void
set_start_state(void)544 set_start_state (void)
545 {
546 BEGIN KEYWORD;
547 }
548
549
550 #ifndef yywrap
551 int
yywrap()552 yywrap ()
553 {
554 return 1;
555 }
556 #endif
557