summaryrefslogtreecommitdiff
path: root/cuobjdump_to_ptxplus
diff options
context:
space:
mode:
Diffstat (limited to 'cuobjdump_to_ptxplus')
-rw-r--r--cuobjdump_to_ptxplus/Makefile8
-rw-r--r--cuobjdump_to_ptxplus/ptx.l471
-rw-r--r--cuobjdump_to_ptxplus/ptx.y629
3 files changed, 1104 insertions, 4 deletions
diff --git a/cuobjdump_to_ptxplus/Makefile b/cuobjdump_to_ptxplus/Makefile
index 242a066..e95136a 100644
--- a/cuobjdump_to_ptxplus/Makefile
+++ b/cuobjdump_to_ptxplus/Makefile
@@ -27,11 +27,11 @@ $(OUTPUT_DIR)/cuobjdump_to_ptxplus: $(OUTPUT_DIR)/cuobjdumpInst.o $(OUTPUT_DIR)/
${LD} ${LDFLAGS} -o $@ $(OUTPUT_DIR)/cuobjdumpInst.o $(OUTPUT_DIR)/cuobjdumpInstList.o $(OUTPUT_DIR)/cuobjdump_to_ptxplus.o $(PTX_PARSER_OBJECTS) $(SASS_PARSER_OBJECTS) $(ELF_PARSER_OBJECTS) $(HEADER_PARSER_OBJECTS)
-$(OUTPUT_DIR)/lex.ptx_.c : ../src/cuda-sim/ptx.l
- ${LEX} ${LEXFLAGS} -o$(OUTPUT_DIR)/lex.ptx_.c ../src/cuda-sim/ptx.l
+$(OUTPUT_DIR)/lex.ptx_.c : ptx.l
+ ${LEX} ${LEXFLAGS} -o$(OUTPUT_DIR)/lex.ptx_.c ptx.l
-$(OUTPUT_DIR)/ptx.tab.c : ../src/cuda-sim/ptx.y
- ${YACC} ${YFLAGS} --name-prefix=ptx_ -v ../src/cuda-sim/ptx.y --file-prefix=$(OUTPUT_DIR)/ptx
+$(OUTPUT_DIR)/ptx.tab.c : ptx.y
+ ${YACC} ${YFLAGS} --name-prefix=ptx_ -v ptx.y --file-prefix=$(OUTPUT_DIR)/ptx
$(OUTPUT_DIR)/ptx.tab.h :$(OUTPUT_DIR)/ptx.tab.c
diff --git a/cuobjdump_to_ptxplus/ptx.l b/cuobjdump_to_ptxplus/ptx.l
new file mode 100644
index 0000000..3232361
--- /dev/null
+++ b/cuobjdump_to_ptxplus/ptx.l
@@ -0,0 +1,471 @@
+/*
+Copyright (c) 2009-2011, Tor M. Aamodt
+The University of British Columbia
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+Neither the name of The University of British Columbia nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%option nounput
+%option noyywrap
+%option yylineno
+%option prefix="ptx_"
+%{
+#include "opcodes.h"
+#include "ptx.tab.h"
+#include <string.h>
+
+#define LINEBUF_SIZE (64*1024)
+char linebuf[LINEBUF_SIZE];
+unsigned col = 0;
+#define TC col+=strlen(ptx_text);
+#define CHECK_UNSIGNED \
+ if( yytext[strlen(yytext)-1]=='U' ) { \
+ printf("GPGPU-Sim: ERROR ** U modifier not implemented\n"); \
+ abort(); \
+ }
+int ptx_error( const char *s );
+%}
+
+%s IN_STRING
+%s IN_COMMENT
+%x IN_FUNC_DECL
+%x NOT_OPCODE
+%%
+
+abs TC; ptx_lval.int_value = ABS_OP; return OPCODE;
+add TC; ptx_lval.int_value = ADD_OP; return OPCODE;
+addp TC; ptx_lval.int_value = ADDP_OP; return OPCODE;
+addc TC; ptx_lval.int_value = ADDC_OP; return OPCODE;
+and TC; ptx_lval.int_value = AND_OP; return OPCODE;
+andn TC; ptx_lval.int_value = ANDN_OP; return OPCODE;
+atom TC; ptx_lval.int_value = ATOM_OP; return OPCODE;
+bar.warp TC; ptx_lval.int_value = NOP_OP; return OPCODE;
+bar TC; ptx_lval.int_value = BAR_OP; return OPCODE;
+bfe TC; ptx_lval.int_value = BFE_OP; return OPCODE;
+bfi TC; ptx_lval.int_value = BFI_OP; return OPCODE;
+bfind TC; ptx_lval.int_value = BFIND_OP; return OPCODE;
+bra TC; ptx_lval.int_value = BRA_OP; return OPCODE;
+brx TC; ptx_lval.int_value = BRX_OP; return OPCODE;
+brev TC; ptx_lval.int_value = BREV_OP; return OPCODE;
+brkpt TC; ptx_lval.int_value = BRKPT_OP; return OPCODE;
+
+wmma TC; ptx_lval.int_value = MMA_OP; return OPCODE;
+wmma\.load TC; ptx_lval.int_value = MMA_LD_OP; return OPCODE;
+wmma\.store TC; ptx_lval.int_value = MMA_ST_OP; return OPCODE;
+
+call TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = CALL_OP; return OPCODE; // blocking opcode token in case the callee has the same name as an opcode
+callp TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = CALLP_OP; return OPCODE;
+clz TC; ptx_lval.int_value = CLZ_OP; return OPCODE;
+cnot TC; ptx_lval.int_value = CNOT_OP; return OPCODE;
+cos TC; ptx_lval.int_value = COS_OP; return OPCODE;
+cvt TC; ptx_lval.int_value = CVT_OP; return OPCODE;
+cvta TC; ptx_lval.int_value = CVTA_OP; return OPCODE;
+div TC; ptx_lval.int_value = DIV_OP; return OPCODE;
+dp4a TC; ptx_lval.int_value = DP4A_OP; return OPCODE;
+ex2 TC; ptx_lval.int_value = EX2_OP; return OPCODE;
+exit TC; ptx_lval.int_value = EXIT_OP; return OPCODE;
+fma TC; ptx_lval.int_value = FMA_OP; return OPCODE;
+isspacep TC; ptx_lval.int_value = ISSPACEP_OP; return OPCODE;
+ld TC; ptx_lval.int_value = LD_OP; return OPCODE;
+ld.volatile TC; ptx_lval.int_value = LD_OP; return OPCODE;
+ldu TC; ptx_lval.int_value = LDU_OP; return OPCODE;
+lg2 TC; ptx_lval.int_value = LG2_OP; return OPCODE;
+mad24 TC; ptx_lval.int_value = MAD24_OP; return OPCODE;
+mad TC; ptx_lval.int_value = MAD_OP; return OPCODE;
+madc TC; ptx_lval.int_value = MADC_OP; return OPCODE;
+madp TC; ptx_lval.int_value = MADP_OP; return OPCODE;
+max TC; ptx_lval.int_value = MAX_OP; return OPCODE;
+membar TC; ptx_lval.int_value = MEMBAR_OP; return OPCODE;
+min TC; ptx_lval.int_value = MIN_OP; return OPCODE;
+mov TC; ptx_lval.int_value = MOV_OP; return OPCODE;
+mul24 TC; ptx_lval.int_value = MUL24_OP; return OPCODE;
+mul TC; ptx_lval.int_value = MUL_OP; return OPCODE;
+neg TC; ptx_lval.int_value = NEG_OP; return OPCODE;
+nandn TC; ptx_lval.int_value = NANDN_OP; return OPCODE;
+norn TC; ptx_lval.int_value = NORN_OP; return OPCODE;
+not TC; ptx_lval.int_value = NOT_OP; return OPCODE;
+or TC; ptx_lval.int_value = OR_OP; return OPCODE;
+orn TC; ptx_lval.int_value = ORN_OP; return OPCODE;
+pmevent TC; ptx_lval.int_value = PMEVENT_OP; return OPCODE;
+popc TC; ptx_lval.int_value = POPC_OP; return OPCODE;
+prefetch TC; ptx_lval.int_value = PREFETCH_OP; return OPCODE;
+prefetchu TC; ptx_lval.int_value = PREFETCHU_OP; return OPCODE;
+prmt TC; ptx_lval.int_value = PRMT_OP; return OPCODE;
+rcp TC; ptx_lval.int_value = RCP_OP; return OPCODE;
+red TC; ptx_lval.int_value = RED_OP; return OPCODE;
+rem TC; ptx_lval.int_value = REM_OP; return OPCODE;
+ret TC; ptx_lval.int_value = RET_OP; return OPCODE;
+retp TC; ptx_lval.int_value = RETP_OP; return OPCODE;
+rsqrt TC; ptx_lval.int_value = RSQRT_OP; return OPCODE;
+sad TC; ptx_lval.int_value = SAD_OP; return OPCODE;
+selp TC; ptx_lval.int_value = SELP_OP; return OPCODE;
+setp TC; ptx_lval.int_value = SETP_OP; return OPCODE;
+set TC; ptx_lval.int_value = SET_OP; return OPCODE;
+shfl TC; ptx_lval.int_value = SHFL_OP; return OPCODE;
+shl TC; ptx_lval.int_value = SHL_OP; return OPCODE;
+shr TC; ptx_lval.int_value = SHR_OP; return OPCODE;
+sin TC; ptx_lval.int_value = SIN_OP; return OPCODE;
+slct TC; ptx_lval.int_value = SLCT_OP; return OPCODE;
+sqrt TC; ptx_lval.int_value = SQRT_OP; return OPCODE;
+sst TC; ptx_lval.int_value = SST_OP; return OPCODE;
+ssy TC; ptx_lval.int_value = SSY_OP; return OPCODE;
+st TC; ptx_lval.int_value = ST_OP; return OPCODE;
+st.volatile TC; ptx_lval.int_value = ST_OP; return OPCODE;
+sub TC; ptx_lval.int_value = SUB_OP; return OPCODE;
+subc TC; ptx_lval.int_value = SUBC_OP; return OPCODE;
+suld TC; ptx_lval.int_value = SULD_OP; return OPCODE;
+sured TC; ptx_lval.int_value = SURED_OP; return OPCODE;
+surst TC; ptx_lval.int_value = SUST_OP; return OPCODE;
+suq TC; ptx_lval.int_value = SUQ_OP; return OPCODE;
+tex TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = TEX_OP; return OPCODE;
+txq TC; ptx_lval.int_value = TEX_OP; return OPCODE;
+trap TC; ptx_lval.int_value = TRAP_OP; return OPCODE;
+vabsdiff TC; ptx_lval.int_value = VABSDIFF_OP; return OPCODE;
+vadd TC; ptx_lval.int_value = VADD_OP; return OPCODE;
+vmad TC; ptx_lval.int_value = VMAD_OP; return OPCODE;
+vmax TC; ptx_lval.int_value = VMAX_OP; return OPCODE;
+vmin TC; ptx_lval.int_value = VMIN_OP; return OPCODE;
+vset TC; ptx_lval.int_value = VSET_OP; return OPCODE;
+vshl TC; ptx_lval.int_value = VSHL_OP; return OPCODE;
+vshr TC; ptx_lval.int_value = VSHR_OP; return OPCODE;
+vsub TC; ptx_lval.int_value = VSUB_OP; return OPCODE;
+vote TC; ptx_lval.int_value = VOTE_OP; return OPCODE;
+xor TC; ptx_lval.int_value = XOR_OP; return OPCODE;
+nop TC; ptx_lval.int_value = NOP_OP; return OPCODE;
+break TC; ptx_lval.int_value = BREAK_OP; return OPCODE;
+breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE;
+
+"CPTX_END" printf("ENDING CUSTOM PTX.\n"); BEGIN(IN_COMMENT);
+
+<INITIAL,NOT_OPCODE,IN_INST,IN_FUNC_DECL>{
+\.a\.sync TC; ptx_lval.int_value = LOAD_A; return WMMA_DIRECTIVE;
+\.b\.sync TC; ptx_lval.int_value = LOAD_B; return WMMA_DIRECTIVE;
+\.c\.sync TC; ptx_lval.int_value = LOAD_C; return WMMA_DIRECTIVE;
+\.d\.sync TC; ptx_lval.int_value = STORE_D; return WMMA_DIRECTIVE;
+\.mma\.sync TC;ptx_lval.int_value=MMA; return WMMA_DIRECTIVE;
+
+\.row TC; ptx_lval.int_value = ROW; return LAYOUT;
+\.col TC; ptx_lval.int_value = COL; return LAYOUT;
+\.m16n16k16 TC; ptx_lval.int_value = M16N16K16; return CONFIGURATION;
+\.f4e TC; return PRMT_F4E_MODE;
+\.b4e TC; return PRMT_B4E_MODE;
+\.rc8 TC; return PRMT_RC8_MODE;
+\.ecl TC; return PRMT_ECL_MODE;
+\.ecr TC; return PRMT_ECR_MODE;
+\.rc16 TC; return PRMT_RC16_MODE;
+
+\.align TC; return ALIGN_DIRECTIVE;
+\.branchtargets TC; return BRANCHTARGETS_DIRECTIVE;
+\.byte TC; return BYTE_DIRECTIVE; /* not in PTX 2.1 */
+\.callprototype TC; return CALLPROTOTYPE_DIRECTIVE;
+\.calltargets TC; return CALLTARGETS_DIRECTIVE;
+\.const\[[0-9]+\] TC; ptx_lval.int_value = atoi(yytext+7); return CONST_DIRECTIVE;
+\.const TC; ptx_lval.int_value = 0; return CONST_DIRECTIVE;
+\.entry TC; return ENTRY_DIRECTIVE;
+\.extern TC; return EXTERN_DIRECTIVE;
+\.file TC; BEGIN(INITIAL); return FILE_DIRECTIVE;
+\.func TC; BEGIN(IN_FUNC_DECL); return FUNC_DIRECTIVE; // blocking opcode parsing in case the function has the same name as an opcode (e.g. sin(), cos())
+\.global TC; return GLOBAL_DIRECTIVE;
+\.global.volatile TC; return GLOBAL_DIRECTIVE; //TODO: fix this!
+\.local TC; return LOCAL_DIRECTIVE;
+\.loc TC; return LOC_DIRECTIVE;
+\.maxnctapersm TC; return MAXNCTAPERSM_DIRECTIVE;
+\.maxnreg TC; return MAXNNREG_DIRECTIVE;
+\.maxntid TC; return MAXNTID_DIRECTIVE;
+\.minnctapersm TC; return MINNCTAPERSM_DIRECTIVE;
+\.param TC; return PARAM_DIRECTIVE;
+\.pragma TC; return PRAGMA_DIRECTIVE;
+\.reg TC; return REG_DIRECTIVE;
+\.reqntid TC; return REQNTID_DIRECTIVE;
+\.section TC; return SECTION_DIRECTIVE;
+\.shared TC; return SHARED_DIRECTIVE;
+\.sreg TC; return SREG_DIRECTIVE;
+\.sstarr TC; return SSTARR_DIRECTIVE;
+\.struct TC; return STRUCT_DIRECTIVE;
+\.surf TC; return SURF_DIRECTIVE; /* not in PTX 2.1 */
+\.target TC; return TARGET_DIRECTIVE;
+\.tex TC; BEGIN(NOT_OPCODE); return TEX_DIRECTIVE;
+\.union TC; return UNION_DIRECTIVE; /* not in PTX 2.1 */
+\.version TC; return VERSION_DIRECTIVE;
+\.visible TC; return VISIBLE_DIRECTIVE;
+\.weak TC; return WEAK_DIRECTIVE;
+\.address_size TC; return ADDRESS_SIZE_DIRECTIVE;
+\.weak TC; return WEAK_DIRECTIVE;
+
+\.constptr TC; return CONSTPTR_DIRECTIVE; /* Ptx plus directive for pointer to constant memory */
+\.ptr TC; return PTR_DIRECTIVE; /* Added for new OpenCL genrated code */
+
+"%clock" TC; ptx_lval.int_value = CLOCK_REG; return SPECIAL_REGISTER;
+"%halfclock" TC; ptx_lval.int_value = HALFCLOCK_ID; return SPECIAL_REGISTER;
+"%clock64" TC; ptx_lval.int_value = CLOCK64_REG; return SPECIAL_REGISTER;
+"%ctaid" TC; ptx_lval.int_value = CTAID_REG; return SPECIAL_REGISTER;
+"%envreg"[0-9]+ TC; sscanf(yytext+7,"%u",&ptx_lval.int_value); ptx_lval.int_value<<=16; ptx_lval.int_value += ENVREG_REG; return SPECIAL_REGISTER;
+"%gridid" TC; ptx_lval.int_value = GRIDID_REG; return SPECIAL_REGISTER;
+"%laneid" TC; ptx_lval.int_value = LANEID_REG; return SPECIAL_REGISTER;
+"%lanemask_eq" TC; ptx_lval.int_value = LANEMASK_EQ_REG; return SPECIAL_REGISTER;
+"%lanemask_le" TC; ptx_lval.int_value = LANEMASK_LE_REG; return SPECIAL_REGISTER;
+"%lanemask_lt" TC; ptx_lval.int_value = LANEMASK_LT_REG; return SPECIAL_REGISTER;
+"%lanemask_ge" TC; ptx_lval.int_value = LANEMASK_GE_REG; return SPECIAL_REGISTER;
+"%lanemask_gt" TC; ptx_lval.int_value = LANEMASK_GT_REG; return SPECIAL_REGISTER;
+"%nctaid" TC; ptx_lval.int_value = NCTAID_REG; return SPECIAL_REGISTER;
+"%ntid" TC; ptx_lval.int_value = NTID_REG; return SPECIAL_REGISTER;
+"%nsmid" TC; ptx_lval.int_value = NSMID_REG; return SPECIAL_REGISTER;
+"%nwarpid" TC; ptx_lval.int_value = NWARPID_REG; return SPECIAL_REGISTER;
+"%pm"[0-3] TC; sscanf(yytext+3,"%u",&ptx_lval.int_value); ptx_lval.int_value<<=16; ptx_lval.int_value += PM_REG; return SPECIAL_REGISTER;
+"%smid" TC; ptx_lval.int_value = SMID_REG; return SPECIAL_REGISTER;
+"%tid" TC; ptx_lval.int_value = TID_REG; return SPECIAL_REGISTER;
+"%warpid" TC; ptx_lval.int_value = WARPID_REG; return SPECIAL_REGISTER;
+"WARP_SZ" TC; ptx_lval.int_value = WARPSZ_REG; return SPECIAL_REGISTER;
+
+[a-zA-Z_][a-zA-Z0-9_$]* TC; ptx_lval.string_value = strdup(yytext); return IDENTIFIER;
+[$%][a-zA-Z0-9_$]+ TC; ptx_lval.string_value = strdup(yytext); return IDENTIFIER;
+
+[0-9]+\.[0-9]+ TC; sscanf(yytext,"%lf", &ptx_lval.double_value); return DOUBLE_OPERAND;
+
+0[xX][0-9a-fA-F]+U? TC; CHECK_UNSIGNED; sscanf(yytext,"%x", &ptx_lval.int_value); return INT_OPERAND;
+0[0-7]+U? TC; printf("GPGPU-Sim: ERROR ** parsing octal not (yet) implemented\n"); abort(); return INT_OPERAND;
+0[bB][01]+U? TC; printf("GPGPU-Sim: ERROR ** parsing binary not (yet) implemented\n"); abort(); return INT_OPERAND;
+[-]?[0-9]+U? TC; CHECK_UNSIGNED; ptx_lval.int_value = atoi(yytext); return INT_OPERAND;
+
+0[fF][0-9a-fA-F]{8} TC; sscanf(yytext+2,"%x", (unsigned*)(void*)&ptx_lval.float_value); return FLOAT_OPERAND;
+0[dD][0-9a-fA-F]{16} TC; sscanf(yytext+2,"%Lx", (unsigned long long*)(void*)&ptx_lval.double_value); return DOUBLE_OPERAND;
+
+\.s8 TC; return S8_TYPE;
+\.s16 TC; return S16_TYPE;
+\.s32 TC; return S32_TYPE;
+\.s64 TC; return S64_TYPE;
+\.u8 TC; return U8_TYPE;
+\.u16 TC; return U16_TYPE;
+\.u32 TC; return U32_TYPE;
+\.u64 TC; return U64_TYPE;
+\.f16 TC; return F16_TYPE;
+\.f16x2 TC; return F16_TYPE; /* TODO: figure out what this should really be */
+\.f32 TC; return F32_TYPE;
+\.f64 TC; return F64_TYPE;
+\.ff64 TC; return FF64_TYPE;
+\.b8 TC; return B8_TYPE;
+\.b16 TC; return B16_TYPE;
+\.b32 TC; return B32_TYPE;
+\.b64 TC; return B64_TYPE;
+\.bb64 TC; return BB64_TYPE;
+\.bb128 TC; return BB128_TYPE;
+\.pred TC; return PRED_TYPE;
+
+\.texref TC; BEGIN(NOT_OPCODE); return TEXREF_TYPE;
+\.samplerref TC; return SAMPLERREF_TYPE;
+\.surfref TC; return SURFREF_TYPE;
+
+\.v2 TC; return V2_TYPE;
+\.v3 TC; return V3_TYPE;
+\.v4 TC; return V4_TYPE;
+
+\.half TC; return HALF_OPTION; /* ptxplus */
+\.cc TC; return EXTP_OPTION; /* extended precision option */
+
+\.equ TC; return EQU_OPTION;
+\.neu TC; return NEU_OPTION;
+\.ltu TC; return LTU_OPTION;
+\.leu TC; return LEU_OPTION;
+\.gtu TC; return GTU_OPTION;
+\.geu TC; return GEU_OPTION;
+\.num TC; return NUM_OPTION;
+\.nan TC; return NAN_OPTION;
+
+\.sat TC; return SAT_OPTION;
+
+\.eq TC; return EQ_OPTION;
+\.ne TC; return NE_OPTION;
+\.lt TC; return LT_OPTION;
+\.le TC; return LE_OPTION;
+\.gt TC; return GT_OPTION;
+\.ge TC; return GE_OPTION;
+\.cf TC; return CF_OPTION;
+\.sf TC; return SF_OPTION;
+\.nsf TC; return NSF_OPTION;
+
+\.lo TC; return LO_OPTION;
+\.ls TC; return LS_OPTION;
+\.hi TC; return HI_OPTION;
+\.hs TC; return HS_OPTION;
+
+
+\.rni TC; return RNI_OPTION;
+\.rzi TC; return RZI_OPTION;
+\.rmi TC; return RMI_OPTION;
+\.rpi TC; return RPI_OPTION;
+
+\.rn TC; return RN_OPTION;
+\.rz TC; return RZ_OPTION;
+\.rm TC; return RM_OPTION;
+\.rp TC; return RP_OPTION;
+
+\.ftz TC; return FTZ_OPTION;
+
+\.neg TC; return NEG_OPTION;
+
+\.wide TC; return WIDE_OPTION;
+\.uni TC; return UNI_OPTION;
+
+\.sync TC; return SYNC_OPTION;
+\.arrive TC; return ARRIVE_OPTION;
+\.red TC; return RED_OPTION;
+
+
+\.approx TC; return APPROX_OPTION;
+\.full TC; return FULL_OPTION;
+
+\.any TC; return ANY_OPTION;
+\.all TC; return ALL_OPTION;
+\.ballot TC; return BALLOT_OPTION;
+\.gl TC; return GLOBAL_OPTION;
+\.cta TC; return CTA_OPTION;
+\.sys TC; return SYS_OPTION;
+
+\.exit TC; return EXIT_OPTION;
+
+\.abs TC; return ABS_OPTION;
+
+\.to TC; return TO_OPTION;
+
+\.ca TC; return CA_OPTION;
+\.cg TC; return CG_OPTION;
+\.cs TC; return CS_OPTION;
+\.lu TC; return LU_OPTION;
+\.cv TC; return CV_OPTION;
+
+\.wb TC; return WB_OPTION;
+\.wt TC; return WT_OPTION;
+
+\.nc TC; return NC_OPTION;
+
+\.up TC; return UP_OPTION;
+\.down TC; return DOWN_OPTION;
+\.bfly TC; return BFLY_OPTION;
+\.idx TC; return IDX_OPTION;
+
+\.popc TC; return ATOMIC_POPC;
+\.and TC; return ATOMIC_AND;
+\.or TC; return ATOMIC_OR;
+\.xor TC; return ATOMIC_XOR;
+\.cas TC; return ATOMIC_CAS;
+\.exch TC; return ATOMIC_EXCH;
+\.add TC; return ATOMIC_ADD;
+\.inc TC; return ATOMIC_INC;
+\.dec TC; return ATOMIC_DEC;
+\.min TC; return ATOMIC_MIN;
+\.max TC; return ATOMIC_MAX;
+
+
+
+\.1d TC; return GEOM_MODIFIER_1D;
+\.2d TC; return GEOM_MODIFIER_2D;
+\.3d TC; return GEOM_MODIFIER_3D;
+
+\.0 TC; ptx_lval.int_value = 0; return DIMENSION_MODIFIER;
+\.1 TC; ptx_lval.int_value = 1; return DIMENSION_MODIFIER;
+\.2 TC; ptx_lval.int_value = 2; return DIMENSION_MODIFIER;
+\.x TC; ptx_lval.int_value = 0; return DIMENSION_MODIFIER;
+\.y TC; ptx_lval.int_value = 1; return DIMENSION_MODIFIER;
+\.z TC; ptx_lval.int_value = 2; return DIMENSION_MODIFIER;
+
+"-" TC; return MINUS;
+"+" TC; return PLUS;
+"," TC; return COMMA;
+"@" TC; return PRED;
+"|" TC; return PIPE;
+"[" TC; return LEFT_SQUARE_BRACKET;
+"]" TC; return RIGHT_SQUARE_BRACKET;
+"<" TC; return LEFT_ANGLE_BRACKET;
+">" TC; return RIGHT_ANGLE_BRACKET;
+"(" TC; return LEFT_PAREN;
+")" TC; return RIGHT_PAREN;
+":" TC; BEGIN(INITIAL); return COLON;
+";" TC; BEGIN(INITIAL); return SEMI_COLON;
+"!" TC; return EXCLAMATION;
+"=" TC; return EQUALS;
+"}" TC; return RIGHT_BRACE;
+\. TC; return PERIOD;
+"/" TC; return BACKSLASH;
+
+"//"[^\n]* TC; // eat single
+
+\n.* col=0; strncpy(linebuf, yytext + 1, LINEBUF_SIZE); yyless( 1 );
+
+" " TC;
+"\t" TC;
+
+
+}
+
+<IN_FUNC_DECL>"{" TC; BEGIN(INITIAL); return LEFT_BRACE; // starting a statement block (allow next token to be parsed as an opcode)
+<INITIAL,NOT_OPCODE>"{" TC; return LEFT_BRACE; // starting a vector operand (next token cannot be opcode)
+
+<INITIAL>{
+"/*" BEGIN(IN_COMMENT);
+}
+<IN_COMMENT>{
+"*/" BEGIN(INITIAL);
+"CPTX_BEGIN" printf("BEGINNING CUSTOM PTX.\n"); BEGIN(INITIAL);
+[^C*\n]+ // eat comment in chunks
+"C" // eat the lone C
+"*" // eat the lone star
+\n TC;
+}
+
+<INITIAL>{
+"\"" BEGIN(IN_STRING);
+}
+<IN_STRING>{
+"\"" TC; BEGIN(INITIAL); return STRING;
+[^\"]* TC; ptx_lval.string_value = strdup(yytext);
+}
+
+<*>\t@@DWARF.*\n
+
+<INITIAL,NOT_OPCODE,IN_FUNC_DECL>. TC; ptx_error((const char*)NULL);
+%%
+
+extern int g_error_detected;
+extern const char *g_filename;
+
+int ptx_error( const char *s )
+{
+ int i;
+ g_error_detected = 1;
+ fflush(stdout);
+ if( s != NULL )
+ printf("%s:%u: Syntax error:\n\n", g_filename, ptx_lineno );
+ printf(" %s\n", linebuf );
+ printf(" ");
+ for( i=0; i < col-1; i++ ) {
+ if( linebuf[i] == '\t' ) printf("\t");
+ else printf(" ");
+ }
+
+ printf("^\n\n");
+ fflush(stdout);
+ //exit(1);
+ return 0;
+}
diff --git a/cuobjdump_to_ptxplus/ptx.y b/cuobjdump_to_ptxplus/ptx.y
new file mode 100644
index 0000000..45392fb
--- /dev/null
+++ b/cuobjdump_to_ptxplus/ptx.y
@@ -0,0 +1,629 @@
+/*
+Copyright (c) 2009-2011, Tor M. Aamodt
+The University of British Columbia
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+Neither the name of The University of British Columbia nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%union {
+ double double_value;
+ float float_value;
+ int int_value;
+ char * string_value;
+ void * ptr_value;
+}
+
+%token <string_value> STRING
+%token <int_value> OPCODE
+%token <int_value> WMMA_DIRECTIVE
+%token <int_value> LAYOUT
+%token <int_value> CONFIGURATION
+%token ALIGN_DIRECTIVE
+%token BRANCHTARGETS_DIRECTIVE
+%token BYTE_DIRECTIVE
+%token CALLPROTOTYPE_DIRECTIVE
+%token CALLTARGETS_DIRECTIVE
+%token <int_value> CONST_DIRECTIVE
+%token CONSTPTR_DIRECTIVE
+%token PTR_DIRECTIVE
+%token ENTRY_DIRECTIVE
+%token EXTERN_DIRECTIVE
+%token FILE_DIRECTIVE
+%token FUNC_DIRECTIVE
+%token GLOBAL_DIRECTIVE
+%token LOCAL_DIRECTIVE
+%token LOC_DIRECTIVE
+%token MAXNCTAPERSM_DIRECTIVE
+%token MAXNNREG_DIRECTIVE
+%token MAXNTID_DIRECTIVE
+%token MINNCTAPERSM_DIRECTIVE
+%token PARAM_DIRECTIVE
+%token PRAGMA_DIRECTIVE
+%token REG_DIRECTIVE
+%token REQNTID_DIRECTIVE
+%token SECTION_DIRECTIVE
+%token SHARED_DIRECTIVE
+%token SREG_DIRECTIVE
+%token SSTARR_DIRECTIVE
+%token STRUCT_DIRECTIVE
+%token SURF_DIRECTIVE
+%token TARGET_DIRECTIVE
+%token TEX_DIRECTIVE
+%token UNION_DIRECTIVE
+%token VERSION_DIRECTIVE
+%token ADDRESS_SIZE_DIRECTIVE
+%token VISIBLE_DIRECTIVE
+%token WEAK_DIRECTIVE
+%token <string_value> IDENTIFIER
+%token <int_value> INT_OPERAND
+%token <float_value> FLOAT_OPERAND
+%token <double_value> DOUBLE_OPERAND
+%token S8_TYPE
+%token S16_TYPE
+%token S32_TYPE
+%token S64_TYPE
+%token U8_TYPE
+%token U16_TYPE
+%token U32_TYPE
+%token U64_TYPE
+%token F16_TYPE
+%token F32_TYPE
+%token F64_TYPE
+%token FF64_TYPE
+%token B8_TYPE
+%token B16_TYPE
+%token B32_TYPE
+%token B64_TYPE
+%token BB64_TYPE
+%token BB128_TYPE
+%token PRED_TYPE
+%token TEXREF_TYPE
+%token SAMPLERREF_TYPE
+%token SURFREF_TYPE
+%token V2_TYPE
+%token V3_TYPE
+%token V4_TYPE
+%token COMMA
+%token PRED
+%token HALF_OPTION
+%token EXTP_OPTION
+%token EQ_OPTION
+%token NE_OPTION
+%token LT_OPTION
+%token LE_OPTION
+%token GT_OPTION
+%token GE_OPTION
+%token LO_OPTION
+%token LS_OPTION
+%token HI_OPTION
+%token HS_OPTION
+%token EQU_OPTION
+%token NEU_OPTION
+%token LTU_OPTION
+%token LEU_OPTION
+%token GTU_OPTION
+%token GEU_OPTION
+%token NUM_OPTION
+%token NAN_OPTION
+%token CF_OPTION
+%token SF_OPTION
+%token NSF_OPTION
+%token LEFT_SQUARE_BRACKET
+%token RIGHT_SQUARE_BRACKET
+%token WIDE_OPTION
+%token <int_value> SPECIAL_REGISTER
+%token MINUS
+%token PLUS
+%token COLON
+%token SEMI_COLON
+%token EXCLAMATION
+%token PIPE
+%token RIGHT_BRACE
+%token LEFT_BRACE
+%token EQUALS
+%token PERIOD
+%token BACKSLASH
+%token <int_value> DIMENSION_MODIFIER
+%token RN_OPTION
+%token RZ_OPTION
+%token RM_OPTION
+%token RP_OPTION
+%token RNI_OPTION
+%token RZI_OPTION
+%token RMI_OPTION
+%token RPI_OPTION
+%token UNI_OPTION
+%token GEOM_MODIFIER_1D
+%token GEOM_MODIFIER_2D
+%token GEOM_MODIFIER_3D
+%token SAT_OPTION
+%token FTZ_OPTION
+%token NEG_OPTION
+%token SYNC_OPTION
+%token RED_OPTION
+%token ARRIVE_OPTION
+%token ATOMIC_POPC
+%token ATOMIC_AND
+%token ATOMIC_OR
+%token ATOMIC_XOR
+%token ATOMIC_CAS
+%token ATOMIC_EXCH
+%token ATOMIC_ADD
+%token ATOMIC_INC
+%token ATOMIC_DEC
+%token ATOMIC_MIN
+%token ATOMIC_MAX
+%token LEFT_ANGLE_BRACKET
+%token RIGHT_ANGLE_BRACKET
+%token LEFT_PAREN
+%token RIGHT_PAREN
+%token APPROX_OPTION
+%token FULL_OPTION
+%token ANY_OPTION
+%token ALL_OPTION
+%token BALLOT_OPTION
+%token GLOBAL_OPTION
+%token CTA_OPTION
+%token SYS_OPTION
+%token EXIT_OPTION
+%token ABS_OPTION
+%token TO_OPTION
+%token CA_OPTION;
+%token CG_OPTION;
+%token CS_OPTION;
+%token LU_OPTION;
+%token CV_OPTION;
+%token WB_OPTION;
+%token WT_OPTION;
+%token NC_OPTION;
+%token UP_OPTION;
+%token DOWN_OPTION;
+%token BFLY_OPTION;
+%token IDX_OPTION;
+%token PRMT_F4E_MODE;
+%token PRMT_B4E_MODE;
+%token PRMT_RC8_MODE;
+%token PRMT_RC16_MODE;
+%token PRMT_ECL_MODE;
+%token PRMT_ECR_MODE;
+
+%type <int_value> function_decl_header
+%type <ptr_value> function_decl
+
+%{
+ #include "ptx_parser.h"
+ #include <stdlib.h>
+ #include <string.h>
+ #include <math.h>
+ void syntax_not_implemented();
+ extern int g_func_decl;
+ int ptx_lex(void);
+ int ptx_error(const char *);
+%}
+
+%%
+
+input: /* empty */
+ | input directive_statement
+ | input function_defn
+ | input function_decl
+ ;
+
+function_defn: function_decl { set_symtab($1); func_header(".skip"); } statement_block { end_function(); }
+ | function_decl { set_symtab($1); } block_spec_list { func_header(".skip"); } statement_block { end_function(); }
+ ;
+
+block_spec: MAXNTID_DIRECTIVE INT_OPERAND COMMA INT_OPERAND COMMA INT_OPERAND {func_header_info_int(".maxntid", $2);
+ func_header_info_int(",", $4);
+ func_header_info_int(",", $6);
+ maxnt_id($2, $4, $6);}
+ | MINNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".minnctapersm", $2); printf("GPGPU-Sim: Warning: .minnctapersm ignored. \n"); }
+ | MAXNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".maxnctapersm", $2); printf("GPGPU-Sim: Warning: .maxnctapersm ignored. \n"); }
+ ;
+
+block_spec_list: block_spec
+ | block_spec_list block_spec
+ ;
+
+function_decl: function_decl_header LEFT_PAREN { start_function($1); func_header_info("(");} param_entry RIGHT_PAREN {func_header_info(")");} function_ident_param { $$ = reset_symtab(); }
+ | function_decl_header { start_function($1); } function_ident_param { $$ = reset_symtab(); }
+ | function_decl_header { start_function($1); add_function_name(""); g_func_decl=0; $$ = reset_symtab(); }
+ ;
+
+function_ident_param: IDENTIFIER { add_function_name($1); } LEFT_PAREN {func_header_info("(");} param_list RIGHT_PAREN { g_func_decl=0; func_header_info(")"); }
+ | IDENTIFIER { add_function_name($1); g_func_decl=0; }
+ ;
+
+function_decl_header: ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
+ | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
+ | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
+ | FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; g_func_decl=1; func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ ;
+
+param_list: /*empty*/
+ | param_entry { add_directive(); }
+ | param_list COMMA {func_header_info(",");} param_entry { add_directive(); }
+
+param_entry: PARAM_DIRECTIVE { add_space_spec(param_space_unclassified,0); } variable_spec ptr_spec identifier_spec { add_function_arg(); }
+ | REG_DIRECTIVE { add_space_spec(reg_space,0); } variable_spec identifier_spec { add_function_arg(); }
+
+ptr_spec: /*empty*/
+ | PTR_DIRECTIVE ptr_space_spec ptr_align_spec
+ | PTR_DIRECTIVE ptr_align_spec
+
+ptr_space_spec: GLOBAL_DIRECTIVE { add_ptr_spec(global_space); }
+ | LOCAL_DIRECTIVE { add_ptr_spec(local_space); }
+ | SHARED_DIRECTIVE { add_ptr_spec(shared_space); }
+ | CONST_DIRECTIVE { add_ptr_spec(global_space); }
+
+ptr_align_spec: ALIGN_DIRECTIVE INT_OPERAND
+
+statement_block: LEFT_BRACE statement_list RIGHT_BRACE
+
+statement_list: directive_statement { add_directive(); }
+ | instruction_statement { add_instruction(); }
+ | statement_list directive_statement { add_directive(); }
+ | statement_list instruction_statement { add_instruction(); }
+ | statement_list {start_inst_group();} statement_block {end_inst_group();}
+ | {start_inst_group();} statement_block {end_inst_group();}
+ ;
+
+directive_statement: variable_declaration SEMI_COLON
+ | VERSION_DIRECTIVE DOUBLE_OPERAND { add_version_info($2, 0); }
+ | VERSION_DIRECTIVE DOUBLE_OPERAND PLUS { add_version_info($2,1); }
+ | ADDRESS_SIZE_DIRECTIVE INT_OPERAND {/*Do nothing*/}
+ | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER { target_header2($2,$4); }
+ | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER { target_header3($2,$4,$6); }
+ | TARGET_DIRECTIVE IDENTIFIER { target_header($2); }
+ | FILE_DIRECTIVE INT_OPERAND STRING { add_file($2,$3); }
+ | FILE_DIRECTIVE INT_OPERAND STRING COMMA INT_OPERAND COMMA INT_OPERAND { add_file($2,$3); }
+ | LOC_DIRECTIVE INT_OPERAND INT_OPERAND INT_OPERAND
+ | PRAGMA_DIRECTIVE STRING SEMI_COLON { add_pragma($2); }
+ | function_decl SEMI_COLON {/*Do nothing*/}
+ ;
+
+variable_declaration: variable_spec identifier_list { add_variables(); }
+ | variable_spec identifier_spec EQUALS initializer_list { add_variables(); }
+ | variable_spec identifier_spec EQUALS literal_operand { add_variables(); }
+ | CONSTPTR_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA INT_OPERAND { add_constptr($2, $4, $6); }
+ ;
+
+variable_spec: var_spec_list { set_variable_type(); }
+
+identifier_list: identifier_spec
+ | identifier_list COMMA identifier_spec;
+
+identifier_spec: IDENTIFIER { add_identifier($1,0,NON_ARRAY_IDENTIFIER); func_header_info($1);}
+ | IDENTIFIER LEFT_ANGLE_BRACKET INT_OPERAND RIGHT_ANGLE_BRACKET { func_header_info($1); func_header_info_int("<", $3); func_header_info(">");
+ int i,lbase,l;
+ char *id = NULL;
+ lbase = strlen($1);
+ for( i=0; i < $3; i++ ) {
+ l = lbase + (int)log10(i+1)+10;
+ id = (char*) malloc(l);
+ snprintf(id,l,"%s%u",$1,i);
+ add_identifier(id,0,NON_ARRAY_IDENTIFIER);
+ }
+ free($1);
+ }
+ | IDENTIFIER LEFT_SQUARE_BRACKET RIGHT_SQUARE_BRACKET { add_identifier($1,0,ARRAY_IDENTIFIER_NO_DIM); func_header_info($1); func_header_info("["); func_header_info("]");}
+ | IDENTIFIER LEFT_SQUARE_BRACKET INT_OPERAND RIGHT_SQUARE_BRACKET { add_identifier($1,$3,ARRAY_IDENTIFIER); func_header_info($1); func_header_info_int("[",$3); func_header_info("]");}
+ ;
+
+var_spec_list: var_spec
+ | var_spec_list var_spec;
+
+var_spec: space_spec
+ | type_spec
+ | align_spec
+ | VISIBLE_DIRECTIVE
+ | EXTERN_DIRECTIVE { add_extern_spec(); }
+ | WEAK_DIRECTIVE
+ ;
+
+align_spec: ALIGN_DIRECTIVE INT_OPERAND { add_alignment_spec($2); }
+
+space_spec: REG_DIRECTIVE { add_space_spec(reg_space,0); }
+ | SREG_DIRECTIVE { add_space_spec(reg_space,0); }
+ | addressable_spec
+ ;
+
+addressable_spec: CONST_DIRECTIVE { add_space_spec(const_space,$1); }
+ | GLOBAL_DIRECTIVE { add_space_spec(global_space,0); }
+ | LOCAL_DIRECTIVE { add_space_spec(local_space,0); }
+ | PARAM_DIRECTIVE { add_space_spec(param_space_unclassified,0); }
+ | SHARED_DIRECTIVE { add_space_spec(shared_space,0); }
+ | SSTARR_DIRECTIVE { add_space_spec(sstarr_space,0); }
+ | SURF_DIRECTIVE { add_space_spec(surf_space,0); }
+ | TEX_DIRECTIVE { add_space_spec(tex_space,0); }
+ ;
+
+type_spec: scalar_type
+ | vector_spec scalar_type
+ ;
+
+vector_spec: V2_TYPE { add_option(V2_TYPE); func_header_info(".v2");}
+ | V3_TYPE { add_option(V3_TYPE); func_header_info(".v3");}
+ | V4_TYPE { add_option(V4_TYPE); func_header_info(".v4");}
+ ;
+
+scalar_type: S8_TYPE { add_scalar_type_spec( S8_TYPE ); }
+ | S16_TYPE { add_scalar_type_spec( S16_TYPE ); }
+ | S32_TYPE { add_scalar_type_spec( S32_TYPE ); }
+ | S64_TYPE { add_scalar_type_spec( S64_TYPE ); }
+ | U8_TYPE { add_scalar_type_spec( U8_TYPE ); }
+ | U16_TYPE { add_scalar_type_spec( U16_TYPE ); }
+ | U32_TYPE { add_scalar_type_spec( U32_TYPE ); }
+ | U64_TYPE { add_scalar_type_spec( U64_TYPE ); }
+ | F16_TYPE { add_scalar_type_spec( F16_TYPE ); }
+ | F32_TYPE { add_scalar_type_spec( F32_TYPE ); }
+ | F64_TYPE { add_scalar_type_spec( F64_TYPE ); }
+ | FF64_TYPE { add_scalar_type_spec( FF64_TYPE ); }
+ | B8_TYPE { add_scalar_type_spec( B8_TYPE ); }
+ | B16_TYPE { add_scalar_type_spec( B16_TYPE ); }
+ | B32_TYPE { add_scalar_type_spec( B32_TYPE ); }
+ | B64_TYPE { add_scalar_type_spec( B64_TYPE ); }
+ | BB64_TYPE { add_scalar_type_spec( BB64_TYPE ); }
+ | BB128_TYPE { add_scalar_type_spec( BB128_TYPE ); }
+ | PRED_TYPE { add_scalar_type_spec( PRED_TYPE ); }
+ | TEXREF_TYPE { add_scalar_type_spec( TEXREF_TYPE ); }
+ | SAMPLERREF_TYPE { add_scalar_type_spec( SAMPLERREF_TYPE ); }
+ | SURFREF_TYPE { add_scalar_type_spec( SURFREF_TYPE ); }
+ ;
+
+initializer_list: LEFT_BRACE literal_list RIGHT_BRACE { add_array_initializer(); }
+ | LEFT_BRACE initializer_list RIGHT_BRACE { syntax_not_implemented(); }
+
+literal_list: literal_operand
+ | literal_list COMMA literal_operand;
+
+instruction_statement: instruction SEMI_COLON
+ | IDENTIFIER COLON { add_label($1); }
+ | pred_spec instruction SEMI_COLON;
+
+instruction: opcode_spec LEFT_PAREN operand RIGHT_PAREN { set_return(); } COMMA operand COMMA LEFT_PAREN operand_list RIGHT_PAREN
+ | opcode_spec operand COMMA LEFT_PAREN operand_list RIGHT_PAREN
+ | opcode_spec operand COMMA LEFT_PAREN RIGHT_PAREN
+ | opcode_spec operand_list
+ | opcode_spec
+ ;
+
+opcode_spec: OPCODE { add_opcode($1); } option_list
+ | OPCODE { add_opcode($1); }
+
+pred_spec: PRED IDENTIFIER { add_pred($2,0, -1); }
+ | PRED EXCLAMATION IDENTIFIER { add_pred($3,1, -1); }
+ | PRED IDENTIFIER LT_OPTION { add_pred($2,0,1); }
+ | PRED IDENTIFIER EQ_OPTION { add_pred($2,0,2); }
+ | PRED IDENTIFIER LE_OPTION { add_pred($2,0,3); }
+ | PRED IDENTIFIER NE_OPTION { add_pred($2,0,5); }
+ | PRED IDENTIFIER GE_OPTION { add_pred($2,0,6); }
+ | PRED IDENTIFIER EQU_OPTION { add_pred($2,0,10); }
+ | PRED IDENTIFIER GTU_OPTION { add_pred($2,0,12); }
+ | PRED IDENTIFIER NEU_OPTION { add_pred($2,0,13); }
+ | PRED IDENTIFIER CF_OPTION { add_pred($2,0,17); }
+ | PRED IDENTIFIER SF_OPTION { add_pred($2,0,19); }
+ | PRED IDENTIFIER NSF_OPTION { add_pred($2,0,28); }
+ ;
+
+option_list: option
+ | option option_list ;
+
+option: type_spec
+ | compare_spec
+ | addressable_spec
+ | rounding_mode
+ | wmma_spec
+ | prmt_spec
+ | SYNC_OPTION { add_option(SYNC_OPTION); }
+ | ARRIVE_OPTION { add_option(ARRIVE_OPTION); }
+ | RED_OPTION { add_option(RED_OPTION); }
+ | UNI_OPTION { add_option(UNI_OPTION); }
+ | WIDE_OPTION { add_option(WIDE_OPTION); }
+ | ANY_OPTION { add_option(ANY_OPTION); }
+ | ALL_OPTION { add_option(ALL_OPTION); }
+ | BALLOT_OPTION { add_option(BALLOT_OPTION); }
+ | GLOBAL_OPTION { add_option(GLOBAL_OPTION); }
+ | CTA_OPTION { add_option(CTA_OPTION); }
+ | SYS_OPTION { add_option(SYS_OPTION); }
+ | GEOM_MODIFIER_1D { add_option(GEOM_MODIFIER_1D); }
+ | GEOM_MODIFIER_2D { add_option(GEOM_MODIFIER_2D); }
+ | GEOM_MODIFIER_3D { add_option(GEOM_MODIFIER_3D); }
+ | SAT_OPTION { add_option(SAT_OPTION); }
+ | FTZ_OPTION { add_option(FTZ_OPTION); }
+ | NEG_OPTION { add_option(NEG_OPTION); }
+ | APPROX_OPTION { add_option(APPROX_OPTION); }
+ | FULL_OPTION { add_option(FULL_OPTION); }
+ | EXIT_OPTION { add_option(EXIT_OPTION); }
+ | ABS_OPTION { add_option(ABS_OPTION); }
+ | atomic_operation_spec ;
+ | TO_OPTION { add_option(TO_OPTION); }
+ | HALF_OPTION { add_option(HALF_OPTION); }
+ | EXTP_OPTION { add_option(EXTP_OPTION); }
+ | CA_OPTION { add_option(CA_OPTION); }
+ | CG_OPTION { add_option(CG_OPTION); }
+ | CS_OPTION { add_option(CS_OPTION); }
+ | LU_OPTION { add_option(LU_OPTION); }
+ | CV_OPTION { add_option(CV_OPTION); }
+ | WB_OPTION { add_option(WB_OPTION); }
+ | WT_OPTION { add_option(WT_OPTION); }
+ | NC_OPTION { add_option(NC_OPTION); }
+ | UP_OPTION { add_option(UP_OPTION); }
+ | DOWN_OPTION { add_option(DOWN_OPTION); }
+ | BFLY_OPTION { add_option(BFLY_OPTION); }
+ | IDX_OPTION { add_option(IDX_OPTION); }
+ ;
+
+atomic_operation_spec: ATOMIC_AND { add_option(ATOMIC_AND); }
+ | ATOMIC_POPC { add_option(ATOMIC_POPC); }
+ | ATOMIC_OR { add_option(ATOMIC_OR); }
+ | ATOMIC_XOR { add_option(ATOMIC_XOR); }
+ | ATOMIC_CAS { add_option(ATOMIC_CAS); }
+ | ATOMIC_EXCH { add_option(ATOMIC_EXCH); }
+ | ATOMIC_ADD { add_option(ATOMIC_ADD); }
+ | ATOMIC_INC { add_option(ATOMIC_INC); }
+ | ATOMIC_DEC { add_option(ATOMIC_DEC); }
+ | ATOMIC_MIN { add_option(ATOMIC_MIN); }
+ | ATOMIC_MAX { add_option(ATOMIC_MAX); }
+ ;
+
+rounding_mode: floating_point_rounding_mode
+ | integer_rounding_mode;
+
+
+floating_point_rounding_mode: RN_OPTION { add_option(RN_OPTION); }
+ | RZ_OPTION { add_option(RZ_OPTION); }
+ | RM_OPTION { add_option(RM_OPTION); }
+ | RP_OPTION { add_option(RP_OPTION); }
+ ;
+
+integer_rounding_mode: RNI_OPTION { add_option(RNI_OPTION); }
+ | RZI_OPTION { add_option(RZI_OPTION); }
+ | RMI_OPTION { add_option(RMI_OPTION); }
+ | RPI_OPTION { add_option(RPI_OPTION); }
+ ;
+
+compare_spec:EQ_OPTION { add_option(EQ_OPTION); }
+ | NE_OPTION { add_option(NE_OPTION); }
+ | LT_OPTION { add_option(LT_OPTION); }
+ | LE_OPTION { add_option(LE_OPTION); }
+ | GT_OPTION { add_option(GT_OPTION); }
+ | GE_OPTION { add_option(GE_OPTION); }
+ | LO_OPTION { add_option(LO_OPTION); }
+ | LS_OPTION { add_option(LS_OPTION); }
+ | HI_OPTION { add_option(HI_OPTION); }
+ | HS_OPTION { add_option(HS_OPTION); }
+ | EQU_OPTION { add_option(EQU_OPTION); }
+ | NEU_OPTION { add_option(NEU_OPTION); }
+ | LTU_OPTION { add_option(LTU_OPTION); }
+ | LEU_OPTION { add_option(LEU_OPTION); }
+ | GTU_OPTION { add_option(GTU_OPTION); }
+ | GEU_OPTION { add_option(GEU_OPTION); }
+ | NUM_OPTION { add_option(NUM_OPTION); }
+ | NAN_OPTION { add_option(NAN_OPTION); }
+ ;
+
+prmt_spec: PRMT_F4E_MODE { add_option( PRMT_F4E_MODE); }
+ | PRMT_B4E_MODE { add_option( PRMT_B4E_MODE); }
+ | PRMT_RC8_MODE { add_option( PRMT_RC8_MODE); }
+ | PRMT_RC16_MODE{ add_option( PRMT_RC16_MODE);}
+ | PRMT_ECL_MODE { add_option( PRMT_ECL_MODE); }
+ | PRMT_ECR_MODE { add_option( PRMT_ECR_MODE); }
+ ;
+
+wmma_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ptr_spec(global_space); add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);}
+ | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);add_wmma_option($4);}
+ ;
+
+vp_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ptr_spec(global_space);add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);}
+ | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);add_wmma_option($4);}
+ ;
+
+
+
+operand_list: operand
+ | operand COMMA operand_list;
+
+operand: IDENTIFIER { add_scalar_operand( $1 ); }
+ | EXCLAMATION IDENTIFIER { add_neg_pred_operand( $2 ); }
+ | MINUS IDENTIFIER { add_scalar_operand( $2 ); change_operand_neg(); }
+ | memory_operand
+ | literal_operand
+ | builtin_operand
+ | vector_operand
+ | MINUS vector_operand { change_operand_neg(); }
+ | tex_operand
+ | IDENTIFIER PLUS INT_OPERAND { add_address_operand($1,$3); }
+ | IDENTIFIER LO_OPTION { add_scalar_operand( $1 ); change_operand_lohi(1);}
+ | MINUS IDENTIFIER LO_OPTION { add_scalar_operand( $2 ); change_operand_lohi(1); change_operand_neg();}
+ | IDENTIFIER HI_OPTION { add_scalar_operand( $1 ); change_operand_lohi(2);}
+ | MINUS IDENTIFIER HI_OPTION { add_scalar_operand( $2 ); change_operand_lohi(2); change_operand_neg();}
+ | IDENTIFIER PIPE IDENTIFIER { add_2vector_operand($1,$3); change_double_operand_type(-1);}
+ | IDENTIFIER PIPE IDENTIFIER LO_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-1); change_operand_lohi(1);}
+ | IDENTIFIER PIPE IDENTIFIER HI_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-1); change_operand_lohi(2);}
+ | IDENTIFIER BACKSLASH IDENTIFIER { add_2vector_operand($1,$3); change_double_operand_type(-3);}
+ | IDENTIFIER BACKSLASH IDENTIFIER LO_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-3); change_operand_lohi(1);}
+ | IDENTIFIER BACKSLASH IDENTIFIER HI_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-3); change_operand_lohi(2);}
+ ;
+
+vector_operand: LEFT_BRACE IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_2vector_operand($2,$4); }
+ | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_3vector_operand($2,$4,$6); }
+ | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_4vector_operand($2,$4,$6,$8); }
+ | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_8vector_operand($2,$4,$6,$8,$10,$12,$14,$16); }
+ | LEFT_BRACE IDENTIFIER RIGHT_BRACE { add_1vector_operand($2); }
+ ;
+
+tex_operand: LEFT_SQUARE_BRACKET IDENTIFIER COMMA { add_scalar_operand($2); }
+ vector_operand
+ RIGHT_SQUARE_BRACKET
+ ;
+
+builtin_operand: SPECIAL_REGISTER DIMENSION_MODIFIER { add_builtin_operand($1,$2); }
+ | SPECIAL_REGISTER { add_builtin_operand($1,-1); }
+ ;
+
+memory_operand : LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { add_memory_operand(); }
+ | IDENTIFIER LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { add_memory_operand(); change_memory_addr_space($1); }
+ | IDENTIFIER LEFT_SQUARE_BRACKET literal_operand RIGHT_SQUARE_BRACKET { change_memory_addr_space($1); }
+ | IDENTIFIER LEFT_SQUARE_BRACKET twin_operand RIGHT_SQUARE_BRACKET { change_memory_addr_space($1); add_memory_operand();}
+ | MINUS memory_operand { change_operand_neg(); }
+ ;
+
+twin_operand : IDENTIFIER PLUS IDENTIFIER { add_double_operand($1,$3); change_double_operand_type(1); }
+ | IDENTIFIER PLUS IDENTIFIER LO_OPTION { add_double_operand($1,$3); change_double_operand_type(1); change_operand_lohi(1); }
+ | IDENTIFIER PLUS IDENTIFIER HI_OPTION { add_double_operand($1,$3); change_double_operand_type(1); change_operand_lohi(2); }
+ | IDENTIFIER PLUS EQUALS IDENTIFIER { add_double_operand($1,$4); change_double_operand_type(2); }
+ | IDENTIFIER PLUS EQUALS IDENTIFIER LO_OPTION { add_double_operand($1,$4); change_double_operand_type(2); change_operand_lohi(1); }
+ | IDENTIFIER PLUS EQUALS IDENTIFIER HI_OPTION { add_double_operand($1,$4); change_double_operand_type(2); change_operand_lohi(2); }
+ | IDENTIFIER PLUS EQUALS INT_OPERAND { add_address_operand($1,$4); change_double_operand_type(3); }
+ ;
+
+literal_operand : INT_OPERAND { add_literal_int($1); }
+ | FLOAT_OPERAND { add_literal_float($1); }
+ | DOUBLE_OPERAND { add_literal_double($1); }
+ ;
+
+address_expression: IDENTIFIER { add_address_operand($1,0); }
+ | IDENTIFIER LO_OPTION { add_address_operand($1,0); change_operand_lohi(1);}
+ | IDENTIFIER HI_OPTION { add_address_operand($1,0); change_operand_lohi(2); }
+ | IDENTIFIER PLUS INT_OPERAND { add_address_operand($1,$3); }
+ | INT_OPERAND { add_address_operand2($1); }
+ ;
+
+%%
+
+extern int ptx_lineno;
+extern const char *g_filename;
+
+void syntax_not_implemented()
+{
+ printf("Parse error (%s:%u): this syntax is not (yet) implemented:\n",g_filename,ptx_lineno);
+ ptx_error(NULL);
+ abort();
+}
generated by cgit v1.3 (git 2.53.0) at 2026-07-10 21:30:14 +0000