/*
 * Copyright (c) 2013 Rob Clark <robclark@freedesktop.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

%code requires {
#include "ir3/ir3_assembler.h"
#include "ir3/ir3_shader.h"

struct ir3 * ir3_parse(struct ir3_shader_variant *v,
		struct ir3_kernel_info *k, FILE *f);
}

%{
#define YYDEBUG 0
#include "ir3/ir3_parser_support.c"
%}

%union {
	int tok;
	int num;
	uint32_t unum;
	uint64_t u64;
	double flt;
	const char *str;
	struct ir3_register *reg;
	struct {
		int start;
		int num;
	} range;
	type_t type;
}

%{
#if YYDEBUG
static void print_token(FILE *file, int type, YYSTYPE value)
{
	fprintf(file, "\ntype: %d\n", type);
}

#define YYPRINT(file, type, value) print_token(file, type, value)
#endif
%}

%token <num> T_INT
%token <unum> T_HEX
%token <flt> T_FLOAT
%token <str> T_IDENTIFIER
%token <num> T_REGISTER
%token <num> T_CONSTANT
%token <num> T_RT

/* @ headers (@const/@sampler/@uniform/@varying) */
%token <tok> T_A_LOCALSIZE
%token <tok> T_A_CONST
%token <tok> T_A_BUF
%token <tok> T_A_UBO
%token <tok> T_A_INVOCATIONID
%token <tok> T_A_WGID
%token <tok> T_A_NUMWG
%token <tok> T_A_BRANCHSTACK
%token <tok> T_A_IN
%token <tok> T_A_OUT
%token <tok> T_A_TEX
%token <tok> T_A_PVTMEM
%token <tok> T_A_LOCALMEM
%token <tok> T_A_CONSTLEN
%token <tok> T_A_EARLYPREAMBLE
%token <tok> T_A_FULLNOPSTART
%token <tok> T_A_FULLNOPEND
%token <tok> T_A_FULLSYNCSTART
%token <tok> T_A_FULLSYNCEND
/* todo, re-add @sampler/@uniform/@varying if needed someday */

/* src register flags */
%token <tok> T_ABSNEG
%token <tok> T_NEG
%token <tok> T_ABS
%token <tok> T_R
%token <tok> T_LAST

%token <tok> T_HR
%token <tok> T_HC

/* dst register flags */
%token <tok> T_EVEN
%token <tok> T_POS_INFINITY
%token <tok> T_NEG_INFINITY
%token <tok> T_EI
%token <num> T_WRMASK

/* Float LUT values accepted as immed: */
%token <num> T_FLUT_0_0
%token <num> T_FLUT_0_5
%token <num> T_FLUT_1_0
%token <num> T_FLUT_2_0
%token <num> T_FLUT_E
%token <num> T_FLUT_PI
%token <num> T_FLUT_INV_PI
%token <num> T_FLUT_INV_LOG2_E
%token <num> T_FLUT_LOG2_E
%token <num> T_FLUT_INV_LOG2_10
%token <num> T_FLUT_LOG2_10
%token <num> T_FLUT_4_0

/* instruction flags */
%token <tok> T_SY
%token <tok> T_SS
%token <tok> T_JP
%token <tok> T_EQ_FLAG
%token <tok> T_SAT
%token <num> T_RPT
%token <tok> T_UL
%token <tok> T_NOP
%token <tok> T_EOLM
%token <tok> T_EOGM
%token <tok> T_EOSTSC

/* category 0: */
%token <tok> T_OP_NOP
%token <tok> T_OP_BR
%token <tok> T_OP_BRAO
%token <tok> T_OP_BRAA
%token <tok> T_OP_BRAC
%token <tok> T_OP_BANY
%token <tok> T_OP_BALL
%token <tok> T_OP_BRAX
%token <tok> T_OP_JUMP
%token <tok> T_OP_CALL
%token <tok> T_OP_RET
%token <tok> T_OP_KILL
%token <tok> T_OP_END
%token <tok> T_OP_EMIT
%token <tok> T_OP_CUT
%token <tok> T_OP_CHMASK
%token <tok> T_OP_CHSH
%token <tok> T_OP_FLOW_REV
%token <tok> T_OP_BKT
%token <tok> T_OP_STKS
%token <tok> T_OP_STKR
%token <tok> T_OP_XSET
%token <tok> T_OP_XCLR
%token <tok> T_OP_GETLAST
%token <tok> T_OP_GETONE
%token <tok> T_OP_DBG
%token <tok> T_OP_SHPS
%token <tok> T_OP_SHPE
%token <tok> T_OP_PREDT
%token <tok> T_OP_PREDF
%token <tok> T_OP_PREDE

/* category 1: */
%token <tok> T_OP_MOVMSK
%token <tok> T_OP_MOVA1
%token <tok> T_OP_MOVA
%token <tok> T_OP_MOVA_R
%token <tok> T_OP_MOV
%token <tok> T_OP_COV
%token <tok> T_OP_SWZ
%token <tok> T_OP_GAT
%token <tok> T_OP_SCT
%token <tok> T_OP_MOVS

%token <tok> T_MUL2
%token <tok> T_DIV2

/* category 2: */
%token <tok> T_OP_ADD_F
%token <tok> T_OP_MIN_F
%token <tok> T_OP_MAX_F
%token <tok> T_OP_MUL_F
%token <tok> T_OP_SIGN_F
%token <tok> T_OP_CMPS_F
%token <tok> T_OP_ABSNEG_F
%token <tok> T_OP_CMPV_F
%token <tok> T_OP_FLOOR_F
%token <tok> T_OP_CEIL_F
%token <tok> T_OP_RNDNE_F
%token <tok> T_OP_RNDAZ_F
%token <tok> T_OP_TRUNC_F
%token <tok> T_OP_ADD_U
%token <tok> T_OP_ADD_S
%token <tok> T_OP_SUB_U
%token <tok> T_OP_SUB_S
%token <tok> T_OP_CMPS_U
%token <tok> T_OP_CMPS_S
%token <tok> T_OP_MIN_U
%token <tok> T_OP_MIN_S
%token <tok> T_OP_MAX_U
%token <tok> T_OP_MAX_S
%token <tok> T_OP_ABSNEG_S
%token <tok> T_OP_AND_B
%token <tok> T_OP_OR_B
%token <tok> T_OP_NOT_B
%token <tok> T_OP_XOR_B
%token <tok> T_OP_CMPV_U
%token <tok> T_OP_CMPV_S
%token <tok> T_OP_MUL_U24
%token <tok> T_OP_MUL_S24
%token <tok> T_OP_MULL_U
%token <tok> T_OP_BFREV_B
%token <tok> T_OP_CLZ_S
%token <tok> T_OP_CLZ_B
%token <tok> T_OP_SHL_B
%token <tok> T_OP_SHR_B
%token <tok> T_OP_ASHR_B
%token <tok> T_OP_BARY_F
%token <tok> T_OP_FLAT_B
%token <tok> T_OP_MGEN_B
%token <tok> T_OP_GETBIT_B
%token <tok> T_OP_SETRM
%token <tok> T_OP_CBITS_B
%token <tok> T_OP_SHB
%token <tok> T_OP_MSAD

/* category 3: */
%token <tok> T_OP_MAD_U16
%token <tok> T_OP_MADSH_U16
%token <tok> T_OP_MAD_S16
%token <tok> T_OP_MADSH_M16
%token <tok> T_OP_MAD_U24
%token <tok> T_OP_MAD_S24
%token <tok> T_OP_MAD_F16
%token <tok> T_OP_MAD_F32
%token <tok> T_OP_SEL_B16
%token <tok> T_OP_SEL_B32
%token <tok> T_OP_SEL_S16
%token <tok> T_OP_SEL_S32
%token <tok> T_OP_SEL_F16
%token <tok> T_OP_SEL_F32
%token <tok> T_OP_SAD_S16
%token <tok> T_OP_SAD_S32
%token <tok> T_OP_SHRM
%token <tok> T_OP_SHLM
%token <tok> T_OP_SHRG
%token <tok> T_OP_SHLG
%token <tok> T_OP_ANDG
%token <tok> T_OP_DP2ACC
%token <tok> T_OP_DP4ACC
%token <tok> T_OP_WMM
%token <tok> T_OP_WMM_ACCU

/* category 4: */
%token <tok> T_OP_RCP
%token <tok> T_OP_RSQ
%token <tok> T_OP_LOG2
%token <tok> T_OP_EXP2
%token <tok> T_OP_SIN
%token <tok> T_OP_COS
%token <tok> T_OP_SQRT
%token <tok> T_OP_HRSQ
%token <tok> T_OP_HLOG2
%token <tok> T_OP_HEXP2

/* category 5: */
%token <tok> T_OP_ISAM
%token <tok> T_OP_ISAML
%token <tok> T_OP_ISAMM
%token <tok> T_OP_SAM
%token <tok> T_OP_SAMB
%token <tok> T_OP_SAML
%token <tok> T_OP_SAMGQ
%token <tok> T_OP_GETLOD
%token <tok> T_OP_CONV
%token <tok> T_OP_CONVM
%token <tok> T_OP_GETSIZE
%token <tok> T_OP_GETBUF
%token <tok> T_OP_GETPOS
%token <tok> T_OP_GETINFO
%token <tok> T_OP_DSX
%token <tok> T_OP_DSY
%token <tok> T_OP_GATHER4R
%token <tok> T_OP_GATHER4G
%token <tok> T_OP_GATHER4B
%token <tok> T_OP_GATHER4A
%token <tok> T_OP_SAMGP0
%token <tok> T_OP_SAMGP1
%token <tok> T_OP_SAMGP2
%token <tok> T_OP_SAMGP3
%token <tok> T_OP_DSXPP_1
%token <tok> T_OP_DSYPP_1
%token <tok> T_OP_RGETPOS
%token <tok> T_OP_RGETINFO
%token <tok> T_OP_BRCST_A
%token <tok> T_OP_QSHUFFLE_BRCST
%token <tok> T_OP_QSHUFFLE_H
%token <tok> T_OP_QSHUFFLE_V
%token <tok> T_OP_QSHUFFLE_DIAG
%token <tok> T_OP_TCINV
%token <tok> T_OP_IMG_BINDLESS_HOF
%token <tok> T_OP_IMG_BINDLESS_PCMN
%token <tok> T_OP_IMG_BINDLESS

