src/freedreno/ir3/ir3_parser.y

   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
  27 struct ir3 * ir3_parse(struct ir3_shader_variant *v,
  28                 struct ir3_kernel_info *k, FILE *f);
  29 }
  30
  31 %{
  32 #define YYDEBUG 0
  33
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #include <math.h>
  38
  39 #include "util/u_math.h"
  40
  41 #include "ir3/ir3.h"
  42 #include "ir3/ir3_shader.h"
  43 #include "ir3/instr-a3xx.h"
  44
  45 #include "ir3_parser.h"
  46
  47 /* ir3 treats the abs/neg flags as separate flags for float vs integer,
  48  * but in the instruction encoding they are the same thing.  Tracking
  49  * them separately is only for the benefit of ir3 opt passes, and not
  50  * required here, so just use the float versions:
  51  */
  52 #define IR3_REG_ABS     IR3_REG_FABS
  53 #define IR3_REG_NEGATE  IR3_REG_FNEG
  54
  55 static struct ir3_kernel_info    *info;
  56 static struct ir3_shader_variant *variant;
  57 /* NOTE the assembler doesn't really use the ir3_block construction
  58  * like the compiler does.  Everything is treated as one large block.
  59  * Which might happen to contain flow control.  But since we don't
  60  * use any of the ir3 backend passes (sched, RA, etc) this doesn't
  61  * really matter.
  62  */
  63 static struct ir3_block          *block;   /* current shader block */
  64 static struct ir3_instruction    *instr;   /* current instruction */
  65
  66 static struct {
  67         unsigned flags;
  68         unsigned repeat;
  69         unsigned nop;
  70 } iflags;
  71
  72 static struct {
  73         unsigned flags;
  74         unsigned wrmask;
  75 } rflags;
  76
  77 int ir3_yyget_lineno(void);
  78
  79 static struct ir3_instruction * new_instr(opc_t opc)
  80 {
  81         instr = ir3_instr_create(block, opc);
  82         instr->flags = iflags.flags;
  83         instr->repeat = iflags.repeat;
  84         instr->nop = iflags.nop;
  85         instr->line = ir3_yyget_lineno();
  86         iflags.flags = iflags.repeat = iflags.nop = 0;
  87         return instr;
  88 }
  89
  90 static void new_shader(void)
  91 {
  92         variant->ir = ir3_create(variant->shader->compiler, variant);
  93         block = ir3_block_create(variant->ir);
  94         list_addtail(&block->node, &variant->ir->block_list);
  95 }
  96
  97 static type_t parse_type(const char **type)
  98 {
  99         if (!strncmp("f16", *type, 3)) {
 100                 *type += 3;
 101                 return TYPE_F16;
 102         } else if (!strncmp("f32", *type, 3)) {
 103                 *type += 3;
 104                 return TYPE_F32;
 105         } else if (!strncmp("u16", *type, 3)) {
 106                 *type += 3;
 107                 return TYPE_U16;
 108         } else if (!strncmp("u32", *type, 3)) {
 109                 *type += 3;
 110                 return TYPE_U32;
 111         } else if (!strncmp("s16", *type, 3)) {
 112                 *type += 3;
 113                 return TYPE_S16;
 114         } else if (!strncmp("s32", *type, 3)) {
 115                 *type += 3;
 116                 return TYPE_S32;
 117         } else if (!strncmp("u8", *type, 2)) {
 118                 *type += 2;
 119                 return TYPE_U8;
 120         } else if (!strncmp("s8", *type, 2)) {
 121                 *type += 2;
 122                 return TYPE_S8;
 123         } else {
 124                 assert(0);  /* shouldn't get here */
 125                 return ~0;
 126         }
 127 }
 128
 129 static struct ir3_instruction * parse_type_type(struct ir3_instruction *instr,
 130                 const char *type_type)
 131 {
 132         instr->cat1.src_type = parse_type(&type_type);
 133         instr->cat1.dst_type = parse_type(&type_type);
 134         return instr;
 135 }
 136
 137 static struct ir3_register * new_reg(int num, unsigned flags)
 138 {
 139         struct ir3_register *reg;
 140         flags |= rflags.flags;
 141         if (num & 0x1)
 142                 flags |= IR3_REG_HALF;
 143         reg = ir3_reg_create(instr, num>>1, flags);
 144         reg->wrmask = MAX2(1, rflags.wrmask);
 145         rflags.flags = rflags.wrmask = 0;
 146         return reg;
 147 }
 148
 149 static struct ir3_register * dummy_dst(void)
 150 {
 151         return new_reg(0, 0);
 152 }
 153
 154 static void add_const(unsigned reg, unsigned c0, unsigned c1, unsigned c2, unsigned c3)
 155 {
 156         struct ir3_const_state *const_state = ir3_const_state(variant);
 157         assert((reg & 0x7) == 0);
 158         int idx = reg >> (1 + 2); /* low bit is half vs full, next two bits are swiz */
 159         if (const_state->immediate_idx == const_state->immediates_size * 4) {
 160                 const_state->immediates = rerzalloc(const_state,
 161                                 const_state->immediates,
 162                                 __typeof__(const_state->immediates[0]),
 163                                 const_state->immediates_size,
 164                                 const_state->immediates_size + 4);
 165                 const_state->immediates_size += 4;
 166         }
 167         const_state->immediates[idx].val[0] = c0;
 168         const_state->immediates[idx].val[1] = c1;
 169         const_state->immediates[idx].val[2] = c2;
 170         const_state->immediates[idx].val[3] = c3;
 171         const_state->immediates_count = idx + 1;
 172         const_state->immediate_idx++;
 173 }
 174
 175 static void add_sysval(unsigned reg, unsigned compmask, gl_system_value sysval)
 176 {
 177         unsigned n = variant->inputs_count++;
 178         variant->inputs[n].regid = reg;
 179         variant->inputs[n].sysval = true;
 180         variant->inputs[n].slot = sysval;
 181         variant->inputs[n].compmask = compmask;
 182         variant->inputs[n].interpolate = INTERP_MODE_FLAT;
 183         variant->total_in++;
 184 }
 185
 186 #ifdef YYDEBUG
 187 int yydebug;
 188 #endif
 189
 190 extern int yylex(void);
 191 extern FILE *ir3_yyin;
 192 void ir3_yyset_lineno(int _line_number);
 193
 194 int yyparse(void);
 195
 196 static void yyerror(const char *error)
 197 {
 198         fprintf(stderr, "error at line %d: %s\n", ir3_yyget_lineno(), error);
 199 }
 200
 201 struct ir3 * ir3_parse(struct ir3_shader_variant *v,
 202                 struct ir3_kernel_info *k, FILE *f)
 203 {
 204         ir3_yyset_lineno(1);
 205         ir3_yyin = f;
 206 #ifdef YYDEBUG
 207         yydebug = 1;
 208 #endif
 209         info = k;
 210         variant = v;
 211         if (yyparse()) {
 212                 ir3_destroy(variant->ir);
 213                 variant->ir = NULL;
 214         }
 215         return variant->ir;
 216 }
 217 %}
 218
 219 %union {
 220         int tok;
 221         int num;
 222         uint32_t unum;
 223         double flt;
 224         const char *str;
 225         struct ir3_register *reg;
 226         struct {
 227                 int start;
 228                 int num;
 229         } range;
 230         type_t type;
 231 }
 232
 233 %{
 234 #if YYDEBUG
 235 static void print_token(FILE *file, int type, YYSTYPE value)
 236 {
 237         fprintf(file, "\ntype: %d\n", type);
 238 }
 239
 240 #define YYPRINT(file, type, value) print_token(file, type, value)
 241 #endif
 242 %}
 243
 244 %token <num> T_INT
 245 %token <unum> T_HEX
 246 %token <flt> T_FLOAT
 247 %token <str> T_IDENTIFIER
 248 %token <num> T_REGISTER
 249 %token <num> T_CONSTANT
 250
 251 /* @ headers (@const/@sampler/@uniform/@varying) */
 252 %token <tok> T_A_LOCALSIZE
 253 %token <tok> T_A_CONST
 254 %token <tok> T_A_BUF
 255 %token <tok> T_A_INVOCATIONID
 256 %token <tok> T_A_WGID
 257 %token <tok> T_A_NUMWG
 258 %token <tok> T_A_IN
 259 %token <tok> T_A_OUT
 260 %token <tok> T_A_TEX
 261 /* todo, re-add @sampler/@uniform/@varying if needed someday */
 262
 263 /* src register flags */
 264 %token <tok> T_ABSNEG
 265 %token <tok> T_NEG
 266 %token <tok> T_ABS
 267 %token <tok> T_R
 268
 269 %token <tok> T_HR
 270 %token <tok> T_HC
 271
 272 /* dst register flags */
 273 %token <tok> T_EVEN
 274 %token <tok> T_POS_INFINITY
 275 %token <tok> T_EI
 276 %token <num> T_WRMASK
 277
 278 /* instruction flags */
 279 %token <tok> T_SY
 280 %token <tok> T_SS
 281 %token <tok> T_JP
 282 %token <num> T_RPT
 283 %token <tok> T_UL
 284 %token <tok> T_NOP
 285
 286 /* category 0: */
 287 %token <tok> T_OP_NOP
 288 %token <tok> T_OP_BR
 289 %token <tok> T_OP_JUMP
 290 %token <tok> T_OP_CALL
 291 %token <tok> T_OP_RET
 292 %token <tok> T_OP_KILL
 293 %token <tok> T_OP_END
 294 %token <tok> T_OP_EMIT
 295 %token <tok> T_OP_CUT
 296 %token <tok> T_OP_CHMASK
 297 %token <tok> T_OP_CHSH
 298 %token <tok> T_OP_FLOW_REV
 299
 300 /* category 1: */
 301 %token <tok> T_OP_MOVA
 302 %token <tok> T_OP_MOV
 303 %token <tok> T_OP_COV
 304
 305 /* category 2: */
 306 %token <tok> T_OP_ADD_F
 307 %token <tok> T_OP_MIN_F
 308 %token <tok> T_OP_MAX_F
 309 %token <tok> T_OP_MUL_F
 310 %token <tok> T_OP_SIGN_F
 311 %token <tok> T_OP_CMPS_F
 312 %token <tok> T_OP_ABSNEG_F
 313 %token <tok> T_OP_CMPV_F
 314 %token <tok> T_OP_FLOOR_F
 315 %token <tok> T_OP_CEIL_F
 316 %token <tok> T_OP_RNDNE_F
 317 %token <tok> T_OP_RNDAZ_F
 318 %token <tok> T_OP_TRUNC_F
 319 %token <tok> T_OP_ADD_U
 320 %token <tok> T_OP_ADD_S
 321 %token <tok> T_OP_SUB_U
 322 %token <tok> T_OP_SUB_S
 323 %token <tok> T_OP_CMPS_U
 324 %token <tok> T_OP_CMPS_S
 325 %token <tok> T_OP_MIN_U
 326 %token <tok> T_OP_MIN_S
 327 %token <tok> T_OP_MAX_U
 328 %token <tok> T_OP_MAX_S
 329 %token <tok> T_OP_ABSNEG_S
 330 %token <tok> T_OP_AND_B
 331 %token <tok> T_OP_OR_B
 332 %token <tok> T_OP_NOT_B
 333 %token <tok> T_OP_XOR_B
 334 %token <tok> T_OP_CMPV_U
 335 %token <tok> T_OP_CMPV_S
 336 %token <tok> T_OP_MUL_U24
 337 %token <tok> T_OP_MUL_S24
 338 %token <tok> T_OP_MULL_U
 339 %token <tok> T_OP_BFREV_B
 340 %token <tok> T_OP_CLZ_S
 341 %token <tok> T_OP_CLZ_B
 342 %token <tok> T_OP_SHL_B
 343 %token <tok> T_OP_SHR_B
 344 %token <tok> T_OP_ASHR_B
 345 %token <tok> T_OP_BARY_F
 346 %token <tok> T_OP_MGEN_B
 347 %token <tok> T_OP_GETBIT_B
 348 %token <tok> T_OP_SETRM
 349 %token <tok> T_OP_CBITS_B
 350 %token <tok> T_OP_SHB
 351 %token <tok> T_OP_MSAD
 352
 353 /* category 3: */
 354 %token <tok> T_OP_MAD_U16
 355 %token <tok> T_OP_MADSH_U16
 356 %token <tok> T_OP_MAD_S16
 357 %token <tok> T_OP_MADSH_M16
 358 %token <tok> T_OP_MAD_U24
 359 %token <tok> T_OP_MAD_S24
 360 %token <tok> T_OP_MAD_F16
 361 %token <tok> T_OP_MAD_F32
 362 %token <tok> T_OP_SEL_B16
 363 %token <tok> T_OP_SEL_B32
 364 %token <tok> T_OP_SEL_S16
 365 %token <tok> T_OP_SEL_S32
 366 %token <tok> T_OP_SEL_F16
 367 %token <tok> T_OP_SEL_F32
 368 %token <tok> T_OP_SAD_S16
 369 %token <tok> T_OP_SAD_S32
 370
 371 /* category 4: */
 372 %token <tok> T_OP_RCP
 373 %token <tok> T_OP_RSQ
 374 %token <tok> T_OP_LOG2
 375 %token <tok> T_OP_EXP2
 376 %token <tok> T_OP_SIN
 377 %token <tok> T_OP_COS
 378 %token <tok> T_OP_SQRT
 379 %token <tok> T_OP_HRSQ
 380 %token <tok> T_OP_HLOG2
 381 %token <tok> T_OP_HEXP2
 382
 383 /* category 5: */
 384 %token <tok> T_OP_ISAM
 385 %token <tok> T_OP_ISAML
 386 %token <tok> T_OP_ISAMM
 387 %token <tok> T_OP_SAM
 388 %token <tok> T_OP_SAMB
 389 %token <tok> T_OP_SAML
 390 %token <tok> T_OP_SAMGQ
 391 %token <tok> T_OP_GETLOD
 392 %token <tok> T_OP_CONV
 393 %token <tok> T_OP_CONVM
 394 %token <tok> T_OP_GETSIZE
 395 %token <tok> T_OP_GETBUF
 396 %token <tok> T_OP_GETPOS
 397 %token <tok> T_OP_GETINFO
 398 %token <tok> T_OP_DSX
 399 %token <tok> T_OP_DSY
 400 %token <tok> T_OP_GATHER4R
 401 %token <tok> T_OP_GATHER4G
 402 %token <tok> T_OP_GATHER4B
 403 %token <tok> T_OP_GATHER4A
 404 %token <tok> T_OP_SAMGP0
 405 %token <tok> T_OP_SAMGP1
 406 %token <tok> T_OP_SAMGP2
 407 %token <tok> T_OP_SAMGP3
 408 %token <tok> T_OP_DSXPP_1
 409 %token <tok> T_OP_DSYPP_1
 410 %token <tok> T_OP_RGETPOS
 411 %token <tok> T_OP_RGETINFO
 412
 413 /* category 6: */
 414 %token <tok> T_OP_LDG
 415 %token <tok> T_OP_LDL
 416 %token <tok> T_OP_LDP
 417 %token <tok> T_OP_STG
 418 %token <tok> T_OP_STL
 419 %token <tok> T_OP_STP
 420 %token <tok> T_OP_LDIB
 421 %token <tok> T_OP_G2L
 422 %token <tok> T_OP_L2G
 423 %token <tok> T_OP_PREFETCH
 424 %token <tok> T_OP_LDLW
 425 %token <tok> T_OP_STLW
 426 %token <tok> T_OP_RESFMT
 427 %token <tok> T_OP_RESINF
 428 %token <tok> T_OP_ATOMIC_ADD
 429 %token <tok> T_OP_ATOMIC_SUB
 430 %token <tok> T_OP_ATOMIC_XCHG
 431 %token <tok> T_OP_ATOMIC_INC
 432 %token <tok> T_OP_ATOMIC_DEC
 433 %token <tok> T_OP_ATOMIC_CMPXCHG
 434 %token <tok> T_OP_ATOMIC_MIN
 435 %token <tok> T_OP_ATOMIC_MAX
 436 %token <tok> T_OP_ATOMIC_AND
 437 %token <tok> T_OP_ATOMIC_OR
 438 %token <tok> T_OP_ATOMIC_XOR
 439 %token <tok> T_OP_LDGB
 440 %token <tok> T_OP_STGB
 441 %token <tok> T_OP_STIB
 442 %token <tok> T_OP_LDC
 443 %token <tok> T_OP_LDLV
 444
 445 /* type qualifiers: */
 446 %token <tok> T_TYPE_F16
 447 %token <tok> T_TYPE_F32
 448 %token <tok> T_TYPE_U16
 449 %token <tok> T_TYPE_U32
 450 %token <tok> T_TYPE_S16
 451 %token <tok> T_TYPE_S32
 452 %token <tok> T_TYPE_U8
 453 %token <tok> T_TYPE_S8
 454
 455 %token <tok> T_UNTYPED
 456 %token <tok> T_TYPED
 457
 458 %token <tok> T_1D
 459 %token <tok> T_2D
 460 %token <tok> T_3D
 461 %token <tok> T_4D
 462
 463 /* condition qualifiers: */
 464 %token <tok> T_LT
 465 %token <tok> T_LE
 466 %token <tok> T_GT
 467 %token <tok> T_GE
 468 %token <tok> T_EQ
 469 %token <tok> T_NE
 470
 471 %token <tok> T_S2EN
 472 %token <tok> T_SAMP
 473 %token <tok> T_TEX
 474 %token <tok> T_BASE
 475
 476 %token <tok> T_NAN
 477 %token <tok> T_INF
 478 %token <num> T_A0
 479 %token <num> T_P0
 480 %token <str> T_CAT1_TYPE_TYPE
 481
 482 %type <num> integer offset
 483 %type <flt> float
 484 %type <reg> reg const
 485 %type <tok> cat1_opc
 486 %type <tok> cat2_opc_1src cat2_opc_2src_cnd cat2_opc_2src
 487 %type <tok> cat3_opc
 488 %type <tok> cat4_opc
 489 %type <tok> cat5_opc cat5_samp cat5_tex cat5_type
 490 %type <type> type
 491 %type <unum> const_val
 492
 493 %error-verbose
 494
 495 %start shader
 496
 497 %%
 498
 499 shader:            { new_shader(); } headers instrs
 500
 501 headers:
 502 |                  header headers
 503
 504 header:            localsize_header
 505 |                  const_header
 506 |                  buf_header
 507 |                  invocationid_header
 508 |                  wgid_header
 509 |                  numwg_header
 510 |                  in_header
 511 |                  out_header
 512 |                  tex_header
 513
 514 const_val:         T_FLOAT   { $$ = fui($1); }
 515 |                  T_INT     { $$ = $1;      }
 516 |                  '-' T_INT { $$ = -$2;     }
 517 |                  T_HEX     { $$ = $1;      }
 518
 519 localsize_header:  T_A_LOCALSIZE const_val ',' const_val ',' const_val {
 520                        info->local_size[0] = $2;
 521                        info->local_size[1] = $4;
 522                        info->local_size[2] = $6;
 523 }
 524
 525 const_header:      T_A_CONST '(' T_CONSTANT ')' const_val ',' const_val ',' const_val ',' const_val {
 526                        add_const($3, $5, $7, $9, $11);
 527 }
 528
 529 buf_header:        T_A_BUF const_val {
 530                        int idx = info->num_bufs++;
 531                        assert(idx < MAX_BUFS);
 532                        info->buf_sizes[idx] = $2;
 533 }
 534
 535 invocationid_header: T_A_INVOCATIONID '(' T_REGISTER ')' {
 536                        assert(($3 & 0x1) == 0);  /* half-reg not allowed */
 537                        unsigned reg = $3 >> 1;
 538                        add_sysval(reg, 0x7, SYSTEM_VALUE_LOCAL_INVOCATION_ID);
 539 }
 540
 541 wgid_header:       T_A_WGID '(' T_REGISTER ')' {
 542                        assert(($3 & 0x1) == 0);  /* half-reg not allowed */
 543                        unsigned reg = $3 >> 1;
 544                        assert(reg >= regid(48, 0)); /* must be a high reg */
 545                        add_sysval(reg, 0x7, SYSTEM_VALUE_WORK_GROUP_ID);
 546 }
 547
 548 numwg_header:      T_A_NUMWG '(' T_CONSTANT ')' {
 549                        assert(($3 & 0x1) == 0);  /* half-reg not allowed */
 550                        unsigned reg = $3 >> 1;
 551                        info->numwg = reg;
 552                        /* reserve space in immediates for the actual value to be plugged in later: */
 553                        add_const($3, 0, 0, 0, 0);
 554 }
 555
 556 /* Stubs for now */
 557 in_header:         T_A_IN '(' T_REGISTER ')' T_IDENTIFIER '(' T_IDENTIFIER '=' integer ')' { }
 558
 559 out_header:        T_A_OUT '(' T_REGISTER ')' T_IDENTIFIER '(' T_IDENTIFIER '=' integer ')' { }
 560
 561 tex_header:        T_A_TEX '(' T_REGISTER ')'
 562                        T_IDENTIFIER '=' integer ',' /* src */
 563                        T_IDENTIFIER '=' integer ',' /* samp */
 564                        T_IDENTIFIER '=' integer ',' /* tex */
 565                        T_IDENTIFIER '=' integer ',' /* wrmask */
 566                        T_IDENTIFIER '=' integer     /* cmd */ { }
 567
 568 iflag:             T_SY   { iflags.flags |= IR3_INSTR_SY; }
 569 |                  T_SS   { iflags.flags |= IR3_INSTR_SS; }
 570 |                  T_JP   { iflags.flags |= IR3_INSTR_JP; }
 571 |                  T_RPT  { iflags.repeat = $1; }
 572 |                  T_UL   { iflags.flags |= IR3_INSTR_UL; }
 573 |                  T_NOP  { iflags.nop = $1; }
 574
 575 iflags:
 576 |                  iflag iflags
 577
 578 instrs:            instr instrs
 579 |                  instr
 580
 581 instr:             iflags cat0_instr
 582 |                  iflags cat1_instr
 583 |                  iflags cat2_instr
 584 |                  iflags cat3_instr
 585 |                  iflags cat4_instr
 586 |                  iflags cat5_instr
 587 |                  iflags cat6_instr
 588
 589 cat0_src:          '!' T_P0        { instr->cat0.inv = true; instr->cat0.comp = $2 >> 1; }
 590 |                  T_P0            { instr->cat0.comp = $1 >> 1; }
 591
 592 cat0_immed:        '#' integer     { instr->cat0.immed = $2; }
 593
 594 cat0_instr:        T_OP_NOP        { new_instr(OPC_NOP); }
 595 |                  T_OP_BR         { new_instr(OPC_B); }    cat0_src ',' cat0_immed
 596 |                  T_OP_JUMP       { new_instr(OPC_JUMP); }  cat0_immed
 597 |                  T_OP_CALL       { new_instr(OPC_CALL); }  cat0_immed
 598 |                  T_OP_RET        { new_instr(OPC_RET); }
 599 |                  T_OP_KILL       { new_instr(OPC_KILL); }  cat0_src
 600 |                  T_OP_END        { new_instr(OPC_END); }
 601 |                  T_OP_EMIT       { new_instr(OPC_EMIT); }
 602 |                  T_OP_CUT        { new_instr(OPC_CUT); }
 603 |                  T_OP_CHMASK     { new_instr(OPC_CHMASK); }
 604 |                  T_OP_CHSH       { new_instr(OPC_CHSH); }
 605 |                  T_OP_FLOW_REV   { new_instr(OPC_FLOW_REV); }
 606
 607 cat1_opc:          T_OP_MOVA {
 608                        new_instr(OPC_MOV);
 609                        instr->cat1.src_type = TYPE_S16;
 610                        instr->cat1.dst_type = TYPE_S16;
 611 }
 612 |                  T_OP_MOV '.' T_CAT1_TYPE_TYPE {
 613                        parse_type_type(new_instr(OPC_MOV), $3);
 614 }
 615 |                  T_OP_COV '.' T_CAT1_TYPE_TYPE {
 616                        parse_type_type(new_instr(OPC_MOV), $3);
 617 }
 618
 619 cat1_instr:        cat1_opc dst_reg ',' src_reg_or_const_or_rel_or_imm
 620
 621 cat2_opc_1src:     T_OP_ABSNEG_F  { new_instr(OPC_ABSNEG_F); }
 622 |                  T_OP_ABSNEG_S  { new_instr(OPC_ABSNEG_S); }
 623 |                  T_OP_CLZ_B     { new_instr(OPC_CLZ_B); }
 624 |                  T_OP_CLZ_S     { new_instr(OPC_CLZ_S); }
 625 |                  T_OP_SIGN_F    { new_instr(OPC_SIGN_F); }
 626 |                  T_OP_FLOOR_F   { new_instr(OPC_FLOOR_F); }
 627 |                  T_OP_CEIL_F    { new_instr(OPC_CEIL_F); }
 628 |                  T_OP_RNDNE_F   { new_instr(OPC_RNDNE_F); }
 629 |                  T_OP_RNDAZ_F   { new_instr(OPC_RNDAZ_F); }
 630 |                  T_OP_TRUNC_F   { new_instr(OPC_TRUNC_F); }
 631 |                  T_OP_NOT_B     { new_instr(OPC_NOT_B); }
 632 |                  T_OP_BFREV_B   { new_instr(OPC_BFREV_B); }
 633 |                  T_OP_SETRM     { new_instr(OPC_SETRM); }
 634 |                  T_OP_CBITS_B   { new_instr(OPC_CBITS_B); }
 635
 636 cat2_opc_2src_cnd: T_OP_CMPS_F    { new_instr(OPC_CMPS_F); }
 637 |                  T_OP_CMPS_U    { new_instr(OPC_CMPS_U); }
 638 |                  T_OP_CMPS_S    { new_instr(OPC_CMPS_S); }
 639 |                  T_OP_CMPV_F    { new_instr(OPC_CMPV_F); }
 640 |                  T_OP_CMPV_U    { new_instr(OPC_CMPV_U); }
 641 |                  T_OP_CMPV_S    { new_instr(OPC_CMPV_S); }
 642
 643 cat2_opc_2src:     T_OP_ADD_F     { new_instr(OPC_ADD_F); }
 644 |                  T_OP_MIN_F     { new_instr(OPC_MIN_F); }
 645 |                  T_OP_MAX_F     { new_instr(OPC_MAX_F); }
 646 |                  T_OP_MUL_F     { new_instr(OPC_MUL_F); }
 647 |                  T_OP_ADD_U     { new_instr(OPC_ADD_U); }
 648 |                  T_OP_ADD_S     { new_instr(OPC_ADD_S); }
 649 |                  T_OP_SUB_U     { new_instr(OPC_SUB_U); }
 650 |                  T_OP_SUB_S     { new_instr(OPC_SUB_S); }
 651 |                  T_OP_MIN_U     { new_instr(OPC_MIN_U); }
 652 |                  T_OP_MIN_S     { new_instr(OPC_MIN_S); }
 653 |                  T_OP_MAX_U     { new_instr(OPC_MAX_U); }
 654 |                  T_OP_MAX_S     { new_instr(OPC_MAX_S); }
 655 |                  T_OP_AND_B     { new_instr(OPC_AND_B); }
 656 |                  T_OP_OR_B      { new_instr(OPC_OR_B); }
 657 |                  T_OP_XOR_B     { new_instr(OPC_XOR_B); }
 658 |                  T_OP_MUL_U24   { new_instr(OPC_MUL_U24); }
 659 |                  T_OP_MUL_S24   { new_instr(OPC_MUL_S24); }
 660 |                  T_OP_MULL_U    { new_instr(OPC_MULL_U); }
 661 |                  T_OP_SHL_B     { new_instr(OPC_SHL_B); }
 662 |                  T_OP_SHR_B     { new_instr(OPC_SHR_B); }
 663 |                  T_OP_ASHR_B    { new_instr(OPC_ASHR_B); }
 664 |                  T_OP_BARY_F    { new_instr(OPC_BARY_F); }
 665 |                  T_OP_MGEN_B    { new_instr(OPC_MGEN_B); }
 666 |                  T_OP_GETBIT_B  { new_instr(OPC_GETBIT_B); }
 667 |                  T_OP_SHB       { new_instr(OPC_SHB); }
 668 |                  T_OP_MSAD      { new_instr(OPC_MSAD); }
 669
 670 cond:              T_LT           { instr->cat2.condition = IR3_COND_LT; }
 671 |                  T_LE           { instr->cat2.condition = IR3_COND_LE; }
 672 |                  T_GT           { instr->cat2.condition = IR3_COND_GT; }
 673 |                  T_GE           { instr->cat2.condition = IR3_COND_GE; }
 674 |                  T_EQ           { instr->cat2.condition = IR3_COND_EQ; }
 675 |                  T_NE           { instr->cat2.condition = IR3_COND_NE; }
 676
 677 cat2_instr:        cat2_opc_1src dst_reg ',' src_reg_or_const_or_rel_or_imm
 678 |                  cat2_opc_2src_cnd '.' cond dst_reg ',' src_reg_or_const_or_rel_or_imm ',' src_reg_or_const_or_rel_or_imm
 679 |                  cat2_opc_2src dst_reg ',' src_reg_or_const_or_rel_or_imm ',' src_reg_or_const_or_rel_or_imm
 680
 681 cat3_opc:          T_OP_MAD_U16   { new_instr(OPC_MAD_U16); }
 682 |                  T_OP_MADSH_U16 { new_instr(OPC_MADSH_U16); }
 683 |                  T_OP_MAD_S16   { new_instr(OPC_MAD_S16); }
 684 |                  T_OP_MADSH_M16 { new_instr(OPC_MADSH_M16); }
 685 |                  T_OP_MAD_U24   { new_instr(OPC_MAD_U24); }
 686 |                  T_OP_MAD_S24   { new_instr(OPC_MAD_S24); }
 687 |                  T_OP_MAD_F16   { new_instr(OPC_MAD_F16); }
 688 |                  T_OP_MAD_F32   { new_instr(OPC_MAD_F32); }
 689 |                  T_OP_SEL_B16   { new_instr(OPC_SEL_B16); }
 690 |                  T_OP_SEL_B32   { new_instr(OPC_SEL_B32); }
 691 |                  T_OP_SEL_S16   { new_instr(OPC_SEL_S16); }
 692 |                  T_OP_SEL_S32   { new_instr(OPC_SEL_S32); }
 693 |                  T_OP_SEL_F16   { new_instr(OPC_SEL_F16); }
 694 |                  T_OP_SEL_F32   { new_instr(OPC_SEL_F32); }
 695 |                  T_OP_SAD_S16   { new_instr(OPC_SAD_S16); }
 696 |                  T_OP_SAD_S32   { new_instr(OPC_SAD_S32); }
 697
 698 cat3_instr:        cat3_opc dst_reg ',' src_reg_or_const_or_rel ',' src_reg_or_const ',' src_reg_or_const_or_rel
 699
 700 cat4_opc:          T_OP_RCP       { new_instr(OPC_RCP); }
 701 |                  T_OP_RSQ       { new_instr(OPC_RSQ); }
 702 |                  T_OP_LOG2      { new_instr(OPC_LOG2); }
 703 |                  T_OP_EXP2      { new_instr(OPC_EXP2); }
 704 |                  T_OP_SIN       { new_instr(OPC_SIN); }
 705 |                  T_OP_COS       { new_instr(OPC_COS); }
 706 |                  T_OP_SQRT      { new_instr(OPC_SQRT); }
 707 |                  T_OP_HRSQ      { new_instr(OPC_HRSQ); }
 708 |                  T_OP_HLOG2     { new_instr(OPC_HLOG2); }
 709 |                  T_OP_HEXP2     { new_instr(OPC_HEXP2); }
 710
 711 cat4_instr:        cat4_opc dst_reg ',' src_reg_or_const_or_rel_or_imm
 712
 713 cat5_opc_dsxypp:   T_OP_DSXPP_1   { new_instr(OPC_DSXPP_1); }
 714 |                  T_OP_DSYPP_1   { new_instr(OPC_DSYPP_1); }
 715
 716 cat5_opc:          T_OP_ISAM      { new_instr(OPC_ISAM); }
 717 |                  T_OP_ISAML     { new_instr(OPC_ISAML); }
 718 |                  T_OP_ISAMM     { new_instr(OPC_ISAMM); }
 719 |                  T_OP_SAM       { new_instr(OPC_SAM); }
 720 |                  T_OP_SAMB      { new_instr(OPC_SAMB); }
 721 |                  T_OP_SAML      { new_instr(OPC_SAML); }
 722 |                  T_OP_SAMGQ     { new_instr(OPC_SAMGQ); }
 723 |                  T_OP_GETLOD    { new_instr(OPC_GETLOD); }
 724 |                  T_OP_CONV      { new_instr(OPC_CONV); }
 725 |                  T_OP_CONVM     { new_instr(OPC_CONVM); }
 726 |                  T_OP_GETSIZE   { new_instr(OPC_GETSIZE); }
 727 |                  T_OP_GETBUF    { new_instr(OPC_GETBUF); }
 728 |                  T_OP_GETPOS    { new_instr(OPC_GETPOS); }
 729 |                  T_OP_GETINFO   { new_instr(OPC_GETINFO); }
 730 |                  T_OP_DSX       { new_instr(OPC_DSX); }
 731 |                  T_OP_DSY       { new_instr(OPC_DSY); }
 732 |                  T_OP_GATHER4R  { new_instr(OPC_GATHER4R); }
 733 |                  T_OP_GATHER4G  { new_instr(OPC_GATHER4G); }
 734 |                  T_OP_GATHER4B  { new_instr(OPC_GATHER4B); }
 735 |                  T_OP_GATHER4A  { new_instr(OPC_GATHER4A); }
 736 |                  T_OP_SAMGP0    { new_instr(OPC_SAMGP0); }
 737 |                  T_OP_SAMGP1    { new_instr(OPC_SAMGP1); }
 738 |                  T_OP_SAMGP2    { new_instr(OPC_SAMGP2); }
 739 |                  T_OP_SAMGP3    { new_instr(OPC_SAMGP3); }
 740 |                  T_OP_RGETPOS   { new_instr(OPC_RGETPOS); }
 741 |                  T_OP_RGETINFO  { new_instr(OPC_RGETINFO); }
 742
 743 cat5_flag:         '.' T_3D       { instr->flags |= IR3_INSTR_3D; }
 744 |                  '.' 'a'        { instr->flags |= IR3_INSTR_A; }
 745 |                  '.' 'o'        { instr->flags |= IR3_INSTR_O; }
 746 |                  '.' 'p'        { instr->flags |= IR3_INSTR_P; }
 747 |                  '.' 's'        { instr->flags |= IR3_INSTR_S; }
 748 |                  '.' T_S2EN     { instr->flags |= IR3_INSTR_S2EN; }
 749 |                  '.' T_BASE     { instr->flags |= IR3_INSTR_B; instr->cat5.tex_base = $2; }
 750 cat5_flags:
 751 |                  cat5_flag cat5_flags
 752
 753 cat5_samp:         T_SAMP         { instr->cat5.samp = $1; }
 754 cat5_tex:          T_TEX          { if (instr->flags & IR3_INSTR_B) instr->cat5.samp |= ($1 << 4); else instr->cat5.tex = $1; }
 755 cat5_type:         '(' type ')'   { instr->cat5.type = $2; }
 756
 757 cat5_instr:        cat5_opc_dsxypp cat5_flags dst_reg ',' src_reg
 758 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg ',' cat5_samp ',' cat5_tex
 759 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg ',' cat5_samp
 760 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg ',' cat5_tex
 761 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' src_reg
 762 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' cat5_samp ',' cat5_tex
 763 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' cat5_samp
 764 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg ',' cat5_tex
 765 |                  cat5_opc cat5_flags cat5_type dst_reg ',' src_reg
 766 |                  cat5_opc cat5_flags cat5_type dst_reg ',' cat5_samp ',' cat5_tex
 767 |                  cat5_opc cat5_flags cat5_type dst_reg ',' cat5_samp
 768 |                  cat5_opc cat5_flags cat5_type dst_reg ',' cat5_tex
 769 |                  cat5_opc cat5_flags cat5_type dst_reg
 770
 771 cat6_typed:        '.' T_UNTYPED  { instr->cat6.typed = 0; }
 772 |                  '.' T_TYPED    { instr->cat6.typed = 1; }
 773
 774 cat6_dim:          '.' T_1D  { instr->cat6.d = 1; }
 775 |                  '.' T_2D  { instr->cat6.d = 2; }
 776 |                  '.' T_3D  { instr->cat6.d = 3; }
 777 |                  '.' T_4D  { instr->cat6.d = 4; }
 778
 779 cat6_type:         '.' type  { instr->cat6.type = $2; }
 780 cat6_offset:       offset    { instr->cat6.src_offset = $1; }
 781 cat6_immed:        integer   { instr->cat6.iim_val = $1; }
 782
 783 cat6_load:         T_OP_LDG  { new_instr(OPC_LDG); }  cat6_type dst_reg ',' 'g' '[' reg cat6_offset ']' ',' cat6_immed
 784 |                  T_OP_LDP  { new_instr(OPC_LDP); }  cat6_type dst_reg ',' 'p' '[' reg cat6_offset ']' ',' cat6_immed
 785 |                  T_OP_LDL  { new_instr(OPC_LDL); }  cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 786 |                  T_OP_LDLW { new_instr(OPC_LDLW); } cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 787 |                  T_OP_LDLV { new_instr(OPC_LDLV); } cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 788
 789 // TODO some of the cat6 instructions have different syntax for a6xx..
 790 //|                  T_OP_LDIB { new_instr(OPC_LDIB); } cat6_type dst_reg cat6_offset ',' reg ',' cat6_immed
 791
 792 cat6_store:        T_OP_STG  { new_instr(OPC_STG); }  cat6_type 'g' '[' dst_reg cat6_offset ']' ',' reg ',' cat6_immed
 793 |                  T_OP_STP  { new_instr(OPC_STP); }  cat6_type 'p' '[' dst_reg cat6_offset ']' ',' reg ',' cat6_immed
 794 |                  T_OP_STL  { new_instr(OPC_STL); }  cat6_type 'l' '[' dst_reg cat6_offset ']' ',' reg ',' cat6_immed
 795 |                  T_OP_STLW { new_instr(OPC_STLW); } cat6_type 'l' '[' dst_reg cat6_offset ']' ',' reg ',' cat6_immed
 796
 797 cat6_storeib:      T_OP_STIB { new_instr(OPC_STIB); dummy_dst(); } cat6_typed cat6_dim cat6_type '.' cat6_immed'g' '[' immediate ']' '+' reg ',' reg
 798
 799 cat6_prefetch:     T_OP_PREFETCH { new_instr(OPC_PREFETCH); new_reg(0,0); /* dummy dst */ } 'g' '[' reg cat6_offset ']' ',' cat6_immed
 800
 801 cat6_atomic_l_g:   '.' 'g'  { instr->flags |= IR3_INSTR_G; }
 802 |                  '.' 'l'  {  }
 803
 804 cat6_atomic:       T_OP_ATOMIC_ADD     { new_instr(OPC_ATOMIC_ADD); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 805 |                  T_OP_ATOMIC_SUB     { new_instr(OPC_ATOMIC_SUB); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 806 |                  T_OP_ATOMIC_XCHG    { new_instr(OPC_ATOMIC_XCHG); }   cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 807 |                  T_OP_ATOMIC_INC     { new_instr(OPC_ATOMIC_INC); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 808 |                  T_OP_ATOMIC_DEC     { new_instr(OPC_ATOMIC_DEC); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 809 |                  T_OP_ATOMIC_CMPXCHG { new_instr(OPC_ATOMIC_CMPXCHG); }cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 810 |                  T_OP_ATOMIC_MIN     { new_instr(OPC_ATOMIC_MIN); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 811 |                  T_OP_ATOMIC_MAX     { new_instr(OPC_ATOMIC_MAX); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 812 |                  T_OP_ATOMIC_AND     { new_instr(OPC_ATOMIC_AND); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 813 |                  T_OP_ATOMIC_OR      { new_instr(OPC_ATOMIC_OR); }     cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 814 |                  T_OP_ATOMIC_XOR     { new_instr(OPC_ATOMIC_XOR); }    cat6_atomic_l_g cat6_type dst_reg ',' 'l' '[' reg cat6_offset ']' ',' cat6_immed
 815
 816 cat6_todo:         T_OP_G2L                 { new_instr(OPC_G2L); }
 817 |                  T_OP_L2G                 { new_instr(OPC_L2G); }
 818 |                  T_OP_RESFMT              { new_instr(OPC_RESFMT); }
 819 |                  T_OP_RESINF              { new_instr(OPC_RESINFO); }
 820 |                  T_OP_LDGB                { new_instr(OPC_LDGB); }
 821 |                  T_OP_STGB                { new_instr(OPC_STGB); }
 822 |                  T_OP_LDC                 { new_instr(OPC_LDC); }
 823
 824 cat6_instr:        cat6_load
 825 |                  cat6_store
 826 |                  cat6_storeib
 827 |                  cat6_prefetch
 828 |                  cat6_atomic
 829 |                  cat6_todo
 830
 831 reg:               T_REGISTER     { $$ = new_reg($1, 0); }
 832 |                  T_A0           { $$ = new_reg((61 << 3) + $1, IR3_REG_HALF); }
 833 |                  T_P0           { $$ = new_reg((62 << 3) + $1, 0); }
 834
 835 const:             T_CONSTANT     { $$ = new_reg($1, IR3_REG_CONST); }
 836
 837 dst_reg_flag:      T_EVEN         { rflags.flags |= IR3_REG_EVEN; }
 838 |                  T_POS_INFINITY { rflags.flags |= IR3_REG_POS_INF; }
 839 |                  T_EI           { rflags.flags |= IR3_REG_EI; }
 840 |                  T_WRMASK       { rflags.wrmask = $1; }
 841
 842 dst_reg_flags:     dst_reg_flag
 843 |                  dst_reg_flag dst_reg_flags
 844
 845                    /* note: destination registers are always incremented in repeat */
 846 dst_reg:           reg                 { $1->flags |= IR3_REG_R; }
 847 |                  dst_reg_flags reg   { $2->flags |= IR3_REG_R; }
 848
 849 src_reg_flag:      T_ABSNEG       { rflags.flags |= IR3_REG_ABS|IR3_REG_NEGATE; }
 850 |                  T_NEG          { rflags.flags |= IR3_REG_NEGATE; }
 851 |                  T_ABS          { rflags.flags |= IR3_REG_ABS; }
 852 |                  T_R            { rflags.flags |= IR3_REG_R; }
 853
 854 src_reg_flags:     src_reg_flag
 855 |                  src_reg_flag src_reg_flags
 856
 857 src_reg:           reg
 858 |                  src_reg_flags reg
 859
 860 src_const:         const
 861 |                  src_reg_flags const
 862
 863 src_reg_or_const:  src_reg
 864 |                  src_const
 865
 866 src_reg_or_const_or_rel: src_reg_or_const
 867 |                  relative
 868
 869 src_reg_or_const_or_rel_or_imm: src_reg_or_const_or_rel
 870 |                  src_reg_flags immediate
 871 |                  immediate
 872
 873 offset:            { $$ = 0; }
 874 |                  '+' integer { $$ = $2; }
 875 |                  '-' integer { $$ = -$2; }
 876
 877 relative:          'r' '<' T_A0 offset '>'  { new_reg(0, IR3_REG_RELATIV)->array.offset = $4; }
 878 |                  'c' '<' T_A0 offset '>'  { new_reg(0, IR3_REG_RELATIV | IR3_REG_CONST)->array.offset = $4; }
 879 |                  T_HR '<' T_A0 offset '>'  { new_reg(0, IR3_REG_RELATIV | IR3_REG_HALF)->array.offset = $4; }
 880 |                  T_HC '<' T_A0 offset '>'  { new_reg(0, IR3_REG_RELATIV | IR3_REG_CONST | IR3_REG_HALF)->array.offset = $4; }
 881
 882 immediate:         integer             { new_reg(0, IR3_REG_IMMED)->iim_val = $1; }
 883 |                  '(' integer ')'     { new_reg(0, IR3_REG_IMMED)->fim_val = $2; }
 884 |                  '(' float ')'       { new_reg(0, IR3_REG_IMMED)->fim_val = $2; }
 885 |                  '(' T_NAN ')'       { new_reg(0, IR3_REG_IMMED)->fim_val = NAN; }
 886 |                  '(' T_INF ')'       { new_reg(0, IR3_REG_IMMED)->fim_val = INFINITY; }
 887
 888 integer:           T_INT       { $$ = $1; }
 889 |                  '-' T_INT   { $$ = -$2; }
 890 |                  T_HEX       { $$ = $1; }
 891 |                  '-' T_HEX   { $$ = -$2; }
 892
 893 float:             T_FLOAT     { $$ = $1; }
 894 |                  '-' T_FLOAT { $$ = -$2; }
 895
 896 type:              T_TYPE_F16  { $$ = TYPE_F16; }
 897 |                  T_TYPE_F32  { $$ = TYPE_F32; }
 898 |                  T_TYPE_U16  { $$ = TYPE_U16; }
 899 |                  T_TYPE_U32  { $$ = TYPE_U32; }
 900 |                  T_TYPE_S16  { $$ = TYPE_S16; }
 901 |                  T_TYPE_S32  { $$ = TYPE_S32; }
 902 |                  T_TYPE_U8   { $$ = TYPE_U8;  }
 903 |                  T_TYPE_S8   { $$ = TYPE_S8;  }