1 %option yylineno
2 %option nounput
3 %{
4 #include <string.h>
5 #include "elk_asm.h"
6 #undef ALIGN16
7 #include "elk_gram.tab.h"
8
9 /* Locations */
10 int yycolumn = 1;
11
12 int saved_state = 0;
13 extern char *input_filename;
14
15 #define YY_NO_INPUT
16 #define YY_USER_ACTION \
17 yylloc.first_line = yylloc.last_line = yylineno; \
18 yylloc.first_column = yycolumn; \
19 yylloc.last_column = yycolumn + yyleng - 1; \
20 yycolumn += yyleng;
21 %}
22
23 %x BLOCK_COMMENT
24 %x FILENAME
25 %x CHANNEL
26 %x REG
27 %x DOTSEL
28 %x LABEL
29 %x MSGDESC
30 %%
31
32 /* eat up single line comment */
33 \/\/.*[\r\n] { yycolumn = 1; }
34
35 /* eat up multiline comment */
36 \/\* { saved_state = YYSTATE; BEGIN(BLOCK_COMMENT); }
37
38 <BLOCK_COMMENT>\*\/ { BEGIN(saved_state); }
39
40 <BLOCK_COMMENT>. { }
41 <BLOCK_COMMENT>[\r\n] { }
42
43 <FILENAME>\"[^\"]+\" {
44 char *name = malloc(yyleng - 1);
45 memmove(name, yytext + 1, yyleng - 2);
46 name[yyleng-1] = '\0';
47 input_filename = name;
48 }
49
50 /* null register */
51 null { BEGIN(REG); return NULL_TOKEN; }
52
53 /* Opcodes */
54 add { yylval.integer = ELK_OPCODE_ADD; return ADD; }
55 add3 { yylval.integer = ELK_OPCODE_ADD3; return ADD3; }
56 addc { yylval.integer = ELK_OPCODE_ADDC; return ADDC; }
57 and { yylval.integer = ELK_OPCODE_AND; return AND; }
58 asr { yylval.integer = ELK_OPCODE_ASR; return ASR; }
59 avg { yylval.integer = ELK_OPCODE_AVG; return AVG; }
60 bfe { yylval.integer = ELK_OPCODE_BFE; return BFE; }
61 bfi1 { yylval.integer = ELK_OPCODE_BFI1; return BFI1; }
62 bfi2 { yylval.integer = ELK_OPCODE_BFI2; return BFI2; }
63 bfrev { yylval.integer = ELK_OPCODE_BFREV; return BFREV; }
64 brc { yylval.integer = ELK_OPCODE_BRC; return BRC; }
65 brd { yylval.integer = ELK_OPCODE_BRD; return BRD; }
66 break { yylval.integer = ELK_OPCODE_BREAK; return BREAK; }
67 call { yylval.integer = ELK_OPCODE_CALL; return CALL; }
68 calla { yylval.integer = ELK_OPCODE_CALLA; return CALLA; }
69 case { yylval.integer = ELK_OPCODE_CASE; return CASE; }
70 cbit { yylval.integer = ELK_OPCODE_CBIT; return CBIT; }
71 cmp { yylval.integer = ELK_OPCODE_CMP; return CMP; }
72 cmpn { yylval.integer = ELK_OPCODE_CMPN; return CMPN; }
73 cont { yylval.integer = ELK_OPCODE_CONTINUE; return CONT; }
74 csel { yylval.integer = ELK_OPCODE_CSEL; return CSEL; }
75 dim { yylval.integer = ELK_OPCODE_DIM; return DIM; }
76 do { yylval.integer = ELK_OPCODE_DO; return DO; }
77 dp2 { yylval.integer = ELK_OPCODE_DP2; return DP2; }
78 dp3 { yylval.integer = ELK_OPCODE_DP3; return DP3; }
79 dp4 { yylval.integer = ELK_OPCODE_DP4; return DP4; }
80 dp4a { yylval.integer = ELK_OPCODE_DP4A; return DP4A; }
81 dph { yylval.integer = ELK_OPCODE_DPH; return DPH; }
82 else { yylval.integer = ELK_OPCODE_ELSE; return ELSE; }
83 endif { yylval.integer = ELK_OPCODE_ENDIF; return ENDIF; }
84 f16to32 { yylval.integer = ELK_OPCODE_F16TO32; return F16TO32; }
85 f32to16 { yylval.integer = ELK_OPCODE_F32TO16; return F32TO16; }
86 fbh { yylval.integer = ELK_OPCODE_FBH; return FBH; }
87 fbl { yylval.integer = ELK_OPCODE_FBL; return FBL; }
88 fork { yylval.integer = ELK_OPCODE_FORK; return FORK; }
89 frc { yylval.integer = ELK_OPCODE_FRC; return FRC; }
90 goto { yylval.integer = ELK_OPCODE_GOTO; return GOTO; }
91 halt { yylval.integer = ELK_OPCODE_HALT; return HALT; }
92 if { yylval.integer = ELK_OPCODE_IF; return IF; }
93 iff { yylval.integer = ELK_OPCODE_IFF; return IFF; }
94 illegal { yylval.integer = ELK_OPCODE_ILLEGAL; return ILLEGAL; }
95 jmpi { yylval.integer = ELK_OPCODE_JMPI; return JMPI; }
96 line { yylval.integer = ELK_OPCODE_LINE; return LINE; }
97 lrp { yylval.integer = ELK_OPCODE_LRP; return LRP; }
98 lzd { yylval.integer = ELK_OPCODE_LZD; return LZD; }
99 mac { yylval.integer = ELK_OPCODE_MAC; return MAC; }
100 mach { yylval.integer = ELK_OPCODE_MACH; return MACH; }
101 mad { yylval.integer = ELK_OPCODE_MAD; return MAD; }
102 madm { yylval.integer = ELK_OPCODE_MADM; return MADM; }
103 mov { yylval.integer = ELK_OPCODE_MOV; return MOV; }
104 movi { yylval.integer = ELK_OPCODE_MOVI; return MOVI; }
105 mul { yylval.integer = ELK_OPCODE_MUL; return MUL; }
106 mrest { yylval.integer = ELK_OPCODE_MREST; return MREST; }
107 msave { yylval.integer = ELK_OPCODE_MSAVE; return MSAVE; }
108 nenop { yylval.integer = ELK_OPCODE_NENOP; return NENOP; }
109 nop { yylval.integer = ELK_OPCODE_NOP; return NOP; }
110 not { yylval.integer = ELK_OPCODE_NOT; return NOT; }
111 or { yylval.integer = ELK_OPCODE_OR; return OR; }
112 pln { yylval.integer = ELK_OPCODE_PLN; return PLN; }
113 pop { yylval.integer = ELK_OPCODE_POP; return POP; }
114 push { yylval.integer = ELK_OPCODE_PUSH; return PUSH; }
115 ret { yylval.integer = ELK_OPCODE_RET; return RET; }
116 rndd { yylval.integer = ELK_OPCODE_RNDD; return RNDD; }
117 rnde { yylval.integer = ELK_OPCODE_RNDE; return RNDE; }
118 rndu { yylval.integer = ELK_OPCODE_RNDU; return RNDU; }
119 rndz { yylval.integer = ELK_OPCODE_RNDZ; return RNDZ; }
120 rol { yylval.integer = ELK_OPCODE_ROL; return ROL; }
121 ror { yylval.integer = ELK_OPCODE_ROR; return ROR; }
122 sad2 { yylval.integer = ELK_OPCODE_SAD2; return SAD2; }
123 sada2 { yylval.integer = ELK_OPCODE_SADA2; return SADA2; }
124 sel { yylval.integer = ELK_OPCODE_SEL; return SEL; }
125 send {
126 yylval.integer = ELK_OPCODE_SEND;
127 return p->devinfo->ver < 12 ? SEND_GFX4 : SEND_GFX12;
128 }
129 sendc {
130 yylval.integer = ELK_OPCODE_SENDC;
131 return p->devinfo->ver < 12 ? SENDC_GFX4 : SENDC_GFX12;
132 }
133 sends { yylval.integer = ELK_OPCODE_SENDS; return SENDS; }
134 sendsc { yylval.integer = ELK_OPCODE_SENDSC; return SENDSC; }
135 shl { yylval.integer = ELK_OPCODE_SHL; return SHL; }
136 shr { yylval.integer = ELK_OPCODE_SHR; return SHR; }
137 smov { yylval.integer = ELK_OPCODE_SMOV; return SMOV; }
138 subb { yylval.integer = ELK_OPCODE_SUBB; return SUBB; }
139 wait { yylval.integer = ELK_OPCODE_WAIT; return WAIT; }
140 while { yylval.integer = ELK_OPCODE_WHILE; return WHILE; }
141 xor { yylval.integer = ELK_OPCODE_XOR; return XOR; }
142 sync { yylval.integer = ELK_OPCODE_SYNC; return SYNC; }
143
144 /* extended math functions */
145 cos { yylval.integer = ELK_MATH_FUNCTION_COS; return COS; }
146 exp { yylval.integer = ELK_MATH_FUNCTION_EXP; return EXP; }
147 fdiv { yylval.integer = ELK_MATH_FUNCTION_FDIV; return FDIV; }
148 inv { yylval.integer = ELK_MATH_FUNCTION_INV; return INV; }
149 invm { yylval.integer = GFX8_MATH_FUNCTION_INVM; return INVM; }
150 intdiv {
151 yylval.integer = ELK_MATH_FUNCTION_INT_DIV_QUOTIENT;
152 return INTDIV;
153 }
154 intdivmod {
155 yylval.integer =
156 ELK_MATH_FUNCTION_INT_DIV_QUOTIENT_AND_REMAINDER;
157 return INTDIVMOD;
158 }
159 intmod {
160 yylval.integer = ELK_MATH_FUNCTION_INT_DIV_REMAINDER;
161 return INTMOD;
162 }
163 log { yylval.integer = ELK_MATH_FUNCTION_LOG; return LOG; }
164 pow { yylval.integer = ELK_MATH_FUNCTION_POW; return POW; }
165 rsq { yylval.integer = ELK_MATH_FUNCTION_RSQ; return RSQ; }
166 rsqrtm { yylval.integer = GFX8_MATH_FUNCTION_RSQRTM; return RSQRTM; }
167 sin { yylval.integer = ELK_MATH_FUNCTION_SIN; return SIN; }
168 sqrt { yylval.integer = ELK_MATH_FUNCTION_SQRT; return SQRT; }
169 sincos { yylval.integer = ELK_MATH_FUNCTION_SINCOS; return SINCOS; }
170
171 /* sync instruction */
172 allrd { yylval.integer = TGL_SYNC_ALLRD; return ALLRD; }
173 allwr { yylval.integer = TGL_SYNC_ALLWR; return ALLWR; }
174 fence { yylval.integer = TGL_SYNC_FENCE; return FENCE; }
175 bar { yylval.integer = TGL_SYNC_BAR; return BAR; }
176 host { yylval.integer = TGL_SYNC_HOST; return HOST; }
177
178 /* shared functions for send instruction */
179 sampler { return SAMPLER; }
180 dp_sampler { return DP_SAMPLER; }
181 gateway { return GATEWAY; }
182 urb { return URB; }
183 thread_spawner { return THREAD_SPAWNER; }
184 render { return RENDER; }
185 const { return CONST; }
186 data { return DATA; }
187 cre { return CRE; }
188 math { return MATH; }
189 read { return READ; }
190 write { return WRITE; }
191 vme { return VME; }
192 "pixel interp" { return PIXEL_INTERP; }
193 "dp data 1" { return DP_DATA_1; }
194 "rt accel" { return RT_ACCEL; }
195 slm { return SLM; }
196 tgm { return TGM; }
197 ugm { return UGM; }
198
199 ";" { return SEMICOLON; }
200 ":" { return COLON; }
201 "(" { return LPAREN; }
202 ")" { return RPAREN; }
203 "{" { return LCURLY; }
204 "}" { return RCURLY; }
205 "[" { return LSQUARE; }
206 "]" { return RSQUARE; }
207 "<" { return LANGLE; }
208 ">" { return RANGLE; }
209 "," { return COMMA; }
210 "." { return DOT; }
211 "+" { return PLUS; }
212 "-" { return MINUS; }
213 "~" { return MINUS; }
214 "(abs)" { return ABS; }
215
216
217 "VxH" { return VxH; }
218 <REG>"<" { return LANGLE; }
219 <REG>[0-9][0-9]* {
220 yylval.integer = strtoul(yytext, NULL, 10);
221 return INTEGER;
222 }
223 <REG>">" { return RANGLE; }
224 <REG>"," { return COMMA; }
225 <REG>"." { BEGIN(DOTSEL); return DOT; }
226 <REG>";" { return SEMICOLON; }
227
228 <DOTSEL>"x" { yylval.integer = ELK_CHANNEL_X; return X; }
229 <DOTSEL>"y" { yylval.integer = ELK_CHANNEL_Y; return Y; }
230 <DOTSEL>"z" { yylval.integer = ELK_CHANNEL_Z; return Z; }
231 <DOTSEL>"w" { yylval.integer = ELK_CHANNEL_W; return W; }
232 <DOTSEL>[0-9][0-9]* {
233 yylval.integer = strtoul(yytext, NULL, 10);
234 BEGIN(REG);
235 return INTEGER;
236 }
237 <DOTSEL>. { yyless(0); BEGIN(INITIAL); }
238 <REG>. { yyless(0); BEGIN(INITIAL); }
239
240 /* Access mode */
241 "align1" { return ALIGN1; }
242 "align16" { return ALIGN16; }
243
244 /* Accumulator write control */
245 AccWrEnable { return ACCWREN; }
246
247 /* Mask control (formerly WECtrl/Write Enable Control) */
248 "WE_all" { return WECTRL; }
249
250 /* Compaction control */
251 compacted { return CMPTCTRL; }
252
253 /* Debug control */
254 breakpoint { return BREAKPOINT; }
255
256 /* Dependency control */
257 NoDDClr { return NODDCLR; }
258 NoDDChk { return NODDCHK; }
259
260 /* End of thread */
261 EOT { return EOT; }
262
263 /* Mask control */
264 nomask { return MASK_DISABLE; }
265
266 /* Channel */
267 <CHANNEL>"x" { yylval.integer = ELK_CHANNEL_X; return X; }
268 <CHANNEL>"y" { yylval.integer = ELK_CHANNEL_Y; return Y; }
269 <CHANNEL>"z" { yylval.integer = ELK_CHANNEL_Z; return Z; }
270 <CHANNEL>"w" { yylval.integer = ELK_CHANNEL_W; return W; }
271 <CHANNEL>[0-9][0-9]* {
272 yylval.integer = strtoul(yytext, NULL, 10);
273 return INTEGER;
274 }
275 <CHANNEL>"." { return DOT; }
276 <CHANNEL>. { yyless(0); BEGIN(INITIAL); }
277
278
279 /* Predicate Control */
280 <CHANNEL>".anyv" { yylval.integer = ELK_PREDICATE_ALIGN1_ANYV; return ANYV; }
281 <CHANNEL>".allv" { yylval.integer = ELK_PREDICATE_ALIGN1_ALLV; return ALLV; }
282 <CHANNEL>".any2h" { yylval.integer = ELK_PREDICATE_ALIGN1_ANY2H; return ANY2H; }
283 <CHANNEL>".all2h" { yylval.integer = ELK_PREDICATE_ALIGN1_ALL2H; return ALL2H; }
284 <CHANNEL>".any4h" { yylval.integer = ELK_PREDICATE_ALIGN16_ANY4H; return ANY4H; }
285 <CHANNEL>".all4h" { yylval.integer = ELK_PREDICATE_ALIGN16_ALL4H; return ALL4H; }
286 <CHANNEL>".any8h" { yylval.integer = ELK_PREDICATE_ALIGN1_ANY8H; return ANY8H; }
287 <CHANNEL>".all8h" { yylval.integer = ELK_PREDICATE_ALIGN1_ALL8H; return ALL8H; }
288 <CHANNEL>".any16h" { yylval.integer = ELK_PREDICATE_ALIGN1_ANY16H; return ANY16H; }
289 <CHANNEL>".all16h" { yylval.integer = ELK_PREDICATE_ALIGN1_ALL16H; return ALL16H; }
290 <CHANNEL>".any32h" { yylval.integer = ELK_PREDICATE_ALIGN1_ANY32H; return ANY32H; }
291 <CHANNEL>".all32h" { yylval.integer = ELK_PREDICATE_ALIGN1_ALL32H; return ALL32H; }
292
293 /* Saturation */
294 ".sat" { return SATURATE; }
295
296 /* Thread control */
297 atomic { return ATOMIC; }
298 switch { return SWITCH; }
299
300 /* compression control */
301 compr { return COMPR; }
302 compr4 { return COMPR4; }
303 sechalf { return SECHALF; }
304
305 /* Quarter Control */
306 1[HNQ] { }
307 "2Q" { return QTR_2Q; }
308 "3Q" { return QTR_3Q; }
309 "4Q" { return QTR_4Q; }
310 "2H" { return QTR_2H; }
311 "2N" { return QTR_2N; }
312 "3N" { return QTR_3N; }
313 "4N" { return QTR_4N; }
314 "5N" { return QTR_5N; }
315 "6N" { return QTR_6N; }
316 "7N" { return QTR_7N; }
317 "8N" { return QTR_8N; }
318
319 /* data types */
320 :?B { return TYPE_B; }
321 :?D { return TYPE_D; }
322 :?DF { return TYPE_DF; }
323 :?F { return TYPE_F; }
324 :?HF { return TYPE_HF; }
325 :?NF { return TYPE_NF; }
326 :?Q { return TYPE_Q; }
327 :?UB { return TYPE_UB; }
328 :?UD { return TYPE_UD; }
329 :?UW { return TYPE_UW; }
330 :?UQ { return TYPE_UQ; }
331 :?UV { return TYPE_UV; }
332 :?V { return TYPE_V; }
333 :?VF { return TYPE_VF; }
334 :?W { return TYPE_W; }
335
336 /* Address registers */
337 "a0" { return ADDRREG; }
338
339 /* accumulator registers */
340 "acc"[0-9]+ { yylval.integer = atoi(yytext + 3); return ACCREG; }
341
342 /* channel enable registers */
343 "ce0" { return CHANNELENABLEREG; }
344
345 /* control registers */
346 "cr0" { return CONTROLREG; }
347
348 /* flag registers */
349 "f"[0|1] { BEGIN(CHANNEL); yylval.integer = atoi(yytext + 1); return FLAGREG; }
350
351 /* message control registers */
352 "m" { return MSGREGFILE; }
353 m[0-9]+ { yylval.integer = atoi(yytext + 1); BEGIN(REG); return MSGREG; }
354
355 /* state register */
356 sr[0-9]+ { yylval.integer = atoi(yytext + 2); return STATEREG; }
357
358 /* notification registers */
359 "n0" { BEGIN(REG); return NOTIFYREG; }
360
361 /* IP register */
362 "ip" { return IPREG; }
363
364 /* Thread control register */
365 "tdr0" { return THREADREG; }
366
367 /* performance register */
368 "tm0" { BEGIN(REG); return PERFORMANCEREG; }
369
370 [gr][0-9]+ {
371 yylval.integer = atoi(yytext + 1);
372 BEGIN(REG); return GENREG;
373 }
374 [gr] { return GENREGFILE; }
375 "mask"[0-9]+ { yylval.integer = atoi(yytext + 4); return MASKREG; }
376
377 /* Conditional modifiers */
378 ".e" { yylval.integer = ELK_CONDITIONAL_Z; return EQUAL; }
379 ".g" { yylval.integer = ELK_CONDITIONAL_G; return GREATER; }
380 ".ge" { yylval.integer = ELK_CONDITIONAL_GE; return GREATER_EQUAL; }
381 ".l" { yylval.integer = ELK_CONDITIONAL_L; return LESS; }
382 ".le" { yylval.integer = ELK_CONDITIONAL_LE; return LESS_EQUAL; }
383 ".ne" { yylval.integer = ELK_CONDITIONAL_NZ; return NOT_EQUAL; }
384 ".nz" { yylval.integer = ELK_CONDITIONAL_NZ; return NOT_ZERO; }
385 ".o" { yylval.integer = ELK_CONDITIONAL_O; return OVERFLOW; }
386 ".r" { yylval.integer = ELK_CONDITIONAL_R; return ROUND_INCREMENT; }
387 ".u" { yylval.integer = ELK_CONDITIONAL_U; return UNORDERED; }
388 ".z" { yylval.integer = ELK_CONDITIONAL_Z; return ZERO; }
389
390 /* Eat up JIP and UIP token, their values will be parsed
391 * in numeric section
392 */
393 "JIP: " { BEGIN(LABEL); }
394 "UIP: " { BEGIN(LABEL); }
395 "Jump: " { }
396 "Pop: " { }
397 [ \t]+ { }
398
399 "MsgDesc: " { BEGIN(MSGDESC); return MSGDESC_BEGIN; }
400 <MSGDESC>ex_bso { return EX_BSO; }
401 <MSGDESC>src1_len { return SRC1_LEN; }
402 <MSGDESC>"=" { return ASSIGN; }
403 <MSGDESC>[0-9][0-9]* {
404 yylval.integer = strtoul(yytext, NULL, 10);
405 return INTEGER;
406 }
407 <MSGDESC>"{" { yyless(0); BEGIN(INITIAL); return MSGDESC_END; }
408 <MSGDESC>. { }
409
410 "0x"[0-9a-f][0-9a-f]* {
411 yylval.llint = strtoull(yytext + 2, NULL, 16);
412 return LONG;
413 }
414 [0-9][0-9]* {
415 yylval.llint = strtoll(yytext, NULL, 10);
416 return LONG;
417 }
418
419 /* jump label target */
420 [a-zA-Z_][0-9a-zA-Z_]*":" {
421 yylval.string = ralloc_strdup(p->mem_ctx, yytext);
422 /* Stomp the trailing ':' */
423 yylval.string[yyleng - 1] = '\0';
424 return JUMP_LABEL_TARGET;
425 }
426
427 /* jump label */
428 <LABEL>[a-zA-Z_][0-9a-zA-Z_]* {
429 yylval.string = ralloc_strdup(p->mem_ctx, yytext);
430 BEGIN(INITIAL);
431 return JUMP_LABEL;
432 }
433
434 /* SWSB */
435 "@"[1-7] { yylval.integer = atoi(yytext + 1); return REG_DIST_CURRENT; }
436 "F@"[1-7] { yylval.integer = atoi(yytext + 2); return REG_DIST_FLOAT; }
437 "I@"[1-7] { yylval.integer = atoi(yytext + 2); return REG_DIST_INT; }
438 "L@"[1-7] { yylval.integer = atoi(yytext + 2); return REG_DIST_LONG; }
439 "A@"[1-7] { yylval.integer = atoi(yytext + 2); return REG_DIST_ALL; }
440
441 "$"[0-9]* { yylval.integer = atoi(yytext + 1); return SBID_ALLOC; }
442 "$"[0-9]*".src" { yylval.integer = atoi(yytext + 1); return SBID_WAIT_SRC; }
443 "$"[0-9]*".dst" { yylval.integer = atoi(yytext + 1); return SBID_WAIT_DST; }
444
445 \n { yycolumn = 1; }
446
447 . {
448 fprintf(stderr, "%s: %d: %s: at \"%s\"\n",
449 input_filename, yylineno,
450 "unexpected token", lex_text());
451 }
452 %%
453
454 char *
455 lex_text(void)
456 {
457 return yytext;
458 }
459
460 #ifndef yywrap
yywrap()461 int yywrap()
462 {
463 return -1;
464 }
465 #endif
466