/* category 6: */
%token <tok> T_OP_LDG
%token <tok> T_OP_LDG_A
%token <tok> T_OP_LDG_K
%token <tok> T_OP_LDL
%token <tok> T_OP_LDP
%token <tok> T_OP_STG
%token <tok> T_OP_STG_A
%token <tok> T_OP_STL
%token <tok> T_OP_STP
%token <tok> T_OP_LDIB
%token <tok> T_OP_G2L
%token <tok> T_OP_L2G
%token <tok> T_OP_PREFETCH
%token <tok> T_OP_LDLW
%token <tok> T_OP_STLW
%token <tok> T_OP_RESFMT
%token <tok> T_OP_RESINFO
%token <tok> T_OP_RESBASE
%token <tok> T_OP_ATOMIC_ADD
%token <tok> T_OP_ATOMIC_SUB
%token <tok> T_OP_ATOMIC_XCHG
%token <tok> T_OP_ATOMIC_INC
%token <tok> T_OP_ATOMIC_DEC
%token <tok> T_OP_ATOMIC_CMPXCHG
%token <tok> T_OP_ATOMIC_MIN
%token <tok> T_OP_ATOMIC_MAX
%token <tok> T_OP_ATOMIC_AND
%token <tok> T_OP_ATOMIC_OR
%token <tok> T_OP_ATOMIC_XOR
%token <tok> T_OP_RESINFO_B
%token <tok> T_OP_LDIB_B
%token <tok> T_OP_STIB_B
%token <tok> T_OP_ATOMIC_B_ADD
%token <tok> T_OP_ATOMIC_B_SUB
%token <tok> T_OP_ATOMIC_B_XCHG
%token <tok> T_OP_ATOMIC_B_INC
%token <tok> T_OP_ATOMIC_B_DEC
%token <tok> T_OP_ATOMIC_B_CMPXCHG
%token <tok> T_OP_ATOMIC_B_MIN
%token <tok> T_OP_ATOMIC_B_MAX
%token <tok> T_OP_ATOMIC_B_AND
%token <tok> T_OP_ATOMIC_B_OR
%token <tok> T_OP_ATOMIC_B_XOR
%token <tok> T_OP_ATOMIC_S_ADD
%token <tok> T_OP_ATOMIC_S_SUB
%token <tok> T_OP_ATOMIC_S_XCHG
%token <tok> T_OP_ATOMIC_S_INC
%token <tok> T_OP_ATOMIC_S_DEC
%token <tok> T_OP_ATOMIC_S_CMPXCHG
%token <tok> T_OP_ATOMIC_S_MIN
%token <tok> T_OP_ATOMIC_S_MAX
%token <tok> T_OP_ATOMIC_S_AND
%token <tok> T_OP_ATOMIC_S_OR
%token <tok> T_OP_ATOMIC_S_XOR
%token <tok> T_OP_ATOMIC_G_ADD
%token <tok> T_OP_ATOMIC_G_SUB
%token <tok> T_OP_ATOMIC_G_XCHG
%token <tok> T_OP_ATOMIC_G_INC
%token <tok> T_OP_ATOMIC_G_DEC
%token <tok> T_OP_ATOMIC_G_CMPXCHG
%token <tok> T_OP_ATOMIC_G_MIN
%token <tok> T_OP_ATOMIC_G_MAX
%token <tok> T_OP_ATOMIC_G_AND
%token <tok> T_OP_ATOMIC_G_OR
%token <tok> T_OP_ATOMIC_G_XOR
%token <tok> T_OP_LDGB
%token <tok> T_OP_STGB
%token <tok> T_OP_STIB
%token <tok> T_OP_LDC
%token <tok> T_OP_LDLV
%token <tok> T_OP_GETSPID
%token <tok> T_OP_GETWID
%token <tok> T_OP_GETFIBERID
%token <tok> T_OP_STC
%token <tok> T_OP_STSC
%token <tok> T_OP_SHFL
%token <tok> T_OP_RAY_INTERSECTION

/* category 7: */
%token <tok> T_OP_BAR
%token <tok> T_OP_FENCE
%token <tok> T_OP_SLEEP
%token <tok> T_OP_ICINV
%token <tok> T_OP_DCCLN
%token <tok> T_OP_DCINV
%token <tok> T_OP_DCFLU
%token <tok> T_OP_CCINV
%token <tok> T_OP_LOCK
%token <tok> T_OP_UNLOCK
%token <tok> T_OP_ALIAS

%token <u64> T_RAW

%token <tok> T_OP_PRINT

/* type qualifiers: */
%token <tok> T_TYPE_F16
%token <tok> T_TYPE_F32
%token <tok> T_TYPE_U16
%token <tok> T_TYPE_U32
%token <tok> T_TYPE_S16
%token <tok> T_TYPE_S32
%token <tok> T_TYPE_U8
%token <tok> T_TYPE_U8_32
%token <tok> T_TYPE_U64
%token <tok> T_TYPE_B16
%token <tok> T_TYPE_B32

%token <tok> T_UNTYPED
%token <tok> T_TYPED

%token <tok> T_MIXED
%token <tok> T_UNSIGNED
%token <tok> T_LOW
%token <tok> T_HIGH

%token <tok> T_1D
%token <tok> T_2D
%token <tok> T_3D
%token <tok> T_4D

%token <tok> T_SAD
%token <tok> T_SSD

/* condition qualifiers: */
%token <tok> T_LT
%token <tok> T_LE
%token <tok> T_GT
%token <tok> T_GE
%token <tok> T_EQ
%token <tok> T_NE

%token <tok> T_S2EN
%token <tok> T_SAMP
%token <tok> T_TEX
%token <tok> T_BASE
%token <tok> T_OFFSET
%token <tok> T_UNIFORM
%token <tok> T_NONUNIFORM
%token <tok> T_IMM
%token <tok> T_RCK
%token <tok> T_CLP

%token <tok> T_NAN
%token <tok> T_INF
%token <num> T_A0
%token <num> T_A1
%token <num> T_P0
%token <num> T_UP0
%token <num> T_W
%token <str> T_CAT1_TYPE_TYPE

%token <tok> T_MOD_TEX
%token <tok> T_MOD_MEM
%token <tok> T_MOD_RT

%token <tok> T_MOD_XOR
%token <tok> T_MOD_UP
%token <tok> T_MOD_DOWN
%token <tok> T_MOD_RUP
%token <tok> T_MOD_RDOWN

%type <num> integer uinteger offset uoffset
%type <num> flut_immed
%type <flt> float
%type <reg> dst const src_gpr src_a0 src_a1 src_p0 cat0_src1 cat0_src2
%type <tok> cat1_opc
%type <tok> cat2_opc_1src cat2_opc_2src_cnd cat2_opc_2src
%type <tok> cat3_opc
%type <tok> cat4_opc
%type <tok> cat5_opc cat5_samp cat5_tex cat5_type
%type <type> type
%type <unum> const_val cat6_src_shift
%type <num> buf_type

%define parse.error verbose

%start shader

%%

shader:            { new_shader(); } headers instrs

headers:           
|                  header headers

header:            localsize_header
|                  const_header
|                  buf_header
|                  invocationid_header
|                  wgid_header
|                  numwg_header
|                  branchstack_header
|                  in_header
|                  out_header
|                  tex_header
|                  pvtmem_header
|                  localmem_header
|                  earlypreamble_header
|                  constlen_header

const_val:         T_FLOAT   { $$ = fui($1); }
|                  T_INT     { $$ = $1;      }
|                  '-' T_INT { $$ = -$2;     }
|                  T_HEX     { $$ = $1;      }

localsize_header:  T_A_LOCALSIZE const_val ',' const_val ',' const_val {
                       variant->local_size[0] = $2;
                       variant->local_size[1] = $4;
                       variant->local_size[2] = $6;
}

const_header:      T_A_CONST '(' T_CONSTANT ')' const_val ',' const_val ',' const_val ',' const_val {
                       add_const($3, $5, $7, $9, $11);
}

buf_header_init_val:  const_val { add_buf_init_val($1); }
buf_header_init_vals: buf_header_init_val
|                     buf_header_init_val ',' buf_header_init_vals
|

buf_header_addr_reg:
                   '(' T_CONSTANT ')' {
                       assert(($2 & 0x1) == 0);  /* half-reg not allowed */
                       unsigned reg = $2 >> 1;

                       info->buf_addr_regs[info->num_bufs - 1] = reg;
                       /* reserve space in immediates for the actual value to be plugged in later: */
                       add_const($2, 0, 0, 0, 0);
}
|

buf_type: T_A_BUF { $$ = KERNEL_BUF_UAV; }
|         T_A_UBO { $$ = KERNEL_BUF_UBO; }

buf_header:        buf_type const_val {
                       int idx = info->num_bufs++;
                       assert(idx < MAX_BUFS);
                       info->buf_types[idx] = $1;
                       info->buf_sizes[idx] = $2;
} buf_header_addr_reg buf_header_init_vals

invocationid_header: T_A_INVOCATIONID '(' T_REGISTER ')' {
                       assert(($3 & 0x1) == 0);  /* half-reg not allowed */
                       unsigned reg = $3 >> 1;
                       add_sysval(reg, 0x7, SYSTEM_VALUE_LOCAL_INVOCATION_ID);
}

