1 /*
2 * Copyright (c) 2013 Rob Clark <robclark@freedesktop.org>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 */
23
24 %code requires {
25 #include "ir3/ir3_assembler.h"
26 #include "ir3/ir3_shader.h"
27
28 struct ir3 * ir3_parse(struct ir3_shader_variant *v,
29 struct ir3_kernel_info *k, FILE *f);
30 }
31
32 %{
33 #define YYDEBUG 0
34
35 #include <stdlib.h>
36 #include <stdio.h>
37 #include <string.h>
38 #include <math.h>
39
40 #include "util/half_float.h"
41 #include "util/u_math.h"
42
43 #include "ir3/ir3.h"
44 #include "ir3/ir3_shader.h"
45 #include "ir3/instr-a3xx.h"
46
47 #include "ir3_parser.h"
48
49 #define swap(a, b) \
50 do { __typeof(a) __tmp = (a); (a) = (b); (b) = __tmp; } while (0)
51
52 /* ir3 treats the abs/neg flags as separate flags for float vs integer,
53 * but in the instruction encoding they are the same thing. Tracking
54 * them separately is only for the benefit of ir3 opt passes, and not
55 * required here, so just use the float versions:
56 */
57 #define IR3_REG_ABS IR3_REG_FABS
58 #define IR3_REG_NEGATE IR3_REG_FNEG
59
60 static struct ir3_kernel_info *info;
61 static struct ir3_shader_variant *variant;
62 /* NOTE the assembler doesn't really use the ir3_block construction
63 * like the compiler does. Everything is treated as one large block.
64 * Which might happen to contain flow control. But since we don't
65 * use any of the ir3 backend passes (sched, RA, etc) this doesn't
66 * really matter.
67 */
68 static struct ir3_block *block; /* current shader block */
69 static struct ir3_instruction *instr; /* current instruction */
70 static unsigned ip; /* current instruction pointer */
71 static struct hash_table *labels;
72
73 void *ir3_parser_dead_ctx;
74
75 static struct {
76 unsigned flags;
77 unsigned repeat;
78 unsigned nop;
79 } iflags;
80
81 static struct {
82 unsigned flags;
83 unsigned wrmask;
84 } rflags;
85
86 int ir3_yyget_lineno(void);
87
new_label(const char * name)88 static void new_label(const char *name)
89 {
90 ralloc_steal(labels, (void *) name);
91 _mesa_hash_table_insert(labels, name, (void *)(uintptr_t)ip);
92 }
93
new_instr(opc_t opc)94 static struct ir3_instruction * new_instr(opc_t opc)
95 {
96 instr = ir3_instr_create(block, opc, 4, 6);
97 instr->flags = iflags.flags;
98 instr->repeat = iflags.repeat;
99 instr->nop = iflags.nop;
100 instr->line = ir3_yyget_lineno();
101 iflags.flags = iflags.repeat = iflags.nop = 0;
102 ip++;
103 return instr;
104 }
105
new_shader(void)106 static void new_shader(void)
107 {
108 variant->ir = ir3_create(variant->shader->compiler, variant);
109 block = ir3_block_create(variant->ir);
110 list_addtail(&block->node, &variant->ir->block_list);
111 ip = 0;
112 labels = _mesa_hash_table_create(variant, _mesa_hash_string, _mesa_key_string_equal);
113 ir3_parser_dead_ctx = ralloc_context(NULL);
114 }
115
parse_type(const char ** type)116 static type_t parse_type(const char **type)
117 {
118 if (!strncmp("f16", *type, 3)) {
119 *type += 3;
120 return TYPE_F16;
121 } else if (!strncmp("f32", *type, 3)) {
122 *type += 3;
123 return TYPE_F32;
124 } else if (!strncmp("u16", *type, 3)) {
125 *type += 3;
126 return TYPE_U16;
127 } else if (!strncmp("u32", *type, 3)) {
128 *type += 3;
129 return TYPE_U32;
130 } else if (!strncmp("s16", *type, 3)) {
131 *type += 3;
132 return TYPE_S16;
133 } else if (!strncmp("s32", *type, 3)) {
134 *type += 3;
135 return TYPE_S32;
136 } else if (!strncmp("u8", *type, 2)) {
137 *type += 2;
138 return TYPE_U8;
139 } else if (!strncmp("s8", *type, 2)) {
140 *type += 2;
141 return TYPE_S8;
142 } else {
143 assert(0); /* shouldn't get here */
144 return ~0;
145 }
146 }
147
parse_type_type(struct ir3_instruction * instr,const char * type_type)148 static struct ir3_instruction * parse_type_type(struct ir3_instruction *instr,
149 const char *type_type)
150 {
151 instr->cat1.src_type = parse_type(&type_type);
152 instr->cat1.dst_type = parse_type(&type_type);
153 return instr;
154 }
155
new_src(int num,unsigned flags)156 static struct ir3_register * new_src(int num, unsigned flags)
157 {
158 struct ir3_register *reg;
159 flags |= rflags.flags;
160 if (num & 0x1)
161 flags |= IR3_REG_HALF;
162 reg = ir3_src_create(instr, num>>1, flags);
163 reg->wrmask = MAX2(1, rflags.wrmask);
164 rflags.flags = rflags.wrmask = 0;
165 return reg;
166 }
167
new_dst(int num,unsigned flags)168 static struct ir3_register * new_dst(int num, unsigned flags)
169 {
170 struct ir3_register *reg;
171 flags |= rflags.flags;
172 if (num & 0x1)
173 flags |= IR3_REG_HALF;
174 reg = ir3_dst_create(instr, num>>1, flags);
175 reg->wrmask = MAX2(1, rflags.wrmask);
176 rflags.flags = rflags.wrmask = 0;
177 return reg;
178 }
179
dummy_dst(void)180 static struct ir3_register * dummy_dst(void)
181 {
182 return new_dst(0, 0);
183 }
184
fixup_cat5_s2en(void)185 static void fixup_cat5_s2en(void)
186 {
187 assert(opc_cat(instr->opc) == 5);
188 if (!(instr->flags & IR3_INSTR_S2EN))
189 return;
190 /* For various reasons (ie. mainly to make the .s2en src easier to
191 * find, given that various different cat5 tex instructions can have
192 * different # of src registers), in ir3 the samp/tex src register
193 * is first, rather than last. So we have to detect this case and
194 * fix things up.
195 */
196 struct ir3_register *s2en_src = instr->srcs[instr->srcs_count - 1];
197
198 if (instr->flags & IR3_INSTR_B)
199 assert(!(s2en_src->flags & IR3_REG_HALF));
200 else
201 assert(s2en_src->flags & IR3_REG_HALF);
202
203 for (int i = 0; i < instr->srcs_count - 1; i++) {
204 instr->srcs[i+1] = instr->srcs[i];
205 }
206 instr->srcs[0] = s2en_src;
207 }
208
add_const(unsigned reg,unsigned c0,unsigned c1,unsigned c2,unsigned c3)209 static void add_const(unsigned reg, unsigned c0, unsigned c1, unsigned c2, unsigned c3)
210 {
211 struct ir3_const_state *const_state = ir3_const_state(variant);
212 assert((reg & 0x7) == 0);
213 int idx = reg >> (1 + 2); /* low bit is half vs full, next two bits are swiz */
214 if (idx * 4 + 4 > const_state->immediates_size) {
215 const_state->immediates = rerzalloc(const_state,
216 const_state->immediates,
217 __typeof__(const_state->immediates[0]),
218 const_state->immediates_size,
219 idx * 4 + 4);
220 for (unsigned i = const_state->immediates_size; i < idx * 4; i++)
221 const_state->immediates[i] = 0xd0d0d0d0;
222 const_state->immediates_size = const_state->immediates_count = idx * 4 + 4;
223 }
224 const_state->immediates[idx * 4 + 0] = c0;
225 const_state->immediates[idx * 4 + 1] = c1;
226 const_state->immediates[idx * 4 + 2] = c2;
227 const_state->immediates[idx * 4 + 3] = c3;
228 }
229
add_sysval(unsigned reg,unsigned compmask,gl_system_value sysval)230 static void add_sysval(unsigned reg, unsigned compmask, gl_system_value sysval)
231 {
232 unsigned n = variant->inputs_count++;
233 variant->inputs[n].regid = reg;
234 variant->inputs[n].sysval = true;
235 variant->inputs[n].slot = sysval;
236 variant->inputs[n].compmask = compmask;
237 variant->total_in++;
238 }
239
resolve_labels(void)240 static bool resolve_labels(void)
241 {
242 int instr_ip = 0;
243 foreach_instr (instr, &block->instr_list) {
244 if (opc_cat(instr->opc) == 0 && instr->cat0.target_label) {
245 struct hash_entry *entry = _mesa_hash_table_search(labels, instr->cat0.target_label);
246 if (!entry) {
247 fprintf(stderr, "unknown label %s\n", instr->cat0.target_label);
248 return false;
249 }
250 int target_ip = (uintptr_t)entry->data;
251 instr->cat0.immed = target_ip - instr_ip;
252 }
253 instr_ip++;
254 }
255 return true;
256 }
257
258 #ifdef YYDEBUG
259 int yydebug;
260 #endif
261
262 extern int yylex(void);
263 void ir3_yyset_lineno(int _line_number);
264 void ir3_yyset_input(FILE *f);
265
266 int yyparse(void);
267
yyerror(const char * error)268 static void yyerror(const char *error)
269 {
270 fprintf(stderr, "error at line %d: %s\n", ir3_yyget_lineno(), error);
271 }
272
ir3_parse(struct ir3_shader_variant * v,struct ir3_kernel_info * k,FILE * f)273 struct ir3 * ir3_parse(struct ir3_shader_variant *v,
274 struct ir3_kernel_info *k, FILE *f)
275 {
276 ir3_yyset_lineno(1);
277 ir3_yyset_input(f);
278 #ifdef YYDEBUG
279 yydebug = 1;
280 #endif
281 info = k;
282 variant = v;
283 if (yyparse() || !resolve_labels()) {
284 ir3_destroy(variant->ir);
285 variant->ir = NULL;
286 }
287 ralloc_free(labels);
288 ralloc_free(ir3_parser_dead_ctx);
289 return variant->ir;
290 }
291 %}
292
293 %union {
294 int tok;
295 int num;
296 uint32_t unum;
297 double flt;
298 const char *str;
299 struct ir3_register *reg;
300 struct {
301 int start;
302 int num;
303 } range;
304 type_t type;
305 }
306
307 %{
308 #if YYDEBUG
print_token(FILE * file,int type,YYSTYPE value)309 static void print_token(FILE *file, int type, YYSTYPE value)
310 {
311 fprintf(file, "\ntype: %d\n", type);
312 }
313
314 #define YYPRINT(file, type, value) print_token(file, type, value)
315 #endif
316 %}
317
318 %token <num> T_INT
319 %token <unum> T_HEX
320 %token <flt> T_FLOAT
321 %token <str> T_IDENTIFIER
322 %token <num> T_REGISTER
323 %token <num> T_CONSTANT
324
325 /* @ headers (@const/@sampler/@uniform/@varying) */
326 %token <tok> T_A_LOCALSIZE
327 %token <tok> T_A_CONST
328 %token <tok> T_A_BUF
329 %token <tok> T_A_INVOCATIONID
330 %token <tok> T_A_WGID
331 %token <tok> T_A_NUMWG
332 %token <tok> T_A_BRANCHSTACK
333 %token <tok> T_A_IN
334 %token <tok> T_A_OUT
335 %token <tok> T_A_TEX
336 %token <tok> T_A_PVTMEM
337 /* todo, re-add @sampler/@uniform/@varying if needed someday */
338
339 /* src register flags */
340 %token <tok> T_ABSNEG
341 %token <tok> T_NEG
342 %token <tok> T_ABS
343 %token <tok> T_R
344
345 %token <tok> T_HR
346 %token <tok> T_HC
347
348 /* dst register flags */
349 %token <tok> T_EVEN
350 %token <tok> T_POS_INFINITY
351 %token <tok> T_NEG_INFINITY
352 %token <tok> T_EI
353 %token <num> T_WRMASK
354
355 /* Float LUT values accepted as immed: */
356 %token <num> T_FLUT_0_0
357 %token <num> T_FLUT_0_5
358 %token <num> T_FLUT_1_0
359 %token <num> T_FLUT_2_0
360 %token <num> T_FLUT_E
361 %token <num> T_FLUT_PI
362 %token <num> T_FLUT_INV_PI
363 %token <num> T_FLUT_INV_LOG2_E
364 %token <num> T_FLUT_LOG2_E
365 %token <num> T_FLUT_INV_LOG2_10
366 %token <num> T_FLUT_LOG2_10
367 %token <num> T_FLUT_4_0
368
369 /* instruction flags */
370 %token <tok> T_SY
371 %token <tok> T_SS
372 %token <tok> T_JP
373 %token <tok> T_SAT
374 %token <num> T_RPT
375 %token <tok> T_UL
376 %token <tok> T_NOP
377
378 /* category 0: */
379 %token <tok> T_OP_NOP
380 %token <tok> T_OP_BR
381 %token <tok> T_OP_BRAO
382 %token <tok> T_OP_BRAA
383 %token <tok> T_OP_BRAC
384 %token <tok> T_OP_BANY
385 %token <tok> T_OP_BALL
386 %token <tok> T_OP_BRAX
387 %token <tok> T_OP_JUMP
388 %token <tok> T_OP_CALL
389 %token <tok> T_OP_RET
390 %token <tok> T_OP_KILL
391 %token <tok> T_OP_END
392 %token <tok> T_OP_EMIT
393 %token <tok> T_OP_CUT
394 %token <tok> T_OP_CHMASK
395 %token <tok> T_OP_CHSH
396 %token <tok> T_OP_FLOW_REV
397 %token <tok> T_OP_BKT
398 %token <tok> T_OP_STKS
399 %token <tok> T_OP_STKR
400 %token <tok> T_OP_XSET
401 %token <tok> T_OP_XCLR
402 %token <tok> T_OP_GETONE
403 %token <tok> T_OP_DBG
404 %token <tok> T_OP_SHPS
405 %token <tok> T_OP_SHPE
406 %token <tok> T_OP_PREDT
407 %token <tok> T_OP_PREDF
408 %token <tok> T_OP_PREDE
409
410 /* category 1: */
411 %token <tok> T_OP_MOVMSK
412 %token <tok> T_OP_MOVA1
413 %token <tok> T_OP_MOVA
414 %token <tok> T_OP_MOV
415 %token <tok> T_OP_COV
416 %token <tok> T_OP_SWZ
417 %token <tok> T_OP_GAT
418 %token <tok> T_OP_SCT
419
420 /* category 2: */
421 %token <tok> T_OP_ADD_F
422 %token <tok> T_OP_MIN_F
423 %token <tok> T_OP_MAX_F
424 %token <tok> T_OP_MUL_F
425 %token <tok> T_OP_SIGN_F
426 %token <tok> T_OP_CMPS_F
427 %token <tok> T_OP_ABSNEG_F
428 %token <tok> T_OP_CMPV_F
429 %token <tok> T_OP_FLOOR_F
430 %token <tok> T_OP_CEIL_F
431 %token <tok> T_OP_RNDNE_F
432 %token <tok> T_OP_RNDAZ_F
433 %token <tok> T_OP_TRUNC_F
434 %token <tok> T_OP_ADD_U
435 %token <tok> T_OP_ADD_S
436 %token <tok> T_OP_SUB_U
437 %token <tok> T_OP_SUB_S
438 %token <tok> T_OP_CMPS_U
439 %token <tok> T_OP_CMPS_S
440 %token <tok> T_OP_MIN_U
441 %token <tok> T_OP_MIN_S
442 %token <tok> T_OP_MAX_U
443 %token <tok> T_OP_MAX_S
444 %token <tok> T_OP_ABSNEG_S
445 %token <tok> T_OP_AND_B
446 %token <tok> T_OP_OR_B
447 %token <tok> T_OP_NOT_B
448 %token <tok> T_OP_XOR_B
449 %token <tok> T_OP_CMPV_U
450 %token <tok> T_OP_CMPV_S
451 %token <tok> T_OP_MUL_U24
452 %token <tok> T_OP_MUL_S24
453 %token <tok> T_OP_MULL_U
454 %token <tok> T_OP_BFREV_B
455 %token <tok> T_OP_CLZ_S
456 %token <tok> T_OP_CLZ_B
457 %token <tok> T_OP_SHL_B
458 %token <tok> T_OP_SHR_B
459 %token <tok> T_OP_ASHR_B
460 %token <tok> T_OP_BARY_F
461 %token <tok> T_OP_MGEN_B
462 %token <tok> T_OP_GETBIT_B
463 %token <tok> T_OP_SETRM
464 %token <tok> T_OP_CBITS_B
465 %token <tok> T_OP_SHB
466 %token <tok> T_OP_MSAD
467
468 /* category 3: */
469 %token <tok> T_OP_MAD_U16
470 %token <tok> T_OP_MADSH_U16
471 %token <tok> T_OP_MAD_S16
472 %token <tok> T_OP_MADSH_M16
473 %token <tok> T_OP_MAD_U24
474 %token <tok> T_OP_MAD_S24
475 %token <tok> T_OP_MAD_F16
476 %token <tok> T_OP_MAD_F32
477 %token <tok> T_OP_SEL_B16
478 %token <tok> T_OP_SEL_B32
479 %token <tok> T_OP_SEL_S16
480 %token <tok> T_OP_SEL_S32
481 %token <tok> T_OP_SEL_F16
482 %token <tok> T_OP_SEL_F32
483 %token <tok> T_OP_SAD_S16
484 %token <tok> T_OP_SAD_S32
485 %token <tok> T_OP_SHLG_B16
486
487 /* category 4: */
488 %token <tok> T_OP_RCP
489 %token <tok> T_OP_RSQ
490 %token <tok> T_OP_LOG2
491 %token <tok> T_OP_EXP2
492 %token <tok> T_OP_SIN
493 %token <tok> T_OP_COS
494 %token <tok> T_OP_SQRT
495 %token <tok> T_OP_HRSQ
496 %token <tok> T_OP_HLOG2
497 %token <tok> T_OP_HEXP2
498
499 /* category 5: */
500 %token <tok> T_OP_ISAM
501 %token <tok> T_OP_ISAML
502 %token <tok> T_OP_ISAMM
503 %token <tok> T_OP_SAM
504 %token <tok> T_OP_SAMB
505 %token <tok> T_OP_SAML
506 %token <tok> T_OP_SAMGQ
507 %token <tok> T_OP_GETLOD
508 %token <tok> T_OP_CONV
509 %token <tok> T_OP_CONVM
510 %token <tok> T_OP_GETSIZE
511 %token <tok> T_OP_GETBUF
512 %token <tok> T_OP_GETPOS
513 %token <tok> T_OP_GETINFO
514 %token <tok> T_OP_DSX
515 %token <tok> T_OP_DSY
516 %token <tok> T_OP_GATHER4R
517 %token <tok> T_OP_GATHER4G
518 %token <tok> T_OP_GATHER4B
519 %token <tok> T_OP_GATHER4A
520 %token <tok> T_OP_SAMGP0
521 %token <tok> T_OP_SAMGP1
522 %token <tok> T_OP_SAMGP2
523 %token <tok> T_OP_SAMGP3
524 %token <tok> T_OP_DSXPP_1
525 %token <tok> T_OP_DSYPP_1
526 %token <tok> T_OP_RGETPOS
527 %token <tok> T_OP_RGETINFO
528
529 /* category 6: */
530 %token <tok> T_OP_LDG
531 %token <tok> T_OP_LDG_A
532 %token <tok> T_OP_LDL
533 %token <tok> T_OP_LDP
534 %token <tok> T_OP_STG
535 %token <tok> T_OP_STG_A
536 %token <tok> T_OP_STL
537 %token <tok> T_OP_STP
538 %token <tok> T_OP_LDIB
539 %token <tok> T_OP_G2L
540 %token <tok> T_OP_L2G
541 %token <tok> T_OP_PREFETCH
542 %token <tok> T_OP_LDLW
543 %token <tok> T_OP_STLW
544 %token <tok> T_OP_RESFMT
545 %token <tok> T_OP_RESINFO
546 %token <tok> T_OP_ATOMIC_ADD
547 %token <tok> T_OP_ATOMIC_SUB
548 %token <tok> T_OP_ATOMIC_XCHG
549 %token <tok> T_OP_ATOMIC_INC
550 %token <tok> T_OP_ATOMIC_DEC
551 %token <tok> T_OP_ATOMIC_CMPXCHG
552 %token <tok> T_OP_ATOMIC_MIN
553 %token <tok> T_OP_ATOMIC_MAX
554 %token <tok> T_OP_ATOMIC_AND
555 %token <tok> T_OP_ATOMIC_OR
556 %token <tok> T_OP_ATOMIC_XOR
557 %token <tok> T_OP_RESINFO_B
558 %token <tok> T_OP_LDIB_B
559 %token <tok> T_OP_STIB_B
560 %token <tok> T_OP_ATOMIC_B_ADD
561 %token <tok> T_OP_ATOMIC_B_SUB
562 %token <tok> T_OP_ATOMIC_B_XCHG
563 %token <tok> T_OP_ATOMIC_B_INC
564 %token <tok> T_OP_ATOMIC_B_DEC
565 %token <tok> T_OP_ATOMIC_B_CMPXCHG
566 %token <tok> T_OP_ATOMIC_B_MIN
567 %token <tok> T_OP_ATOMIC_B_MAX
568 %token <tok> T_OP_ATOMIC_B_AND
569 %token <tok> T_OP_ATOMIC_B_OR
570 %token <tok> T_OP_ATOMIC_B_XOR
571 %token <tok> T_OP_LDGB
572 %token <tok> T_OP_STGB
573 %token <tok> T_OP_STIB
574 %token <tok> T_OP_LDC
575 %token <tok> T_OP_LDLV
576 %token <tok> T_OP_GETSPID
577 %token <tok> T_OP_GETWID
578
579 /* category 7: */
580 %token <tok> T_OP_BAR
581 %token <tok> T_OP_FENCE
582
583 /* type qualifiers: */
584 %token <tok> T_TYPE_F16
585 %token <tok> T_TYPE_F32
586 %token <tok> T_TYPE_U16
587 %token <tok> T_TYPE_U32
588 %token <tok> T_TYPE_S16
589 %token <tok> T_TYPE_S32
590 %token <tok> T_TYPE_U8
591 %token <tok> T_TYPE_S8
592
593 %token <tok> T_UNTYPED
594 %token <tok> T_TYPED
595
596 %token <tok> T_1D
597 %token <tok> T_2D
598 %token <tok> T_3D
599 %token <tok> T_4D
600
601 /* condition qualifiers: */
602 %token <tok> T_LT
603 %token <tok> T_LE
604 %token <tok> T_GT
605 %token <tok> T_GE
606 %token <tok> T_EQ
607 %token <tok> T_NE
608
609 %token <tok> T_S2EN
610 %token <tok> T_SAMP
611 %token <tok> T_TEX
612 %token <tok> T_BASE
613 %token <tok> T_OFFSET
614 %token <tok> T_UNIFORM
615 %token <tok> T_NONUNIFORM
616 %token <tok> T_IMM
617
618 %token <tok> T_NAN
619 %token <tok> T_INF
620 %token <num> T_A0
621 %token <num> T_A1
622 %token <num> T_P0
623 %token <num> T_W
624 %token <str> T_CAT1_TYPE_TYPE
625
626 %type <num> integer offset
627 %type <num> flut_immed
628 %type <flt> float
629 %type <reg> src dst const
630 %type <tok> cat1_opc
631 %type <tok> cat2_opc_1src cat2_opc_2src_cnd cat2_opc_2src
632 %type <tok> cat3_opc
633 %type <tok> cat4_opc
634 %type <tok> cat5_opc cat5_samp cat5_tex cat5_type
635 %type <type> type
636 %type <unum> const_val
637
638 %error-verbose
639
640 %start shader
641
642 %%
643
644 shader: { new_shader(); } headers instrs
645
646 headers:
647 | header headers
648
649 header: localsize_header
650 | const_header
651 | buf_header
652 | invocationid_header
653 | wgid_header
654 | numwg_header
655 | branchstack_header
656 | in_header
657 | out_header
658 | tex_header
659 | pvtmem_header
660
661 const_val: T_FLOAT { $$ = fui($1); }
662 | T_INT { $$ = $1; }
663 | '-' T_INT { $$ = -$2; }
664 | T_HEX { $$ = $1; }
665
666 localsize_header: T_A_LOCALSIZE const_val ',' const_val ',' const_val {
667 variant->local_size[0] = $2;
668 variant->local_size[1] = $4;
669 variant->local_size[2] = $6;
670 }
671
672 const_header: T_A_CONST '(' T_CONSTANT ')' const_val ',' const_val ',' const_val ',' const_val {
673 add_const($3, $5, $7, $9, $11);
674 }
675
676 buf_header_addr_reg:
677 '(' T_CONSTANT ')' {
678 assert(($2 & 0x1) == 0); /* half-reg not allowed */
679 unsigned reg = $2 >> 1;
680
681 info->buf_addr_regs[info->num_bufs - 1] = reg;
682 /* reserve space in immediates for the actual value to be plugged in later: */
683 add_const($2, 0, 0, 0, 0);
684 }
685 |
686
687 buf_header: T_A_BUF const_val {
688 int idx = info->num_bufs++;
689 assert(idx < MAX_BUFS);
690 info->buf_sizes[idx] = $2;
691 } buf_header_addr_reg
692
693 invocationid_header: T_A_INVOCATIONID '(' T_REGISTER ')' {
694 assert(($3 & 0x1) == 0); /* half-reg not allowed */
695 unsigned reg = $3 >> 1;
696 add_sysval(reg, 0x7, SYSTEM_VALUE_LOCAL_INVOCATION_ID);
697 }
698
699 wgid_header: T_A_WGID '(' T_REGISTER ')' {
700 assert(($3 & 0x1) == 0); /* half-reg not allowed */
701 unsigned reg = $3 >> 1;
702 assert(variant->shader->compiler->gen >= 5);
703 assert(reg >= regid(48, 0)); /* must be a high reg */
704 add_sysval(reg, 0x7, SYSTEM_VALUE_WORKGROUP_ID);
705 }
706 | T_A_WGID '(' T_CONSTANT ')' {
707 assert(($3 & 0x1) == 0); /* half-reg not allowed */
708 unsigned reg = $3 >> 1;
709 assert(variant->shader->compiler->gen < 5);
710 info->wgid = reg;
711 }
712
713 numwg_header: T_A_NUMWG '(' T_CONSTANT ')' {
714 assert(($3 & 0x1) == 0); /* half-reg not allowed */
715 unsigned reg = $3 >> 1;
716 info->numwg = reg;
717 /* reserve space in immediates for the actual value to be plugged in later: */
718 if (variant->shader->compiler->gen >= 5)
719 add_const($3, 0, 0, 0, 0);
720 }
721
722 branchstack_header: T_A_BRANCHSTACK const_val { variant->branchstack = $2; }
723
724 pvtmem_header: T_A_PVTMEM const_val { variant->pvtmem_size = $2; }
725
726 /* Stubs for now */
727 in_header: T_A_IN '(' T_REGISTER ')' T_IDENTIFIER '(' T_IDENTIFIER '=' integer ')' { }
728
729 out_header: T_A_OUT '(' T_REGISTER ')' T_IDENTIFIER '(' T_IDENTIFIER '=' integer ')' { }
730
731 tex_header: T_A_TEX '(' T_REGISTER ')'
732 T_IDENTIFIER '=' integer ',' /* src */
733 T_IDENTIFIER '=' integer ',' /* samp */
734 T_IDENTIFIER '=' integer ',' /* tex */
735 T_IDENTIFIER '=' integer ',' /* wrmask */
736 T_IDENTIFIER '=' integer /* cmd */ { }
737
738 iflag: T_SY { iflags.flags |= IR3_INSTR_SY; }
739 | T_SS { iflags.flags |= IR3_INSTR_SS; }
740 | T_JP { iflags.flags |= IR3_INSTR_JP; }
741 | T_SAT { iflags.flags |= IR3_INSTR_SAT; }
742 | T_RPT { iflags.repeat = $1; }
743 | T_UL { iflags.flags |= IR3_INSTR_UL; }
744 | T_NOP { iflags.nop = $1; }
745
746 iflags:
747 | iflag iflags
748
749 instrs: instr instrs
750 | instr
751
752 instr: iflags cat0_instr
753 | iflags cat1_instr
754 | iflags cat2_instr
755 | iflags cat3_instr
756 | iflags cat4_instr
757 | iflags cat5_instr { fixup_cat5_s2en(); }
758 | iflags cat6_instr
759 | iflags cat7_instr
760 | label
761
762 label: T_IDENTIFIER ':' { new_label($1); }
763
764 cat0_src1: '!' T_P0 { instr->cat0.inv1 = true; instr->cat0.comp1 = $2 >> 1; }
765 | T_P0 { instr->cat0.comp1 = $1 >> 1; }
766
767 cat0_src2: '!' T_P0 { instr->cat0.inv2 = true; instr->cat0.comp2 = $2 >> 1; }
768 | T_P0 { instr->cat0.comp2 = $1 >> 1; }
769
770 cat0_immed: '#' integer { instr->cat0.immed = $2; }
771 | '#' T_IDENTIFIER { ralloc_steal(instr, (void *)$2); instr->cat0.target_label = $2; }
772
773 cat0_instr: T_OP_NOP { new_instr(OPC_NOP); }
774 | T_OP_BR { new_instr(OPC_B)->cat0.brtype = BRANCH_PLAIN; } cat0_src1 ',' cat0_immed
775 | T_OP_BRAO { new_instr(OPC_B)->cat0.brtype = BRANCH_OR; } cat0_src1 ',' cat0_src2 ',' cat0_immed
776 | T_OP_BRAA { new_instr(OPC_B)->cat0.brtype = BRANCH_AND; } cat0_src1 ',' cat0_src2 ',' cat0_immed
777 | T_OP_BRAC '.' integer { new_instr(OPC_B)->cat0.brtype = BRANCH_CONST; instr->cat0.idx = $3; } cat0_immed
778 | T_OP_BANY { new_instr(OPC_B)->cat0.brtype = BRANCH_ANY; } cat0_src1 ',' cat0_immed
779 | T_OP_BALL { new_instr(OPC_B)->cat0.brtype = BRANCH_ALL; } cat0_src1 ',' cat0_immed
780 | T_OP_BRAX { new_instr(OPC_B)->cat0.brtype = BRANCH_X; } cat0_immed
781 | T_OP_JUMP { new_instr(OPC_JUMP); } cat0_immed
782 | T_OP_CALL { new_instr(OPC_CALL); } cat0_immed
783 | T_OP_RET { new_instr(OPC_RET); }
784 | T_OP_KILL { new_instr(OPC_KILL); } cat0_src1
785 | T_OP_END { new_instr(OPC_END); }
786 | T_OP_EMIT { new_instr(OPC_EMIT); }
787 | T_OP_CUT { new_instr(OPC_CUT); }
788 | T_OP_CHMASK { new_instr(OPC_CHMASK); }
789 | T_OP_CHSH { new_instr(OPC_CHSH); }
790 | T_OP_FLOW_REV { new_instr(OPC_FLOW_REV); }
791 | T_OP_BKT { new_instr(OPC_BKT); } cat0_immed
792 | T_OP_STKS { new_instr(OPC_STKS); }
793 | T_OP_STKR { new_instr(OPC_STKR); }
794 | T_OP_XSET { new_instr(OPC_XSET); }
795 | T_OP_XCLR { new_instr(OPC_XCLR); }
796 | T_OP_GETONE { new_instr(OPC_GETONE); } cat0_immed
797 | T_OP_DBG { new_instr(OPC_DBG); }
798 | T_OP_SHPS { new_instr(OPC_SHPS); } cat0_immed
799 | T_OP_SHPE { new_instr(OPC_SHPE); }
800 | T_OP_PREDT { new_instr(OPC_PREDT); } cat0_src1
801 | T_OP_PREDF { new_instr(OPC_PREDF); } cat0_src1
802 | T_OP_PREDE { new_instr(OPC_PREDE); }
803
804 cat1_opc: T_OP_MOV '.' T_CAT1_TYPE_TYPE {
805 parse_type_type(new_instr(OPC_MOV), $3);
806 }
807 | T_OP_COV '.' T_CAT1_TYPE_TYPE {
808 parse_type_type(new_instr(OPC_MOV), $3);
809 }
810
811 cat1_src: src_reg_or_const_or_rel
812 | immediate_cat1
813
814 cat1_movmsk: T_OP_MOVMSK '.' T_W {
815 new_instr(OPC_MOVMSK);
816 instr->cat1.src_type = TYPE_U32;
817 instr->cat1.dst_type = TYPE_U32;
818 instr->repeat = $3 - 1;
819 } dst_reg {
820 instr->dsts[0]->wrmask = (1 << $3) - 1;
821 }
822
823 cat1_mova1: T_OP_MOVA1 T_A1 ',' {
824 new_instr(OPC_MOV);
825 instr->cat1.src_type = TYPE_U16;
826 instr->cat1.dst_type = TYPE_U16;
827 new_dst((61 << 3) + 2, IR3_REG_HALF);
828 } cat1_src
829
830 cat1_mova: T_OP_MOVA T_A0 ',' {
831 new_instr(OPC_MOV);
832 instr->cat1.src_type = TYPE_S16;
833 instr->cat1.dst_type = TYPE_S16;
834 new_dst((61 << 3), IR3_REG_HALF);
835 } cat1_src
836
837 cat1_swz: T_OP_SWZ '.' T_CAT1_TYPE_TYPE { parse_type_type(new_instr(OPC_SWZ), $3); } dst_reg ',' dst_reg ',' src_reg ',' src_reg
838
839 cat1_gat: T_OP_GAT '.' T_CAT1_TYPE_TYPE { parse_type_type(new_instr(OPC_GAT), $3); } dst_reg ',' src_reg ',' src_reg ',' src_reg ',' src_reg
840
841 cat1_sct: T_OP_SCT '.' T_CAT1_TYPE_TYPE { parse_type_type(new_instr(OPC_SCT), $3); } dst_reg ',' dst_reg ',' dst_reg ',' dst_reg ',' src_reg
842
843 /* NOTE: cat1 can also *write* to relative gpr */
844 cat1_instr: cat1_movmsk
845 | cat1_mova1
846 | cat1_mova
847 | cat1_swz
848 | cat1_gat
849 | cat1_sct
850 | cat1_opc dst_reg ',' cat1_src
851 | cat1_opc relative_gpr_dst ',' cat1_src
852
853 cat2_opc_1src: T_OP_ABSNEG_F { new_instr(OPC_ABSNEG_F); }
854 | T_OP_ABSNEG_S { new_instr(OPC_ABSNEG_S); }
855 | T_OP_CLZ_B { new_instr(OPC_CLZ_B); }
856 | T_OP_CLZ_S { new_instr(OPC_CLZ_S); }
857 | T_OP_SIGN_F { new_instr(OPC_SIGN_F); }
858 | T_OP_FLOOR_F { new_instr(OPC_FLOOR_F); }
859 | T_OP_CEIL_F { new_instr(OPC_CEIL_F); }
860 | T_OP_RNDNE_F { new_instr(OPC_RNDNE_F); }
861 | T_OP_RNDAZ_F { new_instr(OPC_RNDAZ_F); }
862 | T_OP_TRUNC_F { new_instr(OPC_TRUNC_F); }
863 | T_OP_NOT_B { new_instr(OPC_NOT_B); }
864 | T_OP_BFREV_B { new_instr(OPC_BFREV_B); }
865 | T_OP_SETRM { new_instr(OPC_SETRM); }
866 | T_OP_CBITS_B { new_instr(OPC_CBITS_B); }
867
868 cat2_opc_2src_cnd: T_OP_CMPS_F { new_instr(OPC_CMPS_F); }
869 | T_OP_CMPS_U { new_instr(OPC_CMPS_U); }
870 | T_OP_CMPS_S { new_instr(OPC_CMPS_S); }
871 | T_OP_CMPV_F { new_instr(OPC_CMPV_F); }
872 | T_OP_CMPV_U { new_instr(OPC_CMPV_U); }
873 | T_OP_CMPV_S { new_instr(OPC_CMPV_S); }
874
875 cat2_opc_2src: T_OP_ADD_F { new_instr(OPC_ADD_F); }
876 | T_OP_MIN_F { new_instr(OPC_MIN_F); }
877 | T_OP_MAX_F { new_instr(OPC_MAX_F); }
878 | T_OP_MUL_F { new_instr(OPC_MUL_F); }
879 | T_OP_ADD_U { new_instr(OPC_ADD_U); }
880 | T_OP_ADD_S { new_instr(OPC_ADD_S); }
881 | T_OP_SUB_U { new_instr(OPC_SUB_U); }
882 | T_OP_SUB_S { new_instr(OPC_SUB_S); }
883 | T_OP_MIN_U { new_instr(OPC_MIN_U); }
884 | T_OP_MIN_S { new_instr(OPC_MIN_S); }
885 | T_OP_MAX_U { new_instr(OPC_MAX_U); }
886 | T_OP_MAX_S { new_instr(OPC_MAX_S); }
887 | T_OP_AND_B { new_instr(OPC_AND_B); }
888 | T_OP_OR_B { new_instr(OPC_OR_B); }
889 | T_OP_XOR_B { new_instr(OPC_XOR_B); }
890 | T_OP_MUL_U24 { new_instr(OPC_MUL_U24); }
891 | T_OP_MUL_S24 { new_instr(OPC_MUL_S24); }
892 | T_OP_MULL_U { new_instr(OPC_MULL_U); }
893 | T_OP_SHL_B { new_instr(OPC_SHL_B); }
894 | T_OP_SHR_B { new_instr(OPC_SHR_B); }
895 | T_OP_ASHR_B { new_instr(OPC_ASHR_B); }
896 | T_OP_BARY_F { new_instr(OPC_BARY_F); }
897 | T_OP_MGEN_B { new_instr(OPC_MGEN_B); }
898 | T_OP_GETBIT_B { new_instr(OPC_GETBIT_B); }
899 | T_OP_SHB { new_instr(OPC_SHB); }
900 | T_OP_MSAD { new_instr(OPC_MSAD); }
901
902 cond: T_LT { instr->cat2.condition = IR3_COND_LT; }
903 | T_LE { instr->cat2.condition = IR3_COND_LE; }
904 | T_GT { instr->cat2.condition = IR3_COND_GT; }
905 | T_GE { instr->cat2.condition = IR3_COND_GE; }
906 | T_EQ { instr->cat2.condition = IR3_COND_EQ; }
907 | T_NE { instr->cat2.condition = IR3_COND_NE; }
908
909 cat2_instr: cat2_opc_1src dst_reg ',' src_reg_or_const_or_rel_or_imm
910 | cat2_opc_2src_cnd '.' cond dst_reg ',' src_reg_or_const_or_rel_or_imm ',' src_reg_or_const_or_rel_or_imm
911 | cat2_opc_2src dst_reg ',' src_reg_or_const_or_rel_or_imm ',' src_reg_or_const_or_rel_or_imm
912
913 cat3_opc: T_OP_MAD_U16 { new_instr(OPC_MAD_U16); }
914 | T_OP_MADSH_U16 { new_instr(OPC_MADSH_U16); }
915 | T_OP_MAD_S16 { new_instr(OPC_MAD_S16); }
916 | T_OP_MADSH_M16 { new_instr(OPC_MADSH_M16); }
917 | T_OP_MAD_U24 { new_instr(OPC_MAD_U24); }
918 | T_OP_MAD_S24 { new_instr(OPC_MAD_S24); }
919 | T_OP_MAD_F16 { new_instr(OPC_MAD_F16); }
920 | T_OP_MAD_F32 { new_instr(OPC_MAD_F32); }
921 | T_OP_SEL_B16 { new_instr(OPC_SEL_B16); }
922 | T_OP_SEL_B32 { new_instr(OPC_SEL_B32); }
923 | T_OP_SEL_S16 { new_instr(OPC_SEL_S16); }
924 | T_OP_SEL_S32 { new_instr(OPC_SEL_S32); }
925 | T_OP_SEL_F16 { new_instr(OPC_SEL_F16); }
926 | T_OP_SEL_F32 { new_instr(OPC_SEL_F32); }
927 | T_OP_SAD_S16 { new_instr(OPC_SAD_S16); }
928 | T_OP_SAD_S32 { new_instr(OPC_SAD_S32); }
929
930 cat3_instr: cat3_opc dst_reg ',' src_reg_or_const_or_rel ',' src_reg_or_const ',' src_reg_or_const_or_rel
931 | T_OP_SHLG_B16 { new_instr(OPC_SHLG_B16); } dst_reg ',' src_reg_or_rel_or_imm ',' src_reg_or_const ',' src_reg_or_rel_or_imm
932
933 cat4_opc: T_OP_RCP { new_instr(OPC_RCP); }
934 | T_OP_RSQ { new_instr(OPC_RSQ); }
935 | T_OP_LOG2 { new_instr(OPC_LOG2); }
936 | T_OP_EXP2 { new_instr(OPC_EXP2); }
937 | T_OP_SIN { new_instr(OPC_SIN); }
938 | T_OP_COS { new_instr(OPC_COS); }
939 | T_OP_SQRT { new_instr(OPC_SQRT); }
940 | T_OP_HRSQ { new_instr(OPC_HRSQ); }
941 | T_OP_HLOG2 { new_instr(OPC_HLOG2); }
942 | T_OP_HEXP2 { new_instr(OPC_HEXP2); }
943
944 cat4_instr: cat4_opc dst_reg ',' src_reg_or_const_or_rel_or_imm
945
946 cat5_opc_dsxypp: T_OP_DSXPP_1 { new_instr(OPC_DSXPP_1)->cat5.type = TYPE_F32; }
947 | T_OP_DSYPP_1 { new_instr(OPC_DSYPP_1)->cat5.type = TYPE_F32; }
948
949 cat5_opc: T_OP_ISAM { new_instr(OPC_ISAM); }
950 | T_OP_ISAML { new_instr(OPC_ISAML); }
951 | T_OP_ISAMM { new_instr(OPC_ISAMM); }
952 | T_OP_SAM { new_instr(OPC_SAM); }
953 | T_OP_SAMB { new_instr(OPC_SAMB); }
954 | T_OP_SAML { new_instr(OPC_SAML); }
955 | T_OP_SAMGQ { new_instr(OPC_SAMGQ); }
956 | T_OP_GETLOD { new_instr(OPC_GETLOD); }
957 | T_OP_CONV { new_instr(OPC_CONV); }
958 | T_OP_CONVM { new_instr(OPC_CONVM); }
959 | T_OP_GETSIZE { new_instr(OPC_GETSIZE); }
960 | T_OP_GETBUF { new_instr(OPC_GETBUF); }
961 | T_OP_GETPOS { new_instr(OPC_GETPOS); }
962 | T_OP_GETINFO { new_instr(OPC_GETINFO); }
963 | T_OP_DSX { new_instr(OPC_DSX); }
964 | T_OP_DSY { new_instr(OPC_DSY); }
965 | T_OP_GATHER4R { new_instr(OPC_GATHER4R); }
966 | T_OP_GATHER4G { new_instr(OPC_GATHER4G); }
967 | T_OP_GATHER4B { new_instr(OPC_GATHER4B); }
968 | T_OP_GATHER4A { new_instr(OPC_GATHER4A); }
969 | T_OP_SAMGP0 { new_instr(OPC_SAMGP0); }
970 | T_OP_SAMGP1 { new_instr(OPC_SAMGP1); }
971 | T_OP_SAMGP2 { new_instr(OPC_SAMGP2); }
972 | T_OP_SAMGP3 { new_instr(OPC_SAMGP3); }
973 | T_OP_RGETPOS { new_instr(OPC_RGETPOS); }
974 | T_OP_RGETINFO { new_instr(OPC_RGETINFO); }
975
976 cat5_flag: '.' T_3D { instr->flags |= IR3_INSTR_3D; }
977 | '.' 'a' { instr->flags |= IR3_INSTR_A; }
978 | '.' 'o' { instr->flags |= IR3_INSTR_O; }
979 | '.' 'p' { instr->flags |= IR3_INSTR_P; }
980 | '.' 's' { instr->flags |= IR3_INSTR_S; }
981 | '.' T_S2EN { instr->flags |= IR3_INSTR_S2EN; }
982 | '.' T_NONUNIFORM { instr->flags |= IR3_INSTR_NONUNIF; }
983 | '.' T_BASE { instr->flags |= IR3_INSTR_B; instr->cat5.tex_base = $2; }
984 cat5_flags:
985 | cat5_flag cat5_flags
986
987 cat5_samp: T_SAMP { instr->cat5.samp = $1; }
988 cat5_tex: T_TEX { if (instr->flags & IR3_INSTR_B) instr->cat5.samp |= ($1 << 4); else instr->cat5.tex = $1; }
989 cat5_type: '(' type ')' { instr->cat5.type = $2; }
990 cat5_a1: src_reg { instr->flags |= IR3_INSTR_A1EN; }
991
992 cat5_instr: cat5_opc_dsxypp cat5_flags dst_reg ',' src_reg
993 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg ',' src_reg
994 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg ',' cat5_samp ',' cat5_tex
995 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg ',' cat5_samp
996 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg ',' cat5_tex
997 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg
998 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' cat5_samp ',' cat5_tex
999 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' cat5_samp ',' cat5_a1
1000 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' cat5_samp
1001 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' cat5_tex
1002 | cat5_opc cat5_flags cat5_type dst_reg ',' src_reg
1003 | cat5_opc cat5_flags cat5_type dst_reg ',' cat5_samp ',' cat5_tex
1004 | cat5_opc cat5_flags cat5_type dst_reg ',' cat5_samp
1005 | cat5_opc cat5_flags cat5_type dst_reg ',' cat5_tex
1006 | cat5_opc cat5_flags cat5_type dst_reg
1007
1008 cat6_typed: '.' T_UNTYPED { instr->cat6.typed = 0; }
1009 | '.' T_TYPED { instr->cat6.typed = 1; }
1010
1011 cat6_dim: '.' T_1D { instr->cat6.d = 1; }
1012 | '.' T_2D { instr->cat6.d = 2; }
1013 | '.' T_3D { instr->cat6.d = 3; }
1014 | '.' T_4D { instr->cat6.d = 4; }
1015
1016 cat6_type: '.' type { instr->cat6.type = $2; }
1017 cat6_imm_offset: offset { new_src(0, IR3_REG_IMMED)->iim_val = $1; }
1018 cat6_offset: cat6_imm_offset
1019 | '+' src
1020 cat6_dst_offset: offset { instr->cat6.dst_offset = $1; }
1021 | '+' src { instr->flags |= IR3_INSTR_G; }
1022
1023 cat6_immed: integer { instr->cat6.iim_val = $1; }
1024
1025 cat6_stg_ldg_a6xx_offset:
1026 '+' '(' src offset ')' '<' '<' integer {
1027 assert($8 == 2);
1028 new_src(0, IR3_REG_IMMED)->uim_val = 0;
1029 new_src(0, IR3_REG_IMMED)->uim_val = $4;
1030 }
1031 | '+' src '<' '<' integer offset '<' '<' integer {
1032 assert($9 == 2);
1033 new_src(0, IR3_REG_IMMED)->uim_val = $5 - 2;
1034 new_src(0, IR3_REG_IMMED)->uim_val = $6;
1035 }
1036
1037 cat6_load: T_OP_LDG { new_instr(OPC_LDG); } cat6_type dst_reg ',' 'g' '[' src cat6_offset ']' ',' immediate
1038 | T_OP_LDG_A { new_instr(OPC_LDG_A); } cat6_type dst_reg ',' 'g' '[' src cat6_stg_ldg_a6xx_offset ']' ',' immediate
1039 | T_OP_LDP { new_instr(OPC_LDP); } cat6_type dst_reg ',' 'p' '[' src cat6_offset ']' ',' immediate
1040 | T_OP_LDL { new_instr(OPC_LDL); } cat6_type dst_reg ',' 'l' '[' src cat6_offset ']' ',' immediate
1041 | T_OP_LDLW { new_instr(OPC_LDLW); } cat6_type dst_reg ',' 'l' '[' src cat6_offset ']' ',' immediate
1042 | T_OP_LDLV { new_instr(OPC_LDLV); } cat6_type dst_reg ',' 'l' '[' integer ']' {
1043 new_src(0, IR3_REG_IMMED)->iim_val = $8;
1044 } ',' immediate
1045
1046 cat6_store: T_OP_STG { new_instr(OPC_STG); dummy_dst(); } cat6_type 'g' '[' src cat6_imm_offset ']' ',' src ',' immediate
1047 | T_OP_STG_A { new_instr(OPC_STG_A); dummy_dst(); } cat6_type 'g' '[' src cat6_stg_ldg_a6xx_offset ']' ',' src ',' immediate
1048 | T_OP_STP { new_instr(OPC_STP); dummy_dst(); } cat6_type 'p' '[' src cat6_dst_offset ']' ',' src ',' immediate
1049 | T_OP_STL { new_instr(OPC_STL); dummy_dst(); } cat6_type 'l' '[' src cat6_dst_offset ']' ',' src ',' immediate
1050 | T_OP_STLW { new_instr(OPC_STLW); dummy_dst(); } cat6_type 'l' '[' src cat6_dst_offset ']' ',' src ',' immediate
1051
1052 cat6_loadib: T_OP_LDIB { new_instr(OPC_LDIB); } cat6_typed cat6_dim cat6_type '.' cat6_immed dst_reg ',' 'g' '[' immediate ']' ',' src ',' src
1053 cat6_storeib: T_OP_STIB { new_instr(OPC_STIB); dummy_dst(); } cat6_typed cat6_dim cat6_type '.' cat6_immed'g' '[' immediate ']' ',' src ',' src ',' src
1054
1055 cat6_prefetch: T_OP_PREFETCH { new_instr(OPC_PREFETCH); new_dst(0,0); /* dummy dst */ } 'g' '[' src cat6_offset ']' ',' cat6_immed
1056
1057 cat6_atomic_opc: T_OP_ATOMIC_ADD { new_instr(OPC_ATOMIC_ADD); }
1058 | T_OP_ATOMIC_SUB { new_instr(OPC_ATOMIC_SUB); }
1059 | T_OP_ATOMIC_XCHG { new_instr(OPC_ATOMIC_XCHG); }
1060 | T_OP_ATOMIC_INC { new_instr(OPC_ATOMIC_INC); }
1061 | T_OP_ATOMIC_DEC { new_instr(OPC_ATOMIC_DEC); }
1062 | T_OP_ATOMIC_CMPXCHG { new_instr(OPC_ATOMIC_CMPXCHG); }
1063 | T_OP_ATOMIC_MIN { new_instr(OPC_ATOMIC_MIN); }
1064 | T_OP_ATOMIC_MAX { new_instr(OPC_ATOMIC_MAX); }
1065 | T_OP_ATOMIC_AND { new_instr(OPC_ATOMIC_AND); }
1066 | T_OP_ATOMIC_OR { new_instr(OPC_ATOMIC_OR); }
1067 | T_OP_ATOMIC_XOR { new_instr(OPC_ATOMIC_XOR); }
1068
1069 cat6_atomic_g: cat6_atomic_opc cat6_typed cat6_dim cat6_type '.' cat6_immed '.' 'g' dst_reg ',' 'g' '[' cat6_reg_or_immed ']' ',' src ',' src ',' src {
1070 instr->flags |= IR3_INSTR_G;
1071 }
1072
1073 cat6_atomic_l: cat6_atomic_opc cat6_typed cat6_dim cat6_type '.' cat6_immed '.' 'l' dst_reg ',' 'l' '[' cat6_reg_or_immed ']' ',' src
1074
1075 cat6_atomic: cat6_atomic_g
1076 | cat6_atomic_l
1077
1078 cat6_ibo_opc_1src: T_OP_RESINFO { new_instr(OPC_RESINFO); }
1079
1080 cat6_ibo_opc_ldgb: T_OP_LDGB { new_instr(OPC_LDGB); }
1081 cat6_ibo_opc_stgb: T_OP_STGB { new_instr(OPC_STGB); }
1082
1083 cat6_ibo: cat6_ibo_opc_1src cat6_type cat6_dim dst_reg ',' 'g' '[' cat6_reg_or_immed ']'
1084 | cat6_ibo_opc_ldgb cat6_typed cat6_dim cat6_type '.' cat6_immed dst_reg ',' 'g' '[' cat6_reg_or_immed ']' ',' src ',' src
1085 | cat6_ibo_opc_stgb cat6_typed cat6_dim cat6_type '.' cat6_immed { dummy_dst(); } 'g' '[' cat6_reg_or_immed ']' ',' src ',' cat6_reg_or_immed ',' src
1086
1087 cat6_id_opc:
1088 T_OP_GETSPID { new_instr(OPC_GETSPID); }
1089 | T_OP_GETWID { new_instr(OPC_GETWID); }
1090
1091 cat6_id: cat6_id_opc cat6_type dst_reg
1092
1093 cat6_bindless_base:
1094 | '.' T_BASE { instr->flags |= IR3_INSTR_B; instr->cat6.base = $2; }
1095
1096 cat6_bindless_mode: T_IMM cat6_bindless_base
1097 | T_UNIFORM cat6_bindless_base
1098 | T_NONUNIFORM cat6_bindless_base { instr->flags |= IR3_INSTR_NONUNIF; }
1099
1100 cat6_reg_or_immed: src
1101 | integer { new_src(0, IR3_REG_IMMED)->iim_val = $1; }
1102
1103 cat6_bindless_ibo_opc_1src: T_OP_RESINFO_B { new_instr(OPC_RESINFO); }
1104
1105 cat6_bindless_ibo_opc_2src: T_OP_ATOMIC_B_ADD { new_instr(OPC_ATOMIC_ADD)->flags |= IR3_INSTR_G; dummy_dst(); }
1106 | T_OP_ATOMIC_B_SUB { new_instr(OPC_ATOMIC_SUB)->flags |= IR3_INSTR_G; dummy_dst(); }
1107 | T_OP_ATOMIC_B_XCHG { new_instr(OPC_ATOMIC_XCHG)->flags |= IR3_INSTR_G; dummy_dst(); }
1108 | T_OP_ATOMIC_B_INC { new_instr(OPC_ATOMIC_INC)->flags |= IR3_INSTR_G; dummy_dst(); }
1109 | T_OP_ATOMIC_B_DEC { new_instr(OPC_ATOMIC_DEC)->flags |= IR3_INSTR_G; dummy_dst(); }
1110 | T_OP_ATOMIC_B_CMPXCHG { new_instr(OPC_ATOMIC_CMPXCHG)->flags |= IR3_INSTR_G; dummy_dst(); }
1111 | T_OP_ATOMIC_B_MIN { new_instr(OPC_ATOMIC_MIN)->flags |= IR3_INSTR_G; dummy_dst(); }
1112 | T_OP_ATOMIC_B_MAX { new_instr(OPC_ATOMIC_MAX)->flags |= IR3_INSTR_G; dummy_dst(); }
1113 | T_OP_ATOMIC_B_AND { new_instr(OPC_ATOMIC_AND)->flags |= IR3_INSTR_G; dummy_dst(); }
1114 | T_OP_ATOMIC_B_OR { new_instr(OPC_ATOMIC_OR)->flags |= IR3_INSTR_G; dummy_dst(); }
1115 | T_OP_ATOMIC_B_XOR { new_instr(OPC_ATOMIC_XOR)->flags |= IR3_INSTR_G; dummy_dst(); }
1116 | T_OP_STIB_B { new_instr(OPC_STIB); dummy_dst(); }
1117
1118 cat6_bindless_ibo_opc_2src_dst: T_OP_LDIB_B { new_instr(OPC_LDIB); }
1119
1120 cat6_bindless_ibo: cat6_bindless_ibo_opc_1src cat6_typed cat6_dim cat6_type '.' cat6_immed '.' cat6_bindless_mode dst_reg ',' cat6_reg_or_immed
1121 | cat6_bindless_ibo_opc_2src cat6_typed cat6_dim cat6_type '.' cat6_immed '.' cat6_bindless_mode src_reg ',' cat6_reg_or_immed ',' cat6_reg_or_immed { swap(instr->srcs[0], instr->srcs[2]); }
1122 | cat6_bindless_ibo_opc_2src_dst cat6_typed cat6_dim cat6_type '.' cat6_immed '.' cat6_bindless_mode dst_reg ',' cat6_reg_or_immed ',' cat6_reg_or_immed { swap(instr->srcs[0], instr->srcs[1]); }
1123
1124 cat6_bindless_ldc_opc: T_OP_LDC { new_instr(OPC_LDC); }
1125
1126 cat6_bindless_ldc: cat6_bindless_ldc_opc '.' T_OFFSET '.' cat6_immed '.' cat6_bindless_mode dst_reg ',' cat6_reg_or_immed ',' cat6_reg_or_immed {
1127 instr->cat6.d = $3;
1128 instr->cat6.type = TYPE_U32;
1129 /* TODO cleanup ir3 src order: */
1130 swap(instr->srcs[0], instr->srcs[1]);
1131 }
1132
1133 cat6_todo: T_OP_G2L { new_instr(OPC_G2L); }
1134 | T_OP_L2G { new_instr(OPC_L2G); }
1135 | T_OP_RESFMT { new_instr(OPC_RESFMT); }
1136
1137 cat6_instr: cat6_load
1138 | cat6_loadib
1139 | cat6_store
1140 | cat6_storeib
1141 | cat6_prefetch
1142 | cat6_atomic
1143 | cat6_ibo
1144 | cat6_id
1145 | cat6_bindless_ldc
1146 | cat6_bindless_ibo
1147 | cat6_todo
1148
1149 cat7_scope: '.' 'w' { instr->cat7.w = true; }
1150 | '.' 'r' { instr->cat7.r = true; }
1151 | '.' 'l' { instr->cat7.l = true; }
1152 | '.' 'g' { instr->cat7.g = true; }
1153
1154 cat7_scopes:
1155 | cat7_scope cat7_scopes
1156
1157 cat7_barrier: T_OP_BAR { new_instr(OPC_BAR); } cat7_scopes
1158 | T_OP_FENCE { new_instr(OPC_FENCE); } cat7_scopes
1159
1160 cat7_instr: cat7_barrier
1161
1162 src: T_REGISTER { $$ = new_src($1, 0); }
1163 | T_A0 { $$ = new_src((61 << 3), IR3_REG_HALF); }
1164 | T_A1 { $$ = new_src((61 << 3) + 1, IR3_REG_HALF); }
1165 | T_P0 { $$ = new_src((62 << 3) + $1, 0); }
1166
1167 dst: T_REGISTER { $$ = new_dst($1, 0); }
1168 | T_A0 { $$ = new_dst((61 << 3), IR3_REG_HALF); }
1169 | T_A1 { $$ = new_dst((61 << 3) + 1, IR3_REG_HALF); }
1170 | T_P0 { $$ = new_dst((62 << 3) + $1, 0); }
1171
1172 const: T_CONSTANT { $$ = new_src($1, IR3_REG_CONST); }
1173
1174 dst_reg_flag: T_EVEN { instr->cat1.round = ROUND_EVEN; }
1175 | T_POS_INFINITY { instr->cat1.round = ROUND_POS_INF; }
1176 | T_NEG_INFINITY { instr->cat1.round = ROUND_NEG_INF; }
1177 | T_EI { rflags.flags |= IR3_REG_EI; }
1178 | T_WRMASK { rflags.wrmask = $1; }
1179
1180 dst_reg_flags: dst_reg_flag
1181 | dst_reg_flag dst_reg_flags
1182
1183 /* note: destination registers are always incremented in repeat */
1184 dst_reg: dst { $1->flags |= IR3_REG_R; }
1185 | dst_reg_flags dst { $2->flags |= IR3_REG_R; }
1186
1187 src_reg_flag: T_ABSNEG { rflags.flags |= IR3_REG_ABS|IR3_REG_NEGATE; }
1188 | T_NEG { rflags.flags |= IR3_REG_NEGATE; }
1189 | T_ABS { rflags.flags |= IR3_REG_ABS; }
1190 | T_R { rflags.flags |= IR3_REG_R; }
1191
1192 src_reg_flags: src_reg_flag
1193 | src_reg_flag src_reg_flags
1194
1195 src_reg: src
1196 | src_reg_flags src
1197
1198 src_const: const
1199 | src_reg_flags const
1200
1201 src_reg_or_const: src_reg
1202 | src_const
1203
1204 src_reg_or_const_or_rel: src_reg_or_const
1205 | relative
1206 | src_reg_flags relative
1207
1208 src_reg_or_const_or_rel_or_imm: src_reg_or_const_or_rel
1209 | src_reg_flags immediate
1210 | immediate
1211
1212 src_reg_or_rel_or_imm: src_reg
1213 | relative
1214 | immediate
1215
1216 offset: { $$ = 0; }
1217 | '+' integer { $$ = $2; }
1218 | '-' integer { $$ = -$2; }
1219
1220 relative_gpr_src: 'r' '<' T_A0 offset '>' { new_src(0, IR3_REG_RELATIV)->array.offset = $4; }
1221 | T_HR '<' T_A0 offset '>' { new_src(0, IR3_REG_RELATIV | IR3_REG_HALF)->array.offset = $4; }
1222
1223 relative_gpr_dst: 'r' '<' T_A0 offset '>' { new_dst(0, IR3_REG_RELATIV)->array.offset = $4; }
1224 | T_HR '<' T_A0 offset '>' { new_dst(0, IR3_REG_RELATIV | IR3_REG_HALF)->array.offset = $4; }
1225
1226 relative_const: 'c' '<' T_A0 offset '>' { new_src(0, IR3_REG_RELATIV | IR3_REG_CONST)->array.offset = $4; }
1227 | T_HC '<' T_A0 offset '>' { new_src(0, IR3_REG_RELATIV | IR3_REG_CONST | IR3_REG_HALF)->array.offset = $4; }
1228
1229 relative: relative_gpr_src
1230 | relative_const
1231
1232 /* cat1 immediates differ slighly in the floating point case from the cat2
1233 * case which can only encode certain predefined values (ie. and index into
1234 * the FLUT table)
1235 */
1236 immediate_cat1: integer { new_src(0, IR3_REG_IMMED)->iim_val = type_size(instr->cat1.src_type) < 32 ? $1 & 0xffff : $1; }
1237 | '(' integer ')' { new_src(0, IR3_REG_IMMED)->fim_val = $2; }
1238 | '(' float ')' { new_src(0, IR3_REG_IMMED)->fim_val = $2; }
1239 | 'h' '(' integer ')' { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->iim_val = $3 & 0xffff; }
1240 | 'h' '(' float ')' { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = _mesa_float_to_half($3); }
1241 | '(' T_NAN ')' { new_src(0, IR3_REG_IMMED)->fim_val = NAN; }
1242 | '(' T_INF ')' { new_src(0, IR3_REG_IMMED)->fim_val = INFINITY; }
1243
1244 immediate: integer { new_src(0, IR3_REG_IMMED)->iim_val = $1; }
1245 | '(' integer ')' { new_src(0, IR3_REG_IMMED)->fim_val = $2; }
1246 | flut_immed { new_src(0, IR3_REG_IMMED)->uim_val = $1; }
1247 | 'h' '(' integer ')' { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->iim_val = $3; }
1248 | 'h' flut_immed { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = $2; }
1249
1250 /* Float LUT values accepted as immed: */
1251 flut_immed: T_FLUT_0_0
1252 | T_FLUT_0_5
1253 | T_FLUT_1_0
1254 | T_FLUT_2_0
1255 | T_FLUT_E
1256 | T_FLUT_PI
1257 | T_FLUT_INV_PI
1258 | T_FLUT_INV_LOG2_E
1259 | T_FLUT_LOG2_E
1260 | T_FLUT_INV_LOG2_10
1261 | T_FLUT_LOG2_10
1262 | T_FLUT_4_0
1263
1264 integer: T_INT { $$ = $1; }
1265 | '-' T_INT { $$ = -$2; }
1266 | T_HEX { $$ = $1; }
1267 | '-' T_HEX { $$ = -$2; }
1268
1269 float: T_FLOAT { $$ = $1; }
1270 | '-' T_FLOAT { $$ = -$2; }
1271
1272 type: T_TYPE_F16 { $$ = TYPE_F16; }
1273 | T_TYPE_F32 { $$ = TYPE_F32; }
1274 | T_TYPE_U16 { $$ = TYPE_U16; }
1275 | T_TYPE_U32 { $$ = TYPE_U32; }
1276 | T_TYPE_S16 { $$ = TYPE_S16; }
1277 | T_TYPE_S32 { $$ = TYPE_S32; }
1278 | T_TYPE_U8 { $$ = TYPE_U8; }
1279 | T_TYPE_S8 { $$ = TYPE_S8; }
1280