wgid_header:       T_A_WGID '(' T_REGISTER ')' {
                       assert(($3 & 0x1) == 0);  /* half-reg not allowed */
                       unsigned reg = $3 >> 1;
                       assert(variant->compiler->gen >= 5);
                       assert(reg >= regid(48, 0)); /* must be a high reg */
                       add_sysval(reg, 0x7, SYSTEM_VALUE_WORKGROUP_ID);
}
|                  T_A_WGID '(' T_CONSTANT ')' {
                       assert(($3 & 0x1) == 0);  /* half-reg not allowed */
                       unsigned reg = $3 >> 1;
                       assert(variant->compiler->gen < 5);
                       info->wgid = reg;
}

numwg_header:      T_A_NUMWG '(' T_CONSTANT ')' {
                       assert(($3 & 0x1) == 0);  /* half-reg not allowed */
                       unsigned reg = $3 >> 1;
                       info->numwg = reg;
                       /* reserve space in immediates for the actual value to be plugged in later: */
                       if (variant->compiler->gen >= 5)
                          add_const($3, 0, 0, 0, 0);
}

branchstack_header: T_A_BRANCHSTACK const_val { variant->branchstack = $2; }

pvtmem_header: T_A_PVTMEM const_val { variant->pvtmem_size = $2; }

localmem_header: T_A_LOCALMEM const_val { variant->shared_size = $2; }

earlypreamble_header: T_A_EARLYPREAMBLE { variant->early_preamble = 1; }

constlen_header: T_A_CONSTLEN const_val { variant->constlen = $2; }

/* Stubs for now */
in_header:         T_A_IN '(' T_REGISTER ')' T_IDENTIFIER '(' T_IDENTIFIER '=' integer ')' { }

out_header:        T_A_OUT '(' T_REGISTER ')' T_IDENTIFIER '(' T_IDENTIFIER '=' integer ')' { }

/* The only used OPC for texture prefetches seems to be SAM */
tex_header_opc:    T_OP_SAM

tex_header:        T_A_TEX '(' T_REGISTER ')'
                       T_IDENTIFIER '=' integer ',' /* src */
                       T_IDENTIFIER '=' integer ',' /* bindless */
                       T_IDENTIFIER '=' integer ',' /* samp */
                       T_MOD_TEX '=' integer ',' /* tex */
                       T_IDENTIFIER '=' integer ',' /* wrmask */
                       T_IDENTIFIER '=' tex_header_opc /* cmd */ { }

fullnop_start_section: T_A_FULLNOPSTART { is_in_fullnop_section = true; }
fullnop_end_section: T_A_FULLNOPEND { is_in_fullnop_section = false; }
fullsync_start_section: T_A_FULLSYNCSTART { is_in_fullsync_section = true; }
fullsync_end_section: T_A_FULLSYNCEND { is_in_fullsync_section = false; }

iflag:             T_SY   { iflags.flags |= IR3_INSTR_SY; }
|                  T_SS   { iflags.flags |= IR3_INSTR_SS; }
|                  T_JP   { iflags.flags |= IR3_INSTR_JP; }
|                  T_EQ_FLAG { iflags.flags |= IR3_INSTR_EQ; }
|                  T_RPT  { iflags.repeat = $1; }
|                  T_UL   { iflags.flags |= IR3_INSTR_UL; }
|                  T_NOP  { iflags.nop = $1; }
|                  T_EOLM { iflags.flags |= IR3_INSTR_EOLM; }
|                  T_EOGM { iflags.flags |= IR3_INSTR_EOGM; }
|                  T_EOSTSC { iflags.flags |= IR3_INSTR_EOSTSC; }

iflags:
|                  iflag iflags

instrs:            instrs instr
|                  instr

instr:             iflags cat0_instr
|                  iflags cat1_instr
|                  iflags cat2_instr
|                  iflags cat3_instr
|                  iflags cat4_instr
|                  iflags cat5_instr { fixup_cat5_s2en(); }
|                  iflags cat6_instr
|                  iflags cat7_instr
|                  raw_instr
|                  meta_print
|                  label
|                  fullnop_start_section
|                  fullnop_end_section
|                  fullsync_start_section
|                  fullsync_end_section

label:             T_IDENTIFIER ':' { new_label($1); }

cat0_src1:         '!' T_P0        { instr->cat0.inv1 = true; $$ = new_src((62 << 3) + $2, IR3_REG_PREDICATE); }
|                  T_P0            { $$ = new_src((62 << 3) + $1, IR3_REG_PREDICATE); }

cat0_src2:         '!' T_P0        { instr->cat0.inv2 = true; $$ = new_src((62 << 3) + $2, IR3_REG_PREDICATE); }
|                  T_P0            { $$ = new_src((62 << 3) + $1, IR3_REG_PREDICATE); }

cat0_immed:        '#' integer     { instr->cat0.immed = $2; }
|                  '#' T_IDENTIFIER { ralloc_steal(variant->ir, (void *)$2); instr->cat0.target_label = $2; }

cat0_instr:        T_OP_NOP        { new_instr(OPC_NOP); }
|                  T_OP_BR         { new_instr(OPC_BR);   } cat0_src1 ',' cat0_immed
|                  T_OP_BRAO       { new_instr(OPC_BRAO); } cat0_src1 ',' cat0_src2 ',' cat0_immed
|                  T_OP_BRAA       { new_instr(OPC_BRAA); } cat0_src1 ',' cat0_src2 ',' cat0_immed
|                  T_OP_BRAC '.' integer { new_instr(OPC_BRAC)->cat0.idx = $3; } cat0_immed
|                  T_OP_BANY       { new_instr(OPC_BANY); } cat0_src1 ',' cat0_immed
|                  T_OP_BALL       { new_instr(OPC_BALL); } cat0_src1 ',' cat0_immed
|                  T_OP_BRAX       { new_instr(OPC_BRAX); } cat0_immed
|                  T_OP_JUMP       { new_instr(OPC_JUMP); }  cat0_immed
|                  T_OP_CALL       { new_instr(OPC_CALL); }  cat0_immed
|                  T_OP_RET        { new_instr(OPC_RET); }
|                  T_OP_KILL       { new_instr(OPC_KILL); }  cat0_src1
|                  T_OP_END        { new_instr(OPC_END); }
|                  T_OP_EMIT       { new_instr(OPC_EMIT); }
|                  T_OP_CUT        { new_instr(OPC_CUT); }
|                  T_OP_CHMASK     { new_instr(OPC_CHMASK); }
|                  T_OP_CHSH       { new_instr(OPC_CHSH); }
|                  T_OP_FLOW_REV   { new_instr(OPC_FLOW_REV); }
|                  T_OP_BKT        { new_instr(OPC_BKT); }      cat0_immed
|                  T_OP_STKS       { new_instr(OPC_STKS); }
|                  T_OP_STKR       { new_instr(OPC_STKR); }
|                  T_OP_XSET       { new_instr(OPC_XSET); }
|                  T_OP_XCLR       { new_instr(OPC_XCLR); }
|                  T_OP_GETONE     { new_instr(OPC_GETONE); }   cat0_immed
|                  T_OP_DBG        { new_instr(OPC_DBG); }
|                  T_OP_SHPS       { new_instr(OPC_SHPS); }     cat0_immed
|                  T_OP_SHPE       { new_instr(OPC_SHPE); }
|                  T_OP_PREDT      { new_instr(OPC_PREDT); }
|                  T_OP_PREDF      { new_instr(OPC_PREDF); }
|                  T_OP_PREDE      { new_instr(OPC_PREDE); }
|                  T_OP_GETLAST '.' T_W { new_instr(OPC_GETLAST); }   cat0_immed

cat1_opc:          T_OP_MOV '.' T_CAT1_TYPE_TYPE {
                       parse_type_type(new_instr(OPC_MOV), $3);
}
|                  T_OP_COV '.' T_CAT1_TYPE_TYPE {
                       parse_type_type(new_instr(OPC_MOV), $3);
}

cat1_src:          src_reg_or_const_or_rel
|                  immediate_cat1

cat1_movmsk:       T_OP_MOVMSK '.' T_W {
                       new_instr(OPC_MOVMSK);
                       instr->cat1.src_type = TYPE_U32;
                       instr->cat1.dst_type = TYPE_U32;
                   } dst_reg {
                       if (($3 % 32) != 0)
                          yyerror("w# must be multiple of 32");
                       if ($3 < 32)
                          yyerror("w# must be at least 32");

                       int num = $3 / 32;

                       instr->repeat = num - 1;
                       instr->dsts[0]->wrmask = (1 << num) - 1;
                   }

mova_src:          src_reg_or_const_or_rel
|                  immediate_cat1
|                  src_reg_flags immediate_cat1

cat1_mova_flags:
|                  '.' 'u' { iflags.flags |= IR3_INSTR_U; }

cat1_mova1:        T_OP_MOVA1 cat1_mova_flags T_A1 ',' {
                       new_instr(OPC_MOV);
                       instr->cat1.src_type = TYPE_U16;
                       instr->cat1.dst_type = TYPE_U16;
                       new_dst((61 << 3) + 2, IR3_REG_HALF);
                   } mova_src

cat1_mova:         T_OP_MOVA cat1_mova_flags T_A0 ',' {
                       new_instr(OPC_MOV);
                       instr->cat1.src_type = TYPE_S16;
                       instr->cat1.dst_type = TYPE_S16;
                       new_dst((61 << 3), IR3_REG_HALF);
                   } mova_src

cat1_mova_dst_flags:
|                  T_SAT { instr->flags |= IR3_INSTR_SAT; }

cat1_mova_r:       T_OP_MOVA_R cat1_mova_flags { new_instr(OPC_MOV); } cat1_mova_dst_flags T_A0 ',' mova_src ',' integer ',' integer {
                       instr->cat1.src_type = TYPE_S16;
                       instr->cat1.dst_type = TYPE_S16;
                       new_dst((61 << 3), IR3_REG_HALF);
                       instr->cat1.r[0] = $9;
                       instr->cat1.r[1] = $11;
                   }

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

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

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

movs_invocation: uinteger { new_src(0, IR3_REG_IMMED)->uim_val = $1; }
|                src_a0

cat1_movs: T_OP_MOVS '.' T_CAT1_TYPE_TYPE { parse_type_type(new_instr(OPC_MOVS), $3); } dst_reg ',' src_reg ',' movs_invocation

                   /* NOTE: cat1 can also *write* to relative gpr */
cat1_instr:        cat1_movmsk
|                  cat1_mova1
|                  cat1_mova
|                  cat1_mova_r
|                  cat1_swz
|                  cat1_gat
|                  cat1_sct
|                  cat1_opc dst_reg ',' cat1_src
|                  cat1_opc relative_gpr_dst ',' cat1_src
|                  cat1_movs

cat2_opc_1src:     T_OP_ABSNEG_F  { new_instr(OPC_ABSNEG_F); }
|                  T_OP_ABSNEG_S  { new_instr(OPC_ABSNEG_S); }
|                  T_OP_CLZ_B     { new_instr(OPC_CLZ_B); }
|                  T_OP_CLZ_S     { new_instr(OPC_CLZ_S); }
|                  T_OP_SIGN_F    { new_instr(OPC_SIGN_F); }
|                  T_OP_FLOOR_F   { new_instr(OPC_FLOOR_F); }
|                  T_OP_CEIL_F    { new_instr(OPC_CEIL_F); }
|                  T_OP_RNDNE_F   { new_instr(OPC_RNDNE_F); }
|                  T_OP_RNDAZ_F   { new_instr(OPC_RNDAZ_F); }
|                  T_OP_TRUNC_F   { new_instr(OPC_TRUNC_F); }
|                  T_OP_NOT_B     { new_instr(OPC_NOT_B); }
|                  T_OP_BFREV_B   { new_instr(OPC_BFREV_B); }
|                  T_OP_SETRM     { new_instr(OPC_SETRM); }
|                  T_OP_CBITS_B   { new_instr(OPC_CBITS_B); }

cat2_opc_2src_cnd: T_OP_CMPS_F    { new_instr(OPC_CMPS_F); }
|                  T_OP_CMPS_U    { new_instr(OPC_CMPS_U); }
|                  T_OP_CMPS_S    { new_instr(OPC_CMPS_S); }
|                  T_OP_CMPV_F    { new_instr(OPC_CMPV_F); }
|                  T_OP_CMPV_U    { new_instr(OPC_CMPV_U); }
|                  T_OP_CMPV_S    { new_instr(OPC_CMPV_S); }
|                  T_OP_ADD_F T_DIV2 { new_instr(OPC_ADD_F_DIV2); }
|                  T_OP_ADD_F T_MUL2 { new_instr(OPC_ADD_F_MUL2); }
|                  T_OP_MUL_F T_DIV2 { new_instr(OPC_MUL_F_DIV2); }
|                  T_OP_MUL_F T_MUL2 { new_instr(OPC_MUL_F_MUL2); }

cat2_opc_2src:     T_OP_ADD_F     { new_instr(OPC_ADD_F); }
|                  T_OP_MIN_F     { new_instr(OPC_MIN_F); }
|                  T_OP_MAX_F     { new_instr(OPC_MAX_F); }
|                  T_OP_MUL_F     { new_instr(OPC_MUL_F); }
|                  T_OP_ADD_U     { new_instr(OPC_ADD_U); }
|                  T_OP_ADD_S     { new_instr(OPC_ADD_S); }
|                  T_OP_SUB_U     { new_instr(OPC_SUB_U); }
|                  T_OP_SUB_S     { new_instr(OPC_SUB_S); }
|                  T_OP_MIN_U     { new_instr(OPC_MIN_U); }
|                  T_OP_MIN_S     { new_instr(OPC_MIN_S); }
|                  T_OP_MAX_U     { new_instr(OPC_MAX_U); }
|                  T_OP_MAX_S     { new_instr(OPC_MAX_S); }
|                  T_OP_AND_B     { new_instr(OPC_AND_B); }
|                  T_OP_OR_B      { new_instr(OPC_OR_B); }
|                  T_OP_XOR_B     { new_instr(OPC_XOR_B); }
|                  T_OP_MUL_U24   { new_instr(OPC_MUL_U24); }
|                  T_OP_MUL_S24   { new_instr(OPC_MUL_S24); }
|                  T_OP_MULL_U    { new_instr(OPC_MULL_U); }
|                  T_OP_SHL_B     { new_instr(OPC_SHL_B); }
|                  T_OP_SHR_B     { new_instr(OPC_SHR_B); }
|                  T_OP_ASHR_B    { new_instr(OPC_ASHR_B); }
|                  T_OP_BARY_F    { new_instr(OPC_BARY_F); }
|                  T_OP_FLAT_B    { new_instr(OPC_FLAT_B); }
|                  T_OP_MGEN_B    { new_instr(OPC_MGEN_B); }
|                  T_OP_GETBIT_B  { new_instr(OPC_GETBIT_B); }
|                  T_OP_SHB       { new_instr(OPC_SHB); }
|                  T_OP_MSAD      { new_instr(OPC_MSAD); }

cond:              T_LT           { instr->cat2.condition = IR3_COND_LT; }
|                  T_LE           { instr->cat2.condition = IR3_COND_LE; }
|                  T_GT           { instr->cat2.condition = IR3_COND_GT; }
|                  T_GE           { instr->cat2.condition = IR3_COND_GE; }
|                  T_EQ           { instr->cat2.condition = IR3_COND_EQ; }
|                  T_NE           { instr->cat2.condition = IR3_COND_NE; }

cat2_instr:        cat2_opc_1src dst_reg ',' src_reg_or_const_or_rel_or_imm
|                  cat2_opc_2src_cnd '.' cond dst_reg ',' src_reg_or_const_or_rel_or_imm ',' src_reg_or_const_or_rel_or_imm
|                  cat2_opc_2src dst_reg ',' src_reg_or_const_or_rel_or_imm ',' src_reg_or_const_or_rel_or_imm

cat3_dp_signedness:'.' T_MIXED   { instr->cat3.signedness = IR3_SRC_MIXED; }
|                  '.' T_UNSIGNED{ instr->cat3.signedness = IR3_SRC_UNSIGNED; }

cat3_dp_pack:      '.' T_LOW     { instr->cat3.packed = IR3_SRC_PACKED_LOW; }
|                  '.' T_HIGH    { instr->cat3.packed = IR3_SRC_PACKED_HIGH; }

cat3_opc:          T_OP_MAD_F16 T_MUL2 { new_instr(OPC_MAD_F16_MUL2); }
|                  T_OP_MAD_F32 T_MUL2 { new_instr(OPC_MAD_F32_MUL2); }
|                  T_OP_MAD_F16 T_DIV2 { new_instr(OPC_MAD_F16_DIV2); }
|                  T_OP_MAD_F32 T_DIV2 { new_instr(OPC_MAD_F32_DIV2); }
|                  T_OP_MAD_F16   { new_instr(OPC_MAD_F16); }
|                  T_OP_MAD_F32   { new_instr(OPC_MAD_F32); }
|                  T_OP_SEL_F16   { new_instr(OPC_SEL_F16); }
|                  T_OP_SEL_F32   { new_instr(OPC_SEL_F32); }

cat3_imm_reg_opc:  T_OP_SHRM      { new_instr(OPC_SHRM); }
|                  T_OP_SHLM      { new_instr(OPC_SHLM); }
|                  T_OP_SHRG      { new_instr(OPC_SHRG); }
|                  T_OP_SHLG      { new_instr(OPC_SHLG); }
|                  T_OP_ANDG      { new_instr(OPC_ANDG); }

cat3_reg_or_const_or_rel_opc:
|                  T_OP_MAD_U16   { new_instr(OPC_MAD_U16); }
|                  T_OP_MADSH_U16 { new_instr(OPC_MADSH_U16); }
|                  T_OP_MAD_S16   { new_instr(OPC_MAD_S16); }
|                  T_OP_MADSH_M16 { new_instr(OPC_MADSH_M16); }
|                  T_OP_MAD_U24   { new_instr(OPC_MAD_U24); }
|                  T_OP_MAD_S24   { new_instr(OPC_MAD_S24); }
|                  T_OP_SEL_B16   { new_instr(OPC_SEL_B16); }
|                  T_OP_SEL_B32   { new_instr(OPC_SEL_B32); }
|                  T_OP_SEL_S16   { new_instr(OPC_SEL_S16); }
|                  T_OP_SEL_S32   { new_instr(OPC_SEL_S32); }
|                  T_OP_SAD_S16   { new_instr(OPC_SAD_S16); }
|                  T_OP_SAD_S32   { new_instr(OPC_SAD_S32); }

cat3_wmm:          T_OP_WMM       { new_instr(OPC_WMM); }
|                  T_OP_WMM_ACCU  { new_instr(OPC_WMM_ACCU); }

cat3_dp:           T_OP_DP2ACC    { new_instr(OPC_DP2ACC); }
|                  T_OP_DP4ACC    { new_instr(OPC_DP4ACC); }

src_reg_or_const_or_rel_or_flut: src_reg_or_const_or_rel
|                  flut_immed     { new_src(0, IR3_REG_IMMED)->uim_val = $1; }
|                  'h' flut_immed { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = $2; }

cat3_instr:        cat3_opc dst_reg ',' src_reg_or_const_or_rel_or_flut ',' src_reg_or_const ',' src_reg_or_const_or_rel_or_flut
|                  cat3_reg_or_const_or_rel_opc dst_reg ',' src_reg_or_const_or_rel_or_imm ',' src_reg_or_const ',' src_reg_or_const_or_rel_or_imm
|                  cat3_imm_reg_opc dst_reg ',' src_reg_or_rel_or_imm ',' src_reg_or_const ',' src_reg_or_rel_or_imm
|                  cat3_wmm         dst_reg ',' src_reg_gpr ',' src_reg ',' immediate
|                  cat3_dp cat3_dp_signedness cat3_dp_pack dst_reg ',' src_reg_or_rel_or_imm ',' src_reg_or_const ',' src_reg_or_rel_or_imm

cat4_opc:          T_OP_RCP       { new_instr(OPC_RCP); }
|                  T_OP_RSQ       { new_instr(OPC_RSQ); }
|                  T_OP_LOG2      { new_instr(OPC_LOG2); }
|                  T_OP_EXP2      { new_instr(OPC_EXP2); }
|                  T_OP_SIN       { new_instr(OPC_SIN); }
|                  T_OP_COS       { new_instr(OPC_COS); }
|                  T_OP_SQRT      { new_instr(OPC_SQRT); }
|                  T_OP_HRSQ      { new_instr(OPC_HRSQ); }
|                  T_OP_HLOG2     { new_instr(OPC_HLOG2); }
|                  T_OP_HEXP2     { new_instr(OPC_HEXP2); }

cat4_instr:        cat4_opc dst_reg ',' src_reg_or_const_or_rel_or_imm

cat5_opc_dsxypp:   T_OP_DSXPP_1   { new_instr(OPC_DSXPP_1)->cat5.type = TYPE_F32; }
|                  T_OP_DSYPP_1   { new_instr(OPC_DSYPP_1)->cat5.type = TYPE_F32; }

cat5_opc_isam:     T_OP_ISAM      { new_instr(OPC_ISAM)->flags |= IR3_INSTR_INV_1D; }

cat5_opc:          T_OP_ISAML     { new_instr(OPC_ISAML); }
|                  T_OP_ISAMM     { new_instr(OPC_ISAMM); }
|                  T_OP_SAM       { new_instr(OPC_SAM); }
|                  T_OP_SAMB      { new_instr(OPC_SAMB); }
|                  T_OP_SAML      { new_instr(OPC_SAML); }
|                  T_OP_SAMGQ     { new_instr(OPC_SAMGQ); }
|                  T_OP_GETLOD    { new_instr(OPC_GETLOD); }
|                  T_OP_CONV      { new_instr(OPC_CONV); }
|                  T_OP_CONVM     { new_instr(OPC_CONVM); }
|                  T_OP_GETSIZE   { new_instr(OPC_GETSIZE); }
|                  T_OP_GETBUF    { new_instr(OPC_GETBUF); }
|                  T_OP_GETPOS    { new_instr(OPC_GETPOS); }
|                  T_OP_GETINFO   { new_instr(OPC_GETINFO); }
|                  T_OP_DSX       { new_instr(OPC_DSX); }
|                  T_OP_DSY       { new_instr(OPC_DSY); }
|                  T_OP_GATHER4R  { new_instr(OPC_GATHER4R); }
|                  T_OP_GATHER4G  { new_instr(OPC_GATHER4G); }
|                  T_OP_GATHER4B  { new_instr(OPC_GATHER4B); }
|                  T_OP_GATHER4A  { new_instr(OPC_GATHER4A); }
|                  T_OP_SAMGP0    { new_instr(OPC_SAMGP0); }
|                  T_OP_SAMGP1    { new_instr(OPC_SAMGP1); }
|                  T_OP_SAMGP2    { new_instr(OPC_SAMGP2); }
|                  T_OP_SAMGP3    { new_instr(OPC_SAMGP3); }
|                  T_OP_RGETPOS   { new_instr(OPC_RGETPOS); }
|                  T_OP_RGETINFO  { new_instr(OPC_RGETINFO); }
|                  T_OP_BRCST_A   { new_instr(OPC_BRCST_ACTIVE); }
|                  T_OP_QSHUFFLE_BRCST { new_instr(OPC_QUAD_SHUFFLE_BRCST); }
|                  T_OP_QSHUFFLE_H     { new_instr(OPC_QUAD_SHUFFLE_HORIZ); }
|                  T_OP_QSHUFFLE_V     { new_instr(OPC_QUAD_SHUFFLE_VERT); }
|                  T_OP_QSHUFFLE_DIAG  { new_instr(OPC_QUAD_SHUFFLE_DIAG); }
|                  T_OP_IMG_BINDLESS_PCMN { new_instr(OPC_IMG_BINDLESS_PCMN); }
|                  T_OP_IMG_BINDLESS_HOF      { new_instr(OPC_IMG_BINDLESS_HOF); }
|                  T_OP_IMG_BINDLESS     { new_instr(OPC_IMG_BINDLESS); }

cat5_matchmode:    '.' T_SAD   { instr->cat5.match_mode = IR3_MATCH_MODE_SAD; }
|                  '.' T_SSD   { instr->cat5.match_mode = IR3_MATCH_MODE_SSD; }

cat5_flag:         '.' T_3D       { instr->flags |= IR3_INSTR_3D; }
|                  '.' 'a'        { instr->flags |= IR3_INSTR_A; }
|                  '.' 'o'        { instr->flags |= IR3_INSTR_O; }
|                  '.' 'p'        { instr->flags |= IR3_INSTR_P; }
|                  '.' 's'        { instr->flags |= IR3_INSTR_S; }
|                  '.' T_S2EN     { instr->flags |= IR3_INSTR_S2EN; }
|                  '.' T_1D       { instr->flags &= ~IR3_INSTR_INV_1D; }
|                  '.' T_UNIFORM  { }
|                  '.' T_NONUNIFORM  { instr->flags |= IR3_INSTR_NONUNIF; }
|                  '.' T_BASE     { instr->flags |= IR3_INSTR_B; instr->cat5.tex_base = $2; }
|                  '.' T_W        { instr->cat5.cluster_size = $2; }
|                  '.' T_RCK      { instr->flags |= IR3_INSTR_RCK; }
|                  '.' T_CLP      { instr->flags |= IR3_INSTR_CLP; }
|                  cat5_matchmode
cat5_flags:
|                  cat5_flag cat5_flags

cat5_samp:         T_SAMP         { instr->cat5.samp = $1; }
cat5_tex:          T_TEX          { instr->cat5.tex = $1; }
cat5_type:         '(' type ')'   { instr->cat5.type = $2; }
|                                 { } /* type does not exist for rck */
cat5_a1:           src_a1         { instr->flags |= IR3_INSTR_A1EN; }

cat5_samp_tex:     src_gpr
|                  cat5_samp ',' cat5_tex
|                  cat5_samp
|                  cat5_tex

cat5_samp_tex_all: cat5_samp_tex
|                  cat5_samp ',' cat5_a1
|                  cat5_tex ',' cat5_a1
|                  src_gpr ',' cat5_a1

cat5_instr:        cat5_opc_dsxypp cat5_flags dst_reg ',' src_gpr
|                  cat5_opc cat5_flags cat5_type dst_reg ',' src_gpr ',' src_gpr ',' cat5_samp_tex_all
|                  cat5_opc cat5_flags cat5_type dst_reg ',' src_gpr ',' cat5_samp_tex_all
|                  cat5_opc cat5_flags cat5_type dst_reg ',' cat5_samp_tex
|                  cat5_opc cat5_flags cat5_type dst_reg
|                  cat5_opc_isam cat5_flags cat5_type dst_reg ',' src_gpr ',' src_gpr ',' cat5_samp_tex_all
|                  cat5_opc_isam cat5_flags cat5_type dst_reg ',' src_gpr ',' cat5_samp_tex_all
|                  cat5_opc_isam '.' 'v' cat5_flags cat5_type dst_reg ',' src_gpr src_uoffset ',' cat5_samp_tex_all { instr->flags |= IR3_INSTR_V; }
|                  T_OP_TCINV { new_instr(OPC_TCINV); }

cat6_typed:        '.' T_UNTYPED  { instr->cat6.typed = 0; }
|                  '.' T_TYPED    { instr->cat6.typed = 1; }

cat6_dim:          '.' T_1D  { instr->cat6.d = 1; }
|                  '.' T_2D  { instr->cat6.d = 2; }
|                  '.' T_3D  { instr->cat6.d = 3; }
|                  '.' T_4D  { instr->cat6.d = 4; }

cat6_type:         '.' type  { instr->cat6.type = $2; }
cat6_imm_offset:   offset    { new_src(0, IR3_REG_IMMED)->iim_val = $1; }
cat6_offset:       cat6_imm_offset
|                  '+' src
cat6_dst_offset:   offset    { instr->cat6.dst_offset = $1; }
|                  '+' src

cat6_immed:        integer   { instr->cat6.iim_val = $1; }

cat6_immed_or_gpr: immediate
|                  src_gpr

cat6_src_shift: '<' '<' integer {$$ = $3;}
|                               {$$ = 0;}

cat6_a6xx_global_address_pt2:
                   '(' '(' '(' src cat6_src_shift ')' offset ')' '<' '<' integer ')' {
                        illegal_syntax_from(7, "pre-a7xx global offset syntax");
                        new_src(0, IR3_REG_IMMED)->uim_val = $5;
                        new_src(0, IR3_REG_IMMED)->uim_val = $7;
                   }
|                  '(' '(' src cat6_src_shift offset ')' '<' '<' integer ')' {
                        illegal_syntax_from(7, "pre-a7xx global offset syntax");
                        new_src(0, IR3_REG_IMMED)->uim_val = $4;
                        new_src(0, IR3_REG_IMMED)->uim_val = $5;
                   }
|                  '(' src cat6_src_shift ')' {
                        illegal_syntax_from(7, "pre-a7xx global offset syntax");
                        // The shift contains the implicit type shift, subtract it.
                        new_src(0, IR3_REG_IMMED)->uim_val = $3 - cat6_type_shift();
                        new_src(0, IR3_REG_IMMED)->uim_val = 0;
                   }
|                  src offset {
                        if (variant->compiler->gen < 7) {
                            new_src(0, IR3_REG_IMMED)->uim_val = 0;
                            new_src(0, IR3_REG_IMMED)->uim_val = $2;
                        } else {
                            // Dummy src to smooth the difference between a6xx and a7xx
                            new_src(0, IR3_REG_IMMED)->uim_val = 0;
                            new_src(0, IR3_REG_IMMED)->uim_val = $2;
                        }
                   }

cat6_a6xx_global_address:
                   src_reg_or_const '+' cat6_a6xx_global_address_pt2

cat6_load:         T_OP_LDG   { new_instr(OPC_LDG); }   cat6_type dst_reg ',' 'g' '[' src cat6_offset ']' ',' immediate
|                  T_OP_LDG_A { new_instr(OPC_LDG_A); } cat6_type dst_reg ',' 'g' '[' cat6_a6xx_global_address ']' ',' immediate
|                  T_OP_LDG_K { new_instr(OPC_LDG_K); } cat6_type 'c' '[' const_dst ']' ',' 'g' '[' src cat6_offset ']' ',' cat6_immed_or_gpr
|                  T_OP_LDP   { new_instr(OPC_LDP); }   cat6_type dst_reg ',' 'p' '[' src cat6_offset ']' ',' immediate
|                  T_OP_LDL   { new_instr(OPC_LDL); }   cat6_type dst_reg ',' 'l' '[' src cat6_offset ']' ',' immediate
|                  T_OP_LDLW  { new_instr(OPC_LDLW); }  cat6_type dst_reg ',' 'l' '[' src cat6_offset ']' ',' immediate
|                  T_OP_LDLV  { new_instr(OPC_LDLV); }  cat6_type dst_reg ',' 'l' '[' integer ']' {
                       new_src(0, IR3_REG_IMMED)->iim_val = $8;
                   } ',' immediate

cat6_store:        T_OP_STG   { new_instr(OPC_STG); dummy_dst(); }   cat6_type 'g' '[' src cat6_imm_offset ']' ',' src ',' immediate
|                  T_OP_STG_A { new_instr(OPC_STG_A); dummy_dst(); } cat6_type 'g' '[' cat6_a6xx_global_address ']' ',' src ',' immediate
|                  T_OP_STP  { new_instr(OPC_STP); dummy_dst(); }  cat6_type 'p' '[' src cat6_dst_offset ']' ',' src ',' immediate
|                  T_OP_STL  { new_instr(OPC_STL); dummy_dst(); }  cat6_type 'l' '[' src cat6_dst_offset ']' ',' src ',' immediate
|                  T_OP_STLW { new_instr(OPC_STLW); dummy_dst(); } cat6_type 'l' '[' src cat6_dst_offset ']' ',' src ',' immediate

cat6_loadib:       T_OP_LDIB { new_instr(OPC_LDIB); } cat6_typed cat6_dim cat6_type '.' cat6_immed dst_reg ',' 'g' '[' immediate ']' ',' src ',' src
cat6_storeib:      T_OP_STIB { new_instr(OPC_STIB); dummy_dst(); } cat6_typed cat6_dim cat6_type '.' cat6_immed'g' '[' immediate ']' ',' src ',' src ',' src

cat6_prefetch:     T_OP_PREFETCH { new_instr(OPC_PREFETCH); new_dst(0,0); /* dummy dst */ } 'g' '[' src cat6_offset ']' ',' cat6_immed

cat6_atomic_opc:   T_OP_ATOMIC_ADD     { new_instr(OPC_ATOMIC_ADD); }
|                  T_OP_ATOMIC_SUB     { new_instr(OPC_ATOMIC_SUB); }
|                  T_OP_ATOMIC_XCHG    { new_instr(OPC_ATOMIC_XCHG); }
|                  T_OP_ATOMIC_INC     { new_instr(OPC_ATOMIC_INC); }
|                  T_OP_ATOMIC_DEC     { new_instr(OPC_ATOMIC_DEC); }
|                  T_OP_ATOMIC_CMPXCHG { new_instr(OPC_ATOMIC_CMPXCHG); }
|                  T_OP_ATOMIC_MIN     { new_instr(OPC_ATOMIC_MIN); }
|                  T_OP_ATOMIC_MAX     { new_instr(OPC_ATOMIC_MAX); }
|                  T_OP_ATOMIC_AND     { new_instr(OPC_ATOMIC_AND); }
|                  T_OP_ATOMIC_OR      { new_instr(OPC_ATOMIC_OR); }
|                  T_OP_ATOMIC_XOR     { new_instr(OPC_ATOMIC_XOR); }

cat6_a3xx_atomic_opc:   T_OP_ATOMIC_S_ADD     { new_instr(OPC_ATOMIC_S_ADD); }
|                       T_OP_ATOMIC_S_SUB     { new_instr(OPC_ATOMIC_S_SUB); }
|                       T_OP_ATOMIC_S_XCHG    { new_instr(OPC_ATOMIC_S_XCHG); }
|                       T_OP_ATOMIC_S_INC     { new_instr(OPC_ATOMIC_S_INC); }
|                       T_OP_ATOMIC_S_DEC     { new_instr(OPC_ATOMIC_S_DEC); }
|                       T_OP_ATOMIC_S_CMPXCHG { new_instr(OPC_ATOMIC_S_CMPXCHG); }
|                       T_OP_ATOMIC_S_MIN     { new_instr(OPC_ATOMIC_S_MIN); }
|                       T_OP_ATOMIC_S_MAX     { new_instr(OPC_ATOMIC_S_MAX); }
|                       T_OP_ATOMIC_S_AND     { new_instr(OPC_ATOMIC_S_AND); }
|                       T_OP_ATOMIC_S_OR      { new_instr(OPC_ATOMIC_S_OR); }
|                       T_OP_ATOMIC_S_XOR     { new_instr(OPC_ATOMIC_S_XOR); }

cat6_a6xx_atomic_opc:   T_OP_ATOMIC_G_ADD     { new_instr(OPC_ATOMIC_G_ADD); }
|                       T_OP_ATOMIC_G_SUB     { new_instr(OPC_ATOMIC_G_SUB); }
|                       T_OP_ATOMIC_G_XCHG    { new_instr(OPC_ATOMIC_G_XCHG); }
|                       T_OP_ATOMIC_G_INC     { new_instr(OPC_ATOMIC_G_INC); }
|                       T_OP_ATOMIC_G_DEC     { new_instr(OPC_ATOMIC_G_DEC); }
|                       T_OP_ATOMIC_G_CMPXCHG { new_instr(OPC_ATOMIC_G_CMPXCHG); }
|                       T_OP_ATOMIC_G_MIN     { new_instr(OPC_ATOMIC_G_MIN); }
|                       T_OP_ATOMIC_G_MAX     { new_instr(OPC_ATOMIC_G_MAX); }
|                       T_OP_ATOMIC_G_AND     { new_instr(OPC_ATOMIC_G_AND); }
|                       T_OP_ATOMIC_G_OR      { new_instr(OPC_ATOMIC_G_OR); }
|                       T_OP_ATOMIC_G_XOR     { new_instr(OPC_ATOMIC_G_XOR); }

cat6_a3xx_atomic_s: cat6_a3xx_atomic_opc cat6_typed cat6_dim cat6_type '.' cat6_immed '.' 'g' dst_reg ',' 'g' '[' cat6_reg_or_immed ']' ',' src ',' src ',' src

cat6_a6xx_atomic_g: cat6_a6xx_atomic_opc cat6_typed cat6_dim cat6_type '.' cat6_immed '.' 'g' dst_reg ',' src ',' src

cat6_atomic_l:     cat6_atomic_opc cat6_typed cat6_dim cat6_type '.' cat6_immed '.' 'l' dst_reg ',' 'l' '[' cat6_reg_or_immed ']' ',' src

cat6_atomic:       cat6_atomic_l
|                  cat6_a3xx_atomic_s
|                  cat6_a6xx_atomic_g

cat6_ibo_opc_1src: T_OP_RESINFO   { new_instr(OPC_RESINFO); }

cat6_ibo_opc_ldgb: T_OP_LDGB      { new_instr(OPC_LDGB); }
cat6_ibo_opc_stgb: T_OP_STGB      { new_instr(OPC_STGB); }

cat6_ibo:          cat6_ibo_opc_1src cat6_type cat6_dim dst_reg ',' 'g' '[' cat6_reg_or_immed ']'
|                  cat6_ibo_opc_ldgb cat6_typed cat6_dim cat6_type '.' cat6_immed dst_reg ',' 'g' '[' cat6_reg_or_immed ']' ',' src ',' src
|                  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

cat6_id_opc:
                   T_OP_GETSPID { new_instr(OPC_GETSPID); }
|                  T_OP_GETWID  { new_instr(OPC_GETWID); }
|                  T_OP_GETFIBERID { new_instr(OPC_GETFIBERID); }

cat6_id:           cat6_id_opc cat6_type dst_reg

cat6_bindless_base:
|                  '.' T_BASE { instr->flags |= IR3_INSTR_B; instr->cat6.base = $2; }

cat6_bindless_mode: T_IMM cat6_bindless_base
|                  T_UNIFORM cat6_bindless_base
|                  T_NONUNIFORM cat6_bindless_base { instr->flags |= IR3_INSTR_NONUNIF; }

cat6_reg_or_immed: src
|                  integer { new_src(0, IR3_REG_IMMED)->iim_val = $1; }

cat6_bindless_ibo_opc_1src: T_OP_RESINFO_B       { new_instr(OPC_RESINFO); }
|                           T_OP_RESBASE         { new_instr(OPC_RESBASE); }

cat6_bindless_ibo_opc_2src: T_OP_ATOMIC_B_ADD        { new_instr(OPC_ATOMIC_B_ADD); dummy_dst(); }
|                  T_OP_ATOMIC_B_SUB        { new_instr(OPC_ATOMIC_B_SUB); dummy_dst(); }
|                  T_OP_ATOMIC_B_XCHG       { new_instr(OPC_ATOMIC_B_XCHG); dummy_dst(); }
|                  T_OP_ATOMIC_B_INC        { new_instr(OPC_ATOMIC_B_INC); dummy_dst(); }
|                  T_OP_ATOMIC_B_DEC        { new_instr(OPC_ATOMIC_B_DEC); dummy_dst(); }
|                  T_OP_ATOMIC_B_CMPXCHG    { new_instr(OPC_ATOMIC_B_CMPXCHG); dummy_dst(); }
|                  T_OP_ATOMIC_B_MIN        { new_instr(OPC_ATOMIC_B_MIN); dummy_dst(); }
|                  T_OP_ATOMIC_B_MAX        { new_instr(OPC_ATOMIC_B_MAX); dummy_dst(); }
|                  T_OP_ATOMIC_B_AND        { new_instr(OPC_ATOMIC_B_AND); dummy_dst(); }
|                  T_OP_ATOMIC_B_OR         { new_instr(OPC_ATOMIC_B_OR); dummy_dst(); }
|                  T_OP_ATOMIC_B_XOR        { new_instr(OPC_ATOMIC_B_XOR); dummy_dst(); }

cat6_bindless_ibo_opc_3src: T_OP_STIB_B     { new_instr(OPC_STIB); dummy_dst(); }

cat6_bindless_ibo_opc_3src_dst: T_OP_LDIB_B              { new_instr(OPC_LDIB); }

cat6_rck:
|                  T_RCK '.' { instr->flags |= IR3_INSTR_RCK; }

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
|                  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]); }
|                  cat6_bindless_ibo_opc_3src cat6_typed cat6_dim cat6_type '.' cat6_immed '.' cat6_bindless_mode src_reg ',' cat6_reg_or_immed src_uoffset ',' cat6_reg_or_immed { swap(instr->srcs[0], instr->srcs[3]); }
|                  cat6_bindless_ibo_opc_3src_dst cat6_typed cat6_dim cat6_type '.' cat6_rck cat6_immed '.' cat6_bindless_mode dst_reg ',' cat6_reg_or_immed src_uoffset ',' cat6_reg_or_immed { swap(instr->srcs[0], instr->srcs[2]); swap(instr->srcs[1], instr->srcs[2]); }

cat6_bindless_ldc_opc: T_OP_LDC  { new_instr(OPC_LDC); }

/* This is separated from the opcode to avoid lookahead/shift-reduce conflicts */
cat6_bindless_ldc_middle:
                        T_OFFSET '.' cat6_immed '.' cat6_bindless_mode dst_reg { instr->cat6.d = $1; }
|                       'u' '.' T_OFFSET '.' cat6_immed '.' cat6_bindless_mode dst_reg { instr->flags |= IR3_INSTR_U; instr->cat6.d = $3; }
|                       cat6_immed '.' 'k' '.' cat6_bindless_mode 'c' '[' T_A1 ']' { instr->opc = OPC_LDC_K; }

cat6_bindless_ldc: cat6_bindless_ldc_opc '.' cat6_bindless_ldc_middle ',' cat6_reg_or_immed ',' cat6_reg_or_immed {
                      instr->cat6.type = TYPE_U32;
                      /* TODO cleanup ir3 src order: */
                      swap(instr->srcs[0], instr->srcs[1]);
                   }

const_dst:        integer { new_src(0, IR3_REG_IMMED)->iim_val = $1; }
|                 T_A1 { new_src(0, IR3_REG_IMMED)->iim_val = 0; instr->flags |= IR3_INSTR_A1EN; }
|                 T_A1 '+' integer { new_src(0, IR3_REG_IMMED)->iim_val = $3; instr->flags |= IR3_INSTR_A1EN; }

cat6_stc:
              T_OP_STC  { new_instr(OPC_STC); }  cat6_type 'c' '[' const_dst ']' ',' src_reg ',' cat6_immed
|             T_OP_STSC { new_instr(OPC_STSC); } cat6_type 'c' '[' const_dst ']' ',' immediate ',' cat6_immed

cat6_shfl_mode: T_MOD_XOR   { instr->cat6.shfl_mode = SHFL_XOR;   }
|               T_MOD_UP    { instr->cat6.shfl_mode = SHFL_UP;    }
|               T_MOD_DOWN  { instr->cat6.shfl_mode = SHFL_DOWN;  }
|               T_MOD_RUP   { instr->cat6.shfl_mode = SHFL_RUP;   }
|               T_MOD_RDOWN { instr->cat6.shfl_mode = SHFL_RDOWN; }
                /* This is added to make it easy to experiment with the
                 * unknown modes.
                 */
|               integer     { instr->cat6.shfl_mode = $1; }

cat6_shfl:
         T_OP_SHFL { new_instr(OPC_SHFL); } '.' cat6_shfl_mode cat6_type dst ',' src ',' cat6_reg_or_immed

cat6_ray_intersection: T_OP_RAY_INTERSECTION {
                     new_instr(OPC_RAY_INTERSECTION);
                     } dst_reg ',' '[' src_reg_or_const ']' ',' src_reg ',' src_reg ',' src_reg

cat6_todo:         T_OP_G2L                 { new_instr(OPC_G2L); }
|                  T_OP_L2G                 { new_instr(OPC_L2G); }
|                  T_OP_RESFMT              { new_instr(OPC_RESFMT); }

cat6_instr:        cat6_load
|                  cat6_loadib
|                  cat6_store
|                  cat6_storeib
|                  cat6_prefetch
|                  cat6_atomic
|                  cat6_ibo
|                  cat6_id
|                  cat6_bindless_ldc
|                  cat6_bindless_ibo
|                  cat6_stc
|                  cat6_shfl
|                  cat6_ray_intersection
|                  cat6_todo

cat7_scope:        '.' 'w'  { instr->cat7.w = true; }
|                  '.' 'r'  { instr->cat7.r = true; }
|                  '.' 'l'  { instr->cat7.l = true; }
|                  '.' 'g'  { instr->cat7.g = true; }

cat7_scopes:
|                  cat7_scope cat7_scopes

cat7_barrier:      T_OP_BAR                { new_instr(OPC_BAR); } cat7_scopes
|                  T_OP_FENCE              { new_instr(OPC_FENCE); } cat7_scopes

cat7_data_cache:   T_OP_DCCLN              { new_instr(OPC_DCCLN); }
|                  T_OP_DCINV              { new_instr(OPC_DCINV); }
|                  T_OP_DCFLU              { new_instr(OPC_DCFLU); }

cat7_alias_dst:    dst_reg
|                  T_RT { new_dst($1, IR3_REG_RT); }

cat7_alias_src:    src_reg_or_const
|                  immediate_cat1

cat7_alias_scope: T_MOD_TEX	{ instr->cat7.alias_scope = ALIAS_TEX; }
|                 T_MOD_MEM	{ instr->cat7.alias_scope = ALIAS_MEM; }
|                 T_MOD_RT	{ instr->cat7.alias_scope = ALIAS_RT; }

cat7_alias_int_type:   T_TYPE_B16
|                      T_TYPE_B32

cat7_alias_float_type: T_TYPE_F16
|                      T_TYPE_F32

cat7_alias_type:  cat7_alias_int_type
|                 cat7_alias_float_type { instr->cat7.alias_type_float = true; }

cat7_alias_table_size_minus_one: T_INT { instr->cat7.alias_table_size_minus_one = $1; }

cat7_instr:        cat7_barrier
|                  cat7_data_cache
|                  T_OP_SLEEP              { new_instr(OPC_SLEEP); }
|                  T_OP_CCINV              { new_instr(OPC_CCINV); }
|                  T_OP_ICINV              { new_instr(OPC_ICINV); }
|                  T_OP_LOCK               { new_instr(OPC_LOCK); }
|                  T_OP_UNLOCK             { new_instr(OPC_UNLOCK); }
|                  T_OP_ALIAS {
                       new_instr(OPC_ALIAS);
                   } '.' cat7_alias_scope '.' cat7_alias_type '.' cat7_alias_table_size_minus_one cat7_alias_dst ',' cat7_alias_src

raw_instr: T_RAW   {new_instr(OPC_META_RAW)->raw.value = $1;}

meta_print_regs:	meta_print_reg
|					meta_print_reg meta_print_regs

meta_print_reg: ',' T_REGISTER {
	meta_print_data.regs_to_dump[meta_print_data.regs_count++] = $2;
}

meta_print_start: T_OP_PRINT T_REGISTER {
	meta_print_data.reg_address_lo = $2;
	meta_print_data.reg_address_hi = $2 + 2;
	meta_print_data.reg_tmp = $2 + 4;
	meta_print_data.regs_count = 0;
}

meta_print: meta_print_start meta_print_regs {
	/* low */
	new_instr(OPC_MOV);
	instr->cat1.src_type = TYPE_U32;
	instr->cat1.dst_type = TYPE_U32;
	new_dst(meta_print_data.reg_address_lo, 0);
	new_src(0, IR3_REG_IMMED)->uim_val = info->shader_print_buffer_iova & 0xffffffff;

	/* high */
	new_instr(OPC_MOV);
	instr->cat1.src_type = TYPE_U32;
	instr->cat1.dst_type = TYPE_U32;
	new_dst(meta_print_data.reg_address_hi, 0);
	new_src(0, IR3_REG_IMMED)->uim_val = info->shader_print_buffer_iova >> 32;

	/* offset */
	new_instr(OPC_MOV);
	instr->cat1.src_type = TYPE_U32;
	instr->cat1.dst_type = TYPE_U32;
	new_dst(meta_print_data.reg_tmp, 0);
	new_src(0, IR3_REG_IMMED)->uim_val = 4 * meta_print_data.regs_count;

	new_instr(OPC_NOP);
	instr->repeat = 5;

	/* Increment and get current offset into print buffer */
	new_instr(OPC_ATOMIC_G_ADD);
	instr->cat6.d = 1;
	instr->cat6.typed = 0;
	instr->cat6.type = TYPE_U32;
	instr->cat6.iim_val = 1;

	new_dst(meta_print_data.reg_address_lo, 0);
	new_src(meta_print_data.reg_address_lo, 0);
	new_src(meta_print_data.reg_tmp, 0);

	/* Store all regs */
	for (uint32_t i = 0; i < meta_print_data.regs_count; i++) {
		new_instr(OPC_STG);
		dummy_dst();
		instr->cat6.type = TYPE_U32;
		instr->flags = IR3_INSTR_SY;
		new_src(meta_print_data.reg_address_lo, 0);
		new_src(0, IR3_REG_IMMED)->iim_val = 0;
		new_src(meta_print_data.regs_to_dump[i], IR3_REG_R);
		new_src(0, IR3_REG_IMMED)->iim_val = 1;

		new_instr(OPC_ADD_U);
		instr->flags = IR3_INSTR_SS;
		new_dst(meta_print_data.reg_address_lo, 0);
		new_src(meta_print_data.reg_address_lo, 0);
		new_src(0, IR3_REG_IMMED)->uim_val = 4;

		new_instr(OPC_NOP);
		instr->repeat = 5;
	}
}

src_gpr:           T_REGISTER     { $$ = new_src($1, 0); }
src_a0:            T_A0           { $$ = new_src((61 << 3), IR3_REG_HALF); }
src_a1:            T_A1           { $$ = new_src((61 << 3) + 1, IR3_REG_HALF); }
src_p0:            T_P0           { $$ = new_src((62 << 3) + $1, IR3_REG_PREDICATE); }

src:               src_gpr
|                  src_a0
|                  src_a1
|                  src_p0

dst:               T_REGISTER     { $$ = new_dst($1, 0); }
|                  T_A0           { $$ = new_dst((61 << 3), IR3_REG_HALF); }
|                  T_A1           { $$ = new_dst((61 << 3) + 1, IR3_REG_HALF); }
|                  T_P0           { $$ = new_dst((62 << 3) + $1, IR3_REG_PREDICATE); }
|                  T_UP0          { $$ = new_dst((62 << 3) + $1, IR3_REG_PREDICATE | IR3_REG_UNIFORM); }

const:             T_CONSTANT     { $$ = new_src($1, IR3_REG_CONST); }

dst_reg_flag:      T_EVEN         { instr->cat1.round = ROUND_EVEN; }
|                  T_POS_INFINITY { instr->cat1.round = ROUND_POS_INF; }
|                  T_NEG_INFINITY { instr->cat1.round = ROUND_NEG_INF; }
|                  T_SAT          { instr->flags |= IR3_INSTR_SAT; }
|                  T_EI           { rflags.flags |= IR3_REG_EI; }
|                  T_WRMASK       { rflags.wrmask = $1; }

dst_reg_flags:     dst_reg_flag
|                  dst_reg_flag dst_reg_flags

                   /* note: destination registers are always incremented in repeat */
dst_reg:           dst                 { $1->flags |= IR3_REG_R; }
|                  dst_reg_flags dst   { $2->flags |= IR3_REG_R; }

src_reg_flag:      T_ABSNEG       { rflags.flags |= IR3_REG_ABS|IR3_REG_NEGATE; }
|                  T_NEG          { rflags.flags |= IR3_REG_NEGATE; }
|                  T_ABS          { rflags.flags |= IR3_REG_ABS; }
|                  T_R            { rflags.flags |= IR3_REG_R; }
|                  T_LAST         { rflags.flags |= IR3_REG_LAST_USE; }

src_reg_flags:     src_reg_flag
|                  src_reg_flag src_reg_flags

src_reg:           src
|                  src_reg_flags src

src_reg_gpr:       src_reg
|                  relative_gpr_src

src_const:         const
|                  src_reg_flags const

src_reg_or_const:  src_reg
|                  src_const

src_reg_or_const_or_rel: src_reg_or_const
|                  relative
|                  src_reg_flags relative

src_reg_or_const_or_rel_or_imm: src_reg_or_const_or_rel
|                  src_reg_flags immediate
|                  immediate

src_reg_or_rel_or_imm: src_reg
|                  relative
|                  immediate

uoffset:           { $$ = 0; }
|                  '+' integer { $$ = $2; }

offset:            uoffset
|                  '-' integer { $$ = -$2; }

src_uoffset:       uoffset { new_src(0, IR3_REG_IMMED)->uim_val = $1; if ($1) instr->flags |= IR3_INSTR_IMM_OFFSET; }

relative_gpr_src:  'r' '<' T_A0 offset '>'  { new_src(0, IR3_REG_RELATIV)->array.offset = $4; }
|                  T_HR '<' T_A0 offset '>'  { new_src(0, IR3_REG_RELATIV | IR3_REG_HALF)->array.offset = $4; }

relative_gpr_dst:  'r' '<' T_A0 offset '>'  { new_dst(0, IR3_REG_RELATIV)->array.offset = $4; }
|                  T_HR '<' T_A0 offset '>'  { new_dst(0, IR3_REG_RELATIV | IR3_REG_HALF)->array.offset = $4; }

relative_const:    'c' '<' T_A0 offset '>'  { new_src(0, IR3_REG_RELATIV | IR3_REG_CONST)->array.offset = $4; }
|                  T_HC '<' T_A0 offset '>'  { new_src(0, IR3_REG_RELATIV | IR3_REG_CONST | IR3_REG_HALF)->array.offset = $4; }

relative:          relative_gpr_src
|                  relative_const

/* cat1 immediates differ slighly in the floating point case from the cat2
 * case which can only encode certain predefined values (ie. and index into
 * the FLUT table)
 *
 * We have to special cases a few FLUT values which are ambiguous from the
 * lexer PoV.
 */
immediate_cat1:    integer             { new_src(0, IR3_REG_IMMED)->iim_val = type_size(instr->cat1.src_type) < 32 ? $1 & 0xffff : $1; }
|                  '(' integer ')'     { new_src(0, IR3_REG_IMMED)->iim_val = $2; }
|                  '(' float ')'       { new_src(0, IR3_REG_IMMED)->fim_val = $2; }
|                  'h' '(' integer ')' { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->iim_val = $3 & 0xffff; }
|                  'h' '(' float ')'   { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = _mesa_float_to_half($3); }
|                  'h' T_FLUT_0_0      { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = _mesa_float_to_half(0.0); }
|                  'h' T_FLUT_0_5      { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = _mesa_float_to_half(0.5); }
|                  'h' T_FLUT_1_0      { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = _mesa_float_to_half(1.0); }
|                  'h' T_FLUT_2_0      { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = _mesa_float_to_half(2.0); }
|                  'h' T_FLUT_4_0      { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = _mesa_float_to_half(4.0); }
|                  '(' T_NAN ')'       { new_src(0, IR3_REG_IMMED)->fim_val = NAN; }
|                  '(' T_INF ')'       { new_src(0, IR3_REG_IMMED)->fim_val = INFINITY; }
|                  T_FLUT_0_0          { new_src(0, IR3_REG_IMMED)->fim_val = 0.0; }
|                  T_FLUT_0_5          { new_src(0, IR3_REG_IMMED)->fim_val = 0.5; }
|                  T_FLUT_1_0          { new_src(0, IR3_REG_IMMED)->fim_val = 1.0; }
|                  T_FLUT_2_0          { new_src(0, IR3_REG_IMMED)->fim_val = 2.0; }
|                  T_FLUT_4_0          { new_src(0, IR3_REG_IMMED)->fim_val = 4.0; }

immediate:         integer             { new_src(0, IR3_REG_IMMED)->iim_val = $1; }
|                  '(' integer ')'     { new_src(0, IR3_REG_IMMED)->iim_val = $2; }
|                  flut_immed          { new_src(0, IR3_REG_IMMED)->uim_val = $1; }
|                  'h' '(' integer ')' { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->iim_val = $3; }
|                  'h' flut_immed      { new_src(0, IR3_REG_IMMED | IR3_REG_HALF)->uim_val = $2; }

/* Float LUT values accepted as immed: */
flut_immed:        T_FLUT_0_0
|                  T_FLUT_0_5
|                  T_FLUT_1_0
|                  T_FLUT_2_0
|                  T_FLUT_E
|                  T_FLUT_PI
|                  T_FLUT_INV_PI
|                  T_FLUT_INV_LOG2_E
|                  T_FLUT_LOG2_E
|                  T_FLUT_INV_LOG2_10
|                  T_FLUT_LOG2_10
|                  T_FLUT_4_0

uinteger:          T_INT       { $$ = $1; }
|                  T_HEX       { $$ = $1; }

integer:           uinteger     { $$ = $1; }
|                  '-' uinteger { $$ = -$2; }

float:             T_FLOAT     { $$ = $1; }
|                  '-' T_FLOAT { $$ = -$2; }

type:              T_TYPE_F16   { $$ = TYPE_F16;   }
|                  T_TYPE_F32   { $$ = TYPE_F32;   }
|                  T_TYPE_U16   { $$ = TYPE_U16;   }
|                  T_TYPE_U32   { $$ = TYPE_U32;   }
|                  T_TYPE_S16   { $$ = TYPE_S16;   }
|                  T_TYPE_S32   { $$ = TYPE_S32;   }
|                  T_TYPE_U8    { $$ = TYPE_U8;    }
|                  T_TYPE_U8_32 { $$ = TYPE_U8_32; }
|                  T_TYPE_U64   { $$ = TYPE_ATOMIC_U64;  }
