From 0c16df3c8b108d8720846bb44b9abcc60ddf42f9 Mon Sep 17 00:00:00 2001 From: Mahmoud Date: Wed, 15 May 2019 20:16:54 -0400 Subject: make gpu_tot_cycle local variable not global variable --- src/cuda-sim/ptx_sim.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/cuda-sim/ptx_sim.cc') diff --git a/src/cuda-sim/ptx_sim.cc b/src/cuda-sim/ptx_sim.cc index 820287d..8ad651e 100644 --- a/src/cuda-sim/ptx_sim.cc +++ b/src/cuda-sim/ptx_sim.cc @@ -222,7 +222,7 @@ void ptx_thread_info::set_done() { assert( !m_at_barrier ); m_thread_done = true; - m_cycle_done = gpu_sim_cycle; + m_cycle_done = m_gpu->gpu_sim_cycle; } unsigned ptx_thread_info::get_builtin( int builtin_id, unsigned dim_mod ) @@ -230,15 +230,15 @@ unsigned ptx_thread_info::get_builtin( int builtin_id, unsigned dim_mod ) assert( m_valid ); switch ((builtin_id&0xFFFF)) { case CLOCK_REG: - return (unsigned)(gpu_sim_cycle + gpu_tot_sim_cycle); + return (unsigned)(m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle); case CLOCK64_REG: abort(); // change return value to unsigned long long? // GPGPUSim clock is 4 times slower - multiply by 4 - return (gpu_sim_cycle + gpu_tot_sim_cycle)*4; + return (m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle)*4; case HALFCLOCK_ID: // GPGPUSim clock is 4 times slower - multiply by 4 // Hardware clock counter is incremented at half the shader clock frequency - divide by 2 (Henry '10) - return (gpu_sim_cycle + gpu_tot_sim_cycle)*2; + return (m_gpu->gpu_sim_cycle + m_gpu->gpu_tot_sim_cycle)*2; case CTAID_REG: assert( dim_mod < 3 ); if( dim_mod == 0 ) return m_ctaid.x; -- cgit v1.3 From 1fb385af6e036588a0b807aa51d74dcf34f841cd Mon Sep 17 00:00:00 2001 From: Mengchi Zhang Date: Fri, 17 May 2019 10:59:27 -0400 Subject: Move ptx parser to reentrant Signed-off-by: Mengchi Zhang --- src/cuda-sim/cuda-sim.cc | 2 + src/cuda-sim/instructions.cc | 2 + src/cuda-sim/ptx.l | 317 +++++++++++++------------- src/cuda-sim/ptx.y | 513 ++++++++++++++++++++++--------------------- src/cuda-sim/ptx_ir.cc | 1 + src/cuda-sim/ptx_parser.cc | 168 +++++++------- src/cuda-sim/ptx_parser.h | 134 ++++++----- src/cuda-sim/ptx_sim.cc | 2 + 8 files changed, 591 insertions(+), 548 deletions(-) (limited to 'src/cuda-sim/ptx_sim.cc') diff --git a/src/cuda-sim/cuda-sim.cc b/src/cuda-sim/cuda-sim.cc index f7bb9cc..e733b7f 100644 --- a/src/cuda-sim/cuda-sim.cc +++ b/src/cuda-sim/cuda-sim.cc @@ -30,6 +30,8 @@ #include "instructions.h" #include "ptx_ir.h" +class ptx_recognizer; +typedef void * yyscan_t; #include "ptx.tab.h" #include "ptx_sim.h" #include diff --git a/src/cuda-sim/instructions.cc b/src/cuda-sim/instructions.cc index 11001d7..69a97b6 100644 --- a/src/cuda-sim/instructions.cc +++ b/src/cuda-sim/instructions.cc @@ -31,6 +31,8 @@ #include "ptx_ir.h" #include "opcodes.h" #include "ptx_sim.h" +typedef void * yyscan_t; +class ptx_recognizer; #include "ptx.tab.h" #include #include diff --git a/src/cuda-sim/ptx.l b/src/cuda-sim/ptx.l index 3232361..d173451 100644 --- a/src/cuda-sim/ptx.l +++ b/src/cuda-sim/ptx.l @@ -31,21 +31,26 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. %option noyywrap %option yylineno %option prefix="ptx_" + +%option bison-bridge +%option reentrant + %{ #include "opcodes.h" +class ptx_recognizer; #include "ptx.tab.h" #include #define LINEBUF_SIZE (64*1024) char linebuf[LINEBUF_SIZE]; unsigned col = 0; -#define TC col+=strlen(ptx_text); +#define TC col+=strlen(yytext); #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 ); +int ptx_error( yyscan_t yyscanner, ptx_recognizer* recognizer, const char *s ); %} %s IN_STRING @@ -54,121 +59,121 @@ int ptx_error( const char *s ); %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; +abs TC; yylval->int_value = ABS_OP; return OPCODE; +add TC; yylval->int_value = ADD_OP; return OPCODE; +addp TC; yylval->int_value = ADDP_OP; return OPCODE; +addc TC; yylval->int_value = ADDC_OP; return OPCODE; +and TC; yylval->int_value = AND_OP; return OPCODE; +andn TC; yylval->int_value = ANDN_OP; return OPCODE; +atom TC; yylval->int_value = ATOM_OP; return OPCODE; +bar.warp TC; yylval->int_value = NOP_OP; return OPCODE; +bar TC; yylval->int_value = BAR_OP; return OPCODE; +bfe TC; yylval->int_value = BFE_OP; return OPCODE; +bfi TC; yylval->int_value = BFI_OP; return OPCODE; +bfind TC; yylval->int_value = BFIND_OP; return OPCODE; +bra TC; yylval->int_value = BRA_OP; return OPCODE; +brx TC; yylval->int_value = BRX_OP; return OPCODE; +brev TC; yylval->int_value = BREV_OP; return OPCODE; +brkpt TC; yylval->int_value = BRKPT_OP; return OPCODE; + +wmma TC; yylval->int_value = MMA_OP; return OPCODE; +wmma\.load TC; yylval->int_value = MMA_LD_OP; return OPCODE; +wmma\.store TC; yylval->int_value = MMA_ST_OP; return OPCODE; + +call TC; BEGIN(NOT_OPCODE); yylval->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); yylval->int_value = CALLP_OP; return OPCODE; +clz TC; yylval->int_value = CLZ_OP; return OPCODE; +cnot TC; yylval->int_value = CNOT_OP; return OPCODE; +cos TC; yylval->int_value = COS_OP; return OPCODE; +cvt TC; yylval->int_value = CVT_OP; return OPCODE; +cvta TC; yylval->int_value = CVTA_OP; return OPCODE; +div TC; yylval->int_value = DIV_OP; return OPCODE; +dp4a TC; yylval->int_value = DP4A_OP; return OPCODE; +ex2 TC; yylval->int_value = EX2_OP; return OPCODE; +exit TC; yylval->int_value = EXIT_OP; return OPCODE; +fma TC; yylval->int_value = FMA_OP; return OPCODE; +isspacep TC; yylval->int_value = ISSPACEP_OP; return OPCODE; +ld TC; yylval->int_value = LD_OP; return OPCODE; +ld.volatile TC; yylval->int_value = LD_OP; return OPCODE; +ldu TC; yylval->int_value = LDU_OP; return OPCODE; +lg2 TC; yylval->int_value = LG2_OP; return OPCODE; +mad24 TC; yylval->int_value = MAD24_OP; return OPCODE; +mad TC; yylval->int_value = MAD_OP; return OPCODE; +madc TC; yylval->int_value = MADC_OP; return OPCODE; +madp TC; yylval->int_value = MADP_OP; return OPCODE; +max TC; yylval->int_value = MAX_OP; return OPCODE; +membar TC; yylval->int_value = MEMBAR_OP; return OPCODE; +min TC; yylval->int_value = MIN_OP; return OPCODE; +mov TC; yylval->int_value = MOV_OP; return OPCODE; +mul24 TC; yylval->int_value = MUL24_OP; return OPCODE; +mul TC; yylval->int_value = MUL_OP; return OPCODE; +neg TC; yylval->int_value = NEG_OP; return OPCODE; +nandn TC; yylval->int_value = NANDN_OP; return OPCODE; +norn TC; yylval->int_value = NORN_OP; return OPCODE; +not TC; yylval->int_value = NOT_OP; return OPCODE; +or TC; yylval->int_value = OR_OP; return OPCODE; +orn TC; yylval->int_value = ORN_OP; return OPCODE; +pmevent TC; yylval->int_value = PMEVENT_OP; return OPCODE; +popc TC; yylval->int_value = POPC_OP; return OPCODE; +prefetch TC; yylval->int_value = PREFETCH_OP; return OPCODE; +prefetchu TC; yylval->int_value = PREFETCHU_OP; return OPCODE; +prmt TC; yylval->int_value = PRMT_OP; return OPCODE; +rcp TC; yylval->int_value = RCP_OP; return OPCODE; +red TC; yylval->int_value = RED_OP; return OPCODE; +rem TC; yylval->int_value = REM_OP; return OPCODE; +ret TC; yylval->int_value = RET_OP; return OPCODE; +retp TC; yylval->int_value = RETP_OP; return OPCODE; +rsqrt TC; yylval->int_value = RSQRT_OP; return OPCODE; +sad TC; yylval->int_value = SAD_OP; return OPCODE; +selp TC; yylval->int_value = SELP_OP; return OPCODE; +setp TC; yylval->int_value = SETP_OP; return OPCODE; +set TC; yylval->int_value = SET_OP; return OPCODE; +shfl TC; yylval->int_value = SHFL_OP; return OPCODE; +shl TC; yylval->int_value = SHL_OP; return OPCODE; +shr TC; yylval->int_value = SHR_OP; return OPCODE; +sin TC; yylval->int_value = SIN_OP; return OPCODE; +slct TC; yylval->int_value = SLCT_OP; return OPCODE; +sqrt TC; yylval->int_value = SQRT_OP; return OPCODE; +sst TC; yylval->int_value = SST_OP; return OPCODE; +ssy TC; yylval->int_value = SSY_OP; return OPCODE; +st TC; yylval->int_value = ST_OP; return OPCODE; +st.volatile TC; yylval->int_value = ST_OP; return OPCODE; +sub TC; yylval->int_value = SUB_OP; return OPCODE; +subc TC; yylval->int_value = SUBC_OP; return OPCODE; +suld TC; yylval->int_value = SULD_OP; return OPCODE; +sured TC; yylval->int_value = SURED_OP; return OPCODE; +surst TC; yylval->int_value = SUST_OP; return OPCODE; +suq TC; yylval->int_value = SUQ_OP; return OPCODE; +tex TC; BEGIN(NOT_OPCODE); yylval->int_value = TEX_OP; return OPCODE; +txq TC; yylval->int_value = TEX_OP; return OPCODE; +trap TC; yylval->int_value = TRAP_OP; return OPCODE; +vabsdiff TC; yylval->int_value = VABSDIFF_OP; return OPCODE; +vadd TC; yylval->int_value = VADD_OP; return OPCODE; +vmad TC; yylval->int_value = VMAD_OP; return OPCODE; +vmax TC; yylval->int_value = VMAX_OP; return OPCODE; +vmin TC; yylval->int_value = VMIN_OP; return OPCODE; +vset TC; yylval->int_value = VSET_OP; return OPCODE; +vshl TC; yylval->int_value = VSHL_OP; return OPCODE; +vshr TC; yylval->int_value = VSHR_OP; return OPCODE; +vsub TC; yylval->int_value = VSUB_OP; return OPCODE; +vote TC; yylval->int_value = VOTE_OP; return OPCODE; +xor TC; yylval->int_value = XOR_OP; return OPCODE; +nop TC; yylval->int_value = NOP_OP; return OPCODE; +break TC; yylval->int_value = BREAK_OP; return OPCODE; +breakaddr TC; yylval->int_value = BREAKADDR_OP; return OPCODE; "CPTX_END" printf("ENDING CUSTOM PTX.\n"); BEGIN(IN_COMMENT); { -\.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; +\.a\.sync TC; yylval->int_value = LOAD_A; return WMMA_DIRECTIVE; +\.b\.sync TC; yylval->int_value = LOAD_B; return WMMA_DIRECTIVE; +\.c\.sync TC; yylval->int_value = LOAD_C; return WMMA_DIRECTIVE; +\.d\.sync TC; yylval->int_value = STORE_D; return WMMA_DIRECTIVE; +\.mma\.sync TC;yylval->int_value=MMA; return WMMA_DIRECTIVE; + +\.row TC; yylval->int_value = ROW; return LAYOUT; +\.col TC; yylval->int_value = COL; return LAYOUT; +\.m16n16k16 TC; yylval->int_value = M16N16K16; return CONFIGURATION; \.f4e TC; return PRMT_F4E_MODE; \.b4e TC; return PRMT_B4E_MODE; \.rc8 TC; return PRMT_RC8_MODE; @@ -181,8 +186,8 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; \.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; +\.const\[[0-9]+\] TC; yylval->int_value = atoi(yytext+7); return CONST_DIRECTIVE; +\.const TC; yylval->int_value = 0; return CONST_DIRECTIVE; \.entry TC; return ENTRY_DIRECTIVE; \.extern TC; return EXTERN_DIRECTIVE; \.file TC; BEGIN(INITIAL); return FILE_DIRECTIVE; @@ -217,40 +222,40 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; \.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; +"%clock" TC; yylval->int_value = CLOCK_REG; return SPECIAL_REGISTER; +"%halfclock" TC; yylval->int_value = HALFCLOCK_ID; return SPECIAL_REGISTER; +"%clock64" TC; yylval->int_value = CLOCK64_REG; return SPECIAL_REGISTER; +"%ctaid" TC; yylval->int_value = CTAID_REG; return SPECIAL_REGISTER; +"%envreg"[0-9]+ TC; sscanf(yytext+7,"%u",&yylval->int_value); yylval->int_value<<=16; yylval->int_value += ENVREG_REG; return SPECIAL_REGISTER; +"%gridid" TC; yylval->int_value = GRIDID_REG; return SPECIAL_REGISTER; +"%laneid" TC; yylval->int_value = LANEID_REG; return SPECIAL_REGISTER; +"%lanemask_eq" TC; yylval->int_value = LANEMASK_EQ_REG; return SPECIAL_REGISTER; +"%lanemask_le" TC; yylval->int_value = LANEMASK_LE_REG; return SPECIAL_REGISTER; +"%lanemask_lt" TC; yylval->int_value = LANEMASK_LT_REG; return SPECIAL_REGISTER; +"%lanemask_ge" TC; yylval->int_value = LANEMASK_GE_REG; return SPECIAL_REGISTER; +"%lanemask_gt" TC; yylval->int_value = LANEMASK_GT_REG; return SPECIAL_REGISTER; +"%nctaid" TC; yylval->int_value = NCTAID_REG; return SPECIAL_REGISTER; +"%ntid" TC; yylval->int_value = NTID_REG; return SPECIAL_REGISTER; +"%nsmid" TC; yylval->int_value = NSMID_REG; return SPECIAL_REGISTER; +"%nwarpid" TC; yylval->int_value = NWARPID_REG; return SPECIAL_REGISTER; +"%pm"[0-3] TC; sscanf(yytext+3,"%u",&yylval->int_value); yylval->int_value<<=16; yylval->int_value += PM_REG; return SPECIAL_REGISTER; +"%smid" TC; yylval->int_value = SMID_REG; return SPECIAL_REGISTER; +"%tid" TC; yylval->int_value = TID_REG; return SPECIAL_REGISTER; +"%warpid" TC; yylval->int_value = WARPID_REG; return SPECIAL_REGISTER; +"WARP_SZ" TC; yylval->int_value = WARPSZ_REG; return SPECIAL_REGISTER; + +[a-zA-Z_][a-zA-Z0-9_$]* TC; yylval->string_value = strdup(yytext); return IDENTIFIER; +[$%][a-zA-Z0-9_$]+ TC; yylval->string_value = strdup(yytext); return IDENTIFIER; + +[0-9]+\.[0-9]+ TC; sscanf(yytext,"%lf", &yylval->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[xX][0-9a-fA-F]+U? TC; CHECK_UNSIGNED; sscanf(yytext,"%x", &yylval->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-9]+U? TC; CHECK_UNSIGNED; yylval->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; +0[fF][0-9a-fA-F]{8} TC; sscanf(yytext+2,"%x", (unsigned*)(void*)&yylval->float_value); return FLOAT_OPERAND; +0[dD][0-9a-fA-F]{16} TC; sscanf(yytext+2,"%Lx", (unsigned long long*)(void*)&yylval->double_value); return DOUBLE_OPERAND; \.s8 TC; return S8_TYPE; \.s16 TC; return S16_TYPE; @@ -383,12 +388,12 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; \.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; +\.0 TC; yylval->int_value = 0; return DIMENSION_MODIFIER; +\.1 TC; yylval->int_value = 1; return DIMENSION_MODIFIER; +\.2 TC; yylval->int_value = 2; return DIMENSION_MODIFIER; +\.x TC; yylval->int_value = 0; return DIMENSION_MODIFIER; +\.y TC; yylval->int_value = 1; return DIMENSION_MODIFIER; +\.z TC; yylval->int_value = 2; return DIMENSION_MODIFIER; "-" TC; return MINUS; "+" TC; return PLUS; @@ -439,24 +444,26 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE; } { "\"" TC; BEGIN(INITIAL); return STRING; -[^\"]* TC; ptx_lval.string_value = strdup(yytext); +[^\"]* TC; yylval->string_value = strdup(yytext); } <*>\t@@DWARF.*\n -. TC; ptx_error((const char*)NULL); +. TC; %% +//ptx_error(yyscanner, (const char*)NULL); extern int g_error_detected; extern const char *g_filename; -int ptx_error( const char *s ) +int ptx_error( yyscan_t yyscanner, ptx_recognizer* recognizer, const char *s ) { + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; int i; g_error_detected = 1; fflush(stdout); if( s != NULL ) - printf("%s:%u: Syntax error:\n\n", g_filename, ptx_lineno ); + printf("%s:%u Syntax error:\n\n", g_filename, yylineno ); printf(" %s\n", linebuf ); printf(" "); for( i=0; i < col-1; i++ ) { diff --git a/src/cuda-sim/ptx.y b/src/cuda-sim/ptx.y index 45392fb..366b0cc 100644 --- a/src/cuda-sim/ptx.y +++ b/src/cuda-sim/ptx.y @@ -27,6 +27,16 @@ 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. */ +%{ +typedef void * yyscan_t; +class ptx_recognizer; +%} + +%define api.pure full +%parse-param {yyscan_t scanner} +%parse-param {ptx_recognizer* recognizer} +%lex-param {yyscan_t scanner} + %union { double double_value; float float_value; @@ -217,10 +227,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include #include - void syntax_not_implemented(); + void syntax_not_implemented(yyscan_t yyscanner, ptx_recognizer* recognizer); extern int g_func_decl; - int ptx_lex(void); - int ptx_error(const char *); + int ptx_lex(YYSTYPE * yylval_param, yyscan_t yyscanner); + int ptx_error( yyscan_t yyscanner, ptx_recognizer* recognizer, const char *s ); %} %% @@ -231,96 +241,96 @@ input: /* empty */ | 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(); } +function_defn: function_decl { recognizer->set_symtab($1); recognizer->func_header(".skip"); } statement_block { recognizer->end_function(); } + | function_decl { recognizer->set_symtab($1); } block_spec_list { recognizer->func_header(".skip"); } statement_block { recognizer->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: MAXNTID_DIRECTIVE INT_OPERAND COMMA INT_OPERAND COMMA INT_OPERAND {recognizer->func_header_info_int(".maxntid", $2); + recognizer->func_header_info_int(",", $4); + recognizer->func_header_info_int(",", $6); + recognizer->maxnt_id($2, $4, $6);} + | MINNCTAPERSM_DIRECTIVE INT_OPERAND { recognizer->func_header_info_int(".minnctapersm", $2); printf("GPGPU-Sim: Warning: .minnctapersm ignored. \n"); } + | MAXNCTAPERSM_DIRECTIVE INT_OPERAND { recognizer->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_decl: function_decl_header LEFT_PAREN { recognizer->start_function($1); recognizer->func_header_info("(");} param_entry RIGHT_PAREN {recognizer->func_header_info(")");} function_ident_param { $$ = recognizer->reset_symtab(); } + | function_decl_header { recognizer->start_function($1); } function_ident_param { $$ = recognizer->reset_symtab(); } + | function_decl_header { recognizer->start_function($1); recognizer->add_function_name(""); g_func_decl=0; $$ = recognizer->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_ident_param: IDENTIFIER { recognizer->add_function_name($1); } LEFT_PAREN {recognizer->func_header_info("(");} param_list RIGHT_PAREN { g_func_decl=0; recognizer->func_header_info(")"); } + | IDENTIFIER { recognizer->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"); } +function_decl_header: ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; recognizer->func_header(".entry"); } + | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; recognizer->func_header(".entry"); } + | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; recognizer->func_header(".entry"); } + | FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); } + | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); } + | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); } + | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; g_func_decl=1; recognizer->func_header(".func"); } + | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); } ; param_list: /*empty*/ - | param_entry { add_directive(); } - | param_list COMMA {func_header_info(",");} param_entry { add_directive(); } + | param_entry { recognizer->add_directive(); } + | param_list COMMA {recognizer->func_header_info(",");} param_entry { recognizer->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(); } +param_entry: PARAM_DIRECTIVE { recognizer->add_space_spec(param_space_unclassified,0); } variable_spec ptr_spec identifier_spec { recognizer->add_function_arg(); } + | REG_DIRECTIVE { recognizer->add_space_spec(reg_space,0); } variable_spec identifier_spec { recognizer->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_space_spec: GLOBAL_DIRECTIVE { recognizer->add_ptr_spec(global_space); } + | LOCAL_DIRECTIVE { recognizer->add_ptr_spec(local_space); } + | SHARED_DIRECTIVE { recognizer->add_ptr_spec(shared_space); } + | CONST_DIRECTIVE { recognizer->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();} +statement_list: directive_statement { recognizer->add_directive(); } + | instruction_statement { recognizer->add_instruction(); } + | statement_list directive_statement { recognizer->add_directive(); } + | statement_list instruction_statement { recognizer->add_instruction(); } + | statement_list {recognizer->start_inst_group();} statement_block {recognizer->end_inst_group();} + | {recognizer->start_inst_group();} statement_block {recognizer->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); } + | VERSION_DIRECTIVE DOUBLE_OPERAND { recognizer->add_version_info($2, 0); } + | VERSION_DIRECTIVE DOUBLE_OPERAND PLUS { recognizer->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); } + | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER { recognizer->target_header2($2,$4); } + | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER { recognizer->target_header3($2,$4,$6); } + | TARGET_DIRECTIVE IDENTIFIER { recognizer->target_header($2); } + | FILE_DIRECTIVE INT_OPERAND STRING { recognizer->add_file($2,$3); } + | FILE_DIRECTIVE INT_OPERAND STRING COMMA INT_OPERAND COMMA INT_OPERAND { recognizer->add_file($2,$3); } | LOC_DIRECTIVE INT_OPERAND INT_OPERAND INT_OPERAND - | PRAGMA_DIRECTIVE STRING SEMI_COLON { add_pragma($2); } + | PRAGMA_DIRECTIVE STRING SEMI_COLON { recognizer->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_declaration: variable_spec identifier_list { recognizer->add_variables(); } + | variable_spec identifier_spec EQUALS initializer_list { recognizer->add_variables(); } + | variable_spec identifier_spec EQUALS literal_operand { recognizer->add_variables(); } + | CONSTPTR_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA INT_OPERAND { recognizer->add_constptr($2, $4, $6); } ; -variable_spec: var_spec_list { set_variable_type(); } +variable_spec: var_spec_list { recognizer->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(">"); +identifier_spec: IDENTIFIER { recognizer->add_identifier($1,0,NON_ARRAY_IDENTIFIER); recognizer->func_header_info($1);} + | IDENTIFIER LEFT_ANGLE_BRACKET INT_OPERAND RIGHT_ANGLE_BRACKET { recognizer->func_header_info($1); recognizer->func_header_info_int("<", $3); recognizer->func_header_info(">"); int i,lbase,l; char *id = NULL; lbase = strlen($1); @@ -328,12 +338,12 @@ identifier_spec: IDENTIFIER { add_identifier($1,0,NON_ARRAY_IDENTIFIER); func_he 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); + recognizer->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("]");} + | IDENTIFIER LEFT_SQUARE_BRACKET RIGHT_SQUARE_BRACKET { recognizer->add_identifier($1,0,ARRAY_IDENTIFIER_NO_DIM); recognizer->func_header_info($1); recognizer->func_header_info("["); recognizer->func_header_info("]");} + | IDENTIFIER LEFT_SQUARE_BRACKET INT_OPERAND RIGHT_SQUARE_BRACKET { recognizer->add_identifier($1,$3,ARRAY_IDENTIFIER); recognizer->func_header_info($1); recognizer->func_header_info_int("[",$3); recognizer->func_header_info("]");} ; var_spec_list: var_spec @@ -343,93 +353,93 @@ var_spec: space_spec | type_spec | align_spec | VISIBLE_DIRECTIVE - | EXTERN_DIRECTIVE { add_extern_spec(); } + | EXTERN_DIRECTIVE { recognizer->add_extern_spec(); } | WEAK_DIRECTIVE ; -align_spec: ALIGN_DIRECTIVE INT_OPERAND { add_alignment_spec($2); } +align_spec: ALIGN_DIRECTIVE INT_OPERAND { recognizer->add_alignment_spec($2); } -space_spec: REG_DIRECTIVE { add_space_spec(reg_space,0); } - | SREG_DIRECTIVE { add_space_spec(reg_space,0); } +space_spec: REG_DIRECTIVE { recognizer->add_space_spec(reg_space,0); } + | SREG_DIRECTIVE { recognizer->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); } +addressable_spec: CONST_DIRECTIVE { recognizer->add_space_spec(const_space,$1); } + | GLOBAL_DIRECTIVE { recognizer->add_space_spec(global_space,0); } + | LOCAL_DIRECTIVE { recognizer->add_space_spec(local_space,0); } + | PARAM_DIRECTIVE { recognizer->add_space_spec(param_space_unclassified,0); } + | SHARED_DIRECTIVE { recognizer->add_space_spec(shared_space,0); } + | SSTARR_DIRECTIVE { recognizer->add_space_spec(sstarr_space,0); } + | SURF_DIRECTIVE { recognizer->add_space_spec(surf_space,0); } + | TEX_DIRECTIVE { recognizer->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(); } +vector_spec: V2_TYPE { recognizer->add_option(V2_TYPE); recognizer->func_header_info(".v2");} + | V3_TYPE { recognizer->add_option(V3_TYPE); recognizer->func_header_info(".v3");} + | V4_TYPE { recognizer->add_option(V4_TYPE); recognizer->func_header_info(".v4");} + ; + +scalar_type: S8_TYPE { recognizer->add_scalar_type_spec( S8_TYPE ); } + | S16_TYPE { recognizer->add_scalar_type_spec( S16_TYPE ); } + | S32_TYPE { recognizer->add_scalar_type_spec( S32_TYPE ); } + | S64_TYPE { recognizer->add_scalar_type_spec( S64_TYPE ); } + | U8_TYPE { recognizer->add_scalar_type_spec( U8_TYPE ); } + | U16_TYPE { recognizer->add_scalar_type_spec( U16_TYPE ); } + | U32_TYPE { recognizer->add_scalar_type_spec( U32_TYPE ); } + | U64_TYPE { recognizer->add_scalar_type_spec( U64_TYPE ); } + | F16_TYPE { recognizer->add_scalar_type_spec( F16_TYPE ); } + | F32_TYPE { recognizer->add_scalar_type_spec( F32_TYPE ); } + | F64_TYPE { recognizer->add_scalar_type_spec( F64_TYPE ); } + | FF64_TYPE { recognizer->add_scalar_type_spec( FF64_TYPE ); } + | B8_TYPE { recognizer->add_scalar_type_spec( B8_TYPE ); } + | B16_TYPE { recognizer->add_scalar_type_spec( B16_TYPE ); } + | B32_TYPE { recognizer->add_scalar_type_spec( B32_TYPE ); } + | B64_TYPE { recognizer->add_scalar_type_spec( B64_TYPE ); } + | BB64_TYPE { recognizer->add_scalar_type_spec( BB64_TYPE ); } + | BB128_TYPE { recognizer->add_scalar_type_spec( BB128_TYPE ); } + | PRED_TYPE { recognizer->add_scalar_type_spec( PRED_TYPE ); } + | TEXREF_TYPE { recognizer->add_scalar_type_spec( TEXREF_TYPE ); } + | SAMPLERREF_TYPE { recognizer->add_scalar_type_spec( SAMPLERREF_TYPE ); } + | SURFREF_TYPE { recognizer->add_scalar_type_spec( SURFREF_TYPE ); } + ; + +initializer_list: LEFT_BRACE literal_list RIGHT_BRACE { recognizer->add_array_initializer(); } + | LEFT_BRACE initializer_list RIGHT_BRACE { syntax_not_implemented(scanner, recognizer); } literal_list: literal_operand | literal_list COMMA literal_operand; instruction_statement: instruction SEMI_COLON - | IDENTIFIER COLON { add_label($1); } + | IDENTIFIER COLON { recognizer->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 +instruction: opcode_spec LEFT_PAREN operand RIGHT_PAREN { recognizer->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); } +opcode_spec: OPCODE { recognizer->add_opcode($1); } option_list + | OPCODE { recognizer->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); } +pred_spec: PRED IDENTIFIER { recognizer->add_pred($2,0, -1); } + | PRED EXCLAMATION IDENTIFIER { recognizer->add_pred($3,1, -1); } + | PRED IDENTIFIER LT_OPTION { recognizer->add_pred($2,0,1); } + | PRED IDENTIFIER EQ_OPTION { recognizer->add_pred($2,0,2); } + | PRED IDENTIFIER LE_OPTION { recognizer->add_pred($2,0,3); } + | PRED IDENTIFIER NE_OPTION { recognizer->add_pred($2,0,5); } + | PRED IDENTIFIER GE_OPTION { recognizer->add_pred($2,0,6); } + | PRED IDENTIFIER EQU_OPTION { recognizer->add_pred($2,0,10); } + | PRED IDENTIFIER GTU_OPTION { recognizer->add_pred($2,0,12); } + | PRED IDENTIFIER NEU_OPTION { recognizer->add_pred($2,0,13); } + | PRED IDENTIFIER CF_OPTION { recognizer->add_pred($2,0,17); } + | PRED IDENTIFIER SF_OPTION { recognizer->add_pred($2,0,19); } + | PRED IDENTIFIER NSF_OPTION { recognizer->add_pred($2,0,28); } ; option_list: option @@ -441,108 +451,108 @@ option: type_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); } + | SYNC_OPTION { recognizer->add_option(SYNC_OPTION); } + | ARRIVE_OPTION { recognizer->add_option(ARRIVE_OPTION); } + | RED_OPTION { recognizer->add_option(RED_OPTION); } + | UNI_OPTION { recognizer->add_option(UNI_OPTION); } + | WIDE_OPTION { recognizer->add_option(WIDE_OPTION); } + | ANY_OPTION { recognizer->add_option(ANY_OPTION); } + | ALL_OPTION { recognizer->add_option(ALL_OPTION); } + | BALLOT_OPTION { recognizer->add_option(BALLOT_OPTION); } + | GLOBAL_OPTION { recognizer->add_option(GLOBAL_OPTION); } + | CTA_OPTION { recognizer->add_option(CTA_OPTION); } + | SYS_OPTION { recognizer->add_option(SYS_OPTION); } + | GEOM_MODIFIER_1D { recognizer->add_option(GEOM_MODIFIER_1D); } + | GEOM_MODIFIER_2D { recognizer->add_option(GEOM_MODIFIER_2D); } + | GEOM_MODIFIER_3D { recognizer->add_option(GEOM_MODIFIER_3D); } + | SAT_OPTION { recognizer->add_option(SAT_OPTION); } + | FTZ_OPTION { recognizer->add_option(FTZ_OPTION); } + | NEG_OPTION { recognizer->add_option(NEG_OPTION); } + | APPROX_OPTION { recognizer->add_option(APPROX_OPTION); } + | FULL_OPTION { recognizer->add_option(FULL_OPTION); } + | EXIT_OPTION { recognizer->add_option(EXIT_OPTION); } + | ABS_OPTION { recognizer->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); } + | TO_OPTION { recognizer->add_option(TO_OPTION); } + | HALF_OPTION { recognizer->add_option(HALF_OPTION); } + | EXTP_OPTION { recognizer->add_option(EXTP_OPTION); } + | CA_OPTION { recognizer->add_option(CA_OPTION); } + | CG_OPTION { recognizer->add_option(CG_OPTION); } + | CS_OPTION { recognizer->add_option(CS_OPTION); } + | LU_OPTION { recognizer->add_option(LU_OPTION); } + | CV_OPTION { recognizer->add_option(CV_OPTION); } + | WB_OPTION { recognizer->add_option(WB_OPTION); } + | WT_OPTION { recognizer->add_option(WT_OPTION); } + | NC_OPTION { recognizer->add_option(NC_OPTION); } + | UP_OPTION { recognizer->add_option(UP_OPTION); } + | DOWN_OPTION { recognizer->add_option(DOWN_OPTION); } + | BFLY_OPTION { recognizer->add_option(BFLY_OPTION); } + | IDX_OPTION { recognizer->add_option(IDX_OPTION); } + ; + +atomic_operation_spec: ATOMIC_AND { recognizer->add_option(ATOMIC_AND); } + | ATOMIC_POPC { recognizer->add_option(ATOMIC_POPC); } + | ATOMIC_OR { recognizer->add_option(ATOMIC_OR); } + | ATOMIC_XOR { recognizer->add_option(ATOMIC_XOR); } + | ATOMIC_CAS { recognizer->add_option(ATOMIC_CAS); } + | ATOMIC_EXCH { recognizer->add_option(ATOMIC_EXCH); } + | ATOMIC_ADD { recognizer->add_option(ATOMIC_ADD); } + | ATOMIC_INC { recognizer->add_option(ATOMIC_INC); } + | ATOMIC_DEC { recognizer->add_option(ATOMIC_DEC); } + | ATOMIC_MIN { recognizer->add_option(ATOMIC_MIN); } + | ATOMIC_MAX { recognizer->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); } +floating_point_rounding_mode: RN_OPTION { recognizer->add_option(RN_OPTION); } + | RZ_OPTION { recognizer->add_option(RZ_OPTION); } + | RM_OPTION { recognizer->add_option(RM_OPTION); } + | RP_OPTION { recognizer->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); } +integer_rounding_mode: RNI_OPTION { recognizer->add_option(RNI_OPTION); } + | RZI_OPTION { recognizer->add_option(RZI_OPTION); } + | RMI_OPTION { recognizer->add_option(RMI_OPTION); } + | RPI_OPTION { recognizer->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); } +compare_spec:EQ_OPTION { recognizer->add_option(EQ_OPTION); } + | NE_OPTION { recognizer->add_option(NE_OPTION); } + | LT_OPTION { recognizer->add_option(LT_OPTION); } + | LE_OPTION { recognizer->add_option(LE_OPTION); } + | GT_OPTION { recognizer->add_option(GT_OPTION); } + | GE_OPTION { recognizer->add_option(GE_OPTION); } + | LO_OPTION { recognizer->add_option(LO_OPTION); } + | LS_OPTION { recognizer->add_option(LS_OPTION); } + | HI_OPTION { recognizer->add_option(HI_OPTION); } + | HS_OPTION { recognizer->add_option(HS_OPTION); } + | EQU_OPTION { recognizer->add_option(EQU_OPTION); } + | NEU_OPTION { recognizer->add_option(NEU_OPTION); } + | LTU_OPTION { recognizer->add_option(LTU_OPTION); } + | LEU_OPTION { recognizer->add_option(LEU_OPTION); } + | GTU_OPTION { recognizer->add_option(GTU_OPTION); } + | GEU_OPTION { recognizer->add_option(GEU_OPTION); } + | NUM_OPTION { recognizer->add_option(NUM_OPTION); } + | NAN_OPTION { recognizer->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); } +prmt_spec: PRMT_F4E_MODE { recognizer->add_option( PRMT_F4E_MODE); } + | PRMT_B4E_MODE { recognizer->add_option( PRMT_B4E_MODE); } + | PRMT_RC8_MODE { recognizer->add_option( PRMT_RC8_MODE); } + | PRMT_RC16_MODE{ recognizer->add_option( PRMT_RC16_MODE);} + | PRMT_ECL_MODE { recognizer->add_option( PRMT_ECL_MODE); } + | PRMT_ECR_MODE { recognizer->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);} +wmma_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{recognizer->add_space_spec(global_space,0);recognizer->add_ptr_spec(global_space); recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);} + | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);recognizer->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);} +vp_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{recognizer->add_space_spec(global_space,0);recognizer->add_ptr_spec(global_space);recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);} + | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{recognizer->add_wmma_option($1);recognizer->add_wmma_option($2);recognizer->add_wmma_option($3);recognizer->add_wmma_option($4);} ; @@ -550,80 +560,79 @@ vp_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ 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(); } +operand: IDENTIFIER { recognizer->add_scalar_operand( $1 ); } + | EXCLAMATION IDENTIFIER { recognizer->add_neg_pred_operand( $2 ); } + | MINUS IDENTIFIER { recognizer->add_scalar_operand( $2 ); recognizer->change_operand_neg(); } | memory_operand | literal_operand | builtin_operand | vector_operand - | MINUS vector_operand { change_operand_neg(); } + | MINUS vector_operand { recognizer->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); } + | IDENTIFIER PLUS INT_OPERAND { recognizer->add_address_operand($1,$3); } + | IDENTIFIER LO_OPTION { recognizer->add_scalar_operand( $1 ); recognizer->change_operand_lohi(1);} + | MINUS IDENTIFIER LO_OPTION { recognizer->add_scalar_operand( $2 ); recognizer->change_operand_lohi(1); recognizer->change_operand_neg();} + | IDENTIFIER HI_OPTION { recognizer->add_scalar_operand( $1 ); recognizer->change_operand_lohi(2);} + | MINUS IDENTIFIER HI_OPTION { recognizer->add_scalar_operand( $2 ); recognizer->change_operand_lohi(2); recognizer->change_operand_neg();} + | IDENTIFIER PIPE IDENTIFIER { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-1);} + | IDENTIFIER PIPE IDENTIFIER LO_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-1); recognizer->change_operand_lohi(1);} + | IDENTIFIER PIPE IDENTIFIER HI_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-1); recognizer->change_operand_lohi(2);} + | IDENTIFIER BACKSLASH IDENTIFIER { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-3);} + | IDENTIFIER BACKSLASH IDENTIFIER LO_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-3); recognizer->change_operand_lohi(1);} + | IDENTIFIER BACKSLASH IDENTIFIER HI_OPTION { recognizer->add_2vector_operand($1,$3); recognizer->change_double_operand_type(-3); recognizer->change_operand_lohi(2);} + ; + +vector_operand: LEFT_BRACE IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { recognizer->add_2vector_operand($2,$4); } + | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { recognizer->add_3vector_operand($2,$4,$6); } + | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { recognizer->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 { recognizer->add_8vector_operand($2,$4,$6,$8,$10,$12,$14,$16); } + | LEFT_BRACE IDENTIFIER RIGHT_BRACE { recognizer->add_1vector_operand($2); } + ; + +tex_operand: LEFT_SQUARE_BRACKET IDENTIFIER COMMA { recognizer->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); } +builtin_operand: SPECIAL_REGISTER DIMENSION_MODIFIER { recognizer->add_builtin_operand($1,$2); } + | SPECIAL_REGISTER { recognizer->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(); } +memory_operand : LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { recognizer->add_memory_operand(); } + | IDENTIFIER LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { recognizer->add_memory_operand(); recognizer->change_memory_addr_space($1); } + | IDENTIFIER LEFT_SQUARE_BRACKET literal_operand RIGHT_SQUARE_BRACKET { recognizer->change_memory_addr_space($1); } + | IDENTIFIER LEFT_SQUARE_BRACKET twin_operand RIGHT_SQUARE_BRACKET { recognizer->change_memory_addr_space($1); recognizer->add_memory_operand();} + | MINUS memory_operand { recognizer->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); } +twin_operand : IDENTIFIER PLUS IDENTIFIER { recognizer->add_double_operand($1,$3); recognizer->change_double_operand_type(1); } + | IDENTIFIER PLUS IDENTIFIER LO_OPTION { recognizer->add_double_operand($1,$3); recognizer->change_double_operand_type(1); recognizer->change_operand_lohi(1); } + | IDENTIFIER PLUS IDENTIFIER HI_OPTION { recognizer->add_double_operand($1,$3); recognizer->change_double_operand_type(1); recognizer->change_operand_lohi(2); } + | IDENTIFIER PLUS EQUALS IDENTIFIER { recognizer->add_double_operand($1,$4); recognizer->change_double_operand_type(2); } + | IDENTIFIER PLUS EQUALS IDENTIFIER LO_OPTION { recognizer->add_double_operand($1,$4); recognizer->change_double_operand_type(2); recognizer->change_operand_lohi(1); } + | IDENTIFIER PLUS EQUALS IDENTIFIER HI_OPTION { recognizer->add_double_operand($1,$4); recognizer->change_double_operand_type(2); recognizer->change_operand_lohi(2); } + | IDENTIFIER PLUS EQUALS INT_OPERAND { recognizer->add_address_operand($1,$4); recognizer->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); } +literal_operand : INT_OPERAND { recognizer->add_literal_int($1); } + | FLOAT_OPERAND { recognizer->add_literal_float($1); } + | DOUBLE_OPERAND { recognizer->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); } +address_expression: IDENTIFIER { recognizer->add_address_operand($1,0); } + | IDENTIFIER LO_OPTION { recognizer->add_address_operand($1,0); recognizer->change_operand_lohi(1);} + | IDENTIFIER HI_OPTION { recognizer->add_address_operand($1,0); recognizer->change_operand_lohi(2); } + | IDENTIFIER PLUS INT_OPERAND { recognizer->add_address_operand($1,$3); } + | INT_OPERAND { recognizer->add_address_operand2($1); } ; %% -extern int ptx_lineno; extern const char *g_filename; -void syntax_not_implemented() +void syntax_not_implemented(yyscan_t yyscanner, ptx_recognizer* recognizer) { - printf("Parse error (%s:%u): this syntax is not (yet) implemented:\n",g_filename,ptx_lineno); - ptx_error(NULL); + printf("Parse error (%s): this syntax is not (yet) implemented:\n",g_filename); + ptx_error(yyscanner, recognizer, NULL); abort(); } diff --git a/src/cuda-sim/ptx_ir.cc b/src/cuda-sim/ptx_ir.cc index 73db24d..8cedf79 100644 --- a/src/cuda-sim/ptx_ir.cc +++ b/src/cuda-sim/ptx_ir.cc @@ -28,6 +28,7 @@ #include "ptx_parser.h" #include "ptx_ir.h" +typedef void * yyscan_t; #include "ptx.tab.h" #include "opcodes.h" #include diff --git a/src/cuda-sim/ptx_parser.cc b/src/cuda-sim/ptx_parser.cc index 25758dd..a1f6e00 100644 --- a/src/cuda-sim/ptx_parser.cc +++ b/src/cuda-sim/ptx_parser.cc @@ -27,13 +27,17 @@ #include "ptx_parser.h" #include "ptx_ir.h" + +typedef void * yyscan_t; #include "ptx.tab.h" #include -extern int ptx_error( const char *s ); -extern int ptx_lineno; -extern int ptx_parse(); -extern FILE *ptx_in; +extern int ptx_get_lineno (yyscan_t yyscanner ); +extern int ptx_error( yyscan_t yyscanner, const char *s ); +extern int ptx_lex_init(yyscan_t* scanner); +extern void ptx_set_in(FILE * _in_str ,yyscan_t yyscanner ); +extern int ptx_parse(yyscan_t scanner, ptx_recognizer* recognizer); +extern int ptx_lex_destroy(yyscan_t scanner); static const struct core_config *g_shader_core_config; void set_ptx_warp_size(const struct core_config * warp_size) @@ -80,7 +84,7 @@ std::list g_scalar_type; #define PTX_PARSE_DPRINTF(...) \ if( g_debug_ir_generation ) { \ - printf(" %s:%u => ",g_filename,ptx_lineno); \ + printf(" %s:%u => ",g_filename,ptx_get_lineno(scanner)); \ printf(" (%s:%u) ", __FILE__, __LINE__); \ printf(__VA_ARGS__); \ printf("\n"); \ @@ -109,7 +113,7 @@ void read_parser_environment_variables() } } -void init_directive_state() +void ptx_recognizer::init_directive_state() { PTX_PARSE_DPRINTF("init_directive_state"); g_space_spec=undefined_space; @@ -125,7 +129,7 @@ void init_directive_state() g_last_symbol = NULL; } -void init_instruction_state() +void ptx_recognizer::init_instruction_state() { PTX_PARSE_DPRINTF("init_instruction_state"); g_pred = NULL; @@ -149,7 +153,6 @@ symbol_table *init_parser( const char *ptx_filename ) /*else { g_global_symbol_table = g_current_symbol_table = new symbol_table("global",0,g_global_allfiles_symbol_table); }*/ - ptx_lineno = 1; #define DEF(X,Y) g_ptx_token_decode[X] = Y; #include "ptx_parser_decode.def" @@ -169,18 +172,23 @@ symbol_table *init_parser( const char *ptx_filename ) g_ptx_token_decode[generic_space] = "generic_space"; g_ptx_token_decode[instruction_space] = "instruction_space"; - init_directive_state(); - init_instruction_state(); + ptx_recognizer recognizer; + ptx_lex_init(&(recognizer.scanner)); + recognizer.init_directive_state(); + recognizer.init_instruction_state(); + FILE *ptx_in; ptx_in = fopen(ptx_filename, "r"); - ptx_parse(); + ptx_set_in(ptx_in, recognizer.scanner); + ptx_parse(recognizer.scanner, &recognizer); + ptx_lex_destroy(recognizer.scanner); fclose(ptx_in); return g_global_symbol_table; } static int g_entry_point; -void start_function( int entry_point ) +void ptx_recognizer::start_function( int entry_point ) { PTX_PARSE_DPRINTF("start_function"); init_directive_state(); @@ -194,7 +202,7 @@ char *g_add_identifier_cached__identifier = NULL; int g_add_identifier_cached__array_dim; int g_add_identifier_cached__array_ident; -void add_function_name( const char *name ) +void ptx_recognizer::add_function_name( const char *name ) { PTX_PARSE_DPRINTF("add_function_name %s %s", name, ((g_entry_point==1)?"(entrypoint)":((g_entry_point==2)?"(extern)":""))); bool prior_decl = g_global_symbol_table->add_function_decl( name, g_entry_point, &g_func_info, &g_current_symbol_table ); @@ -210,21 +218,21 @@ void add_function_name( const char *name ) if( prior_decl ) { g_func_info->remove_args(); } - g_global_symbol_table->add_function( g_func_info, g_filename, ptx_lineno ); + g_global_symbol_table->add_function( g_func_info, g_filename, ptx_get_lineno(scanner) ); } //Jin: handle instruction group for cdp -void start_inst_group() { +void ptx_recognizer::start_inst_group() { PTX_PARSE_DPRINTF("start_instruction_group"); g_current_symbol_table = g_current_symbol_table->start_inst_group(); } -void end_inst_group() { +void ptx_recognizer::end_inst_group() { PTX_PARSE_DPRINTF("end_instruction_group"); g_current_symbol_table = g_current_symbol_table->end_inst_group(); } -void add_directive() +void ptx_recognizer::add_directive() { PTX_PARSE_DPRINTF("add_directive"); init_directive_state(); @@ -232,7 +240,7 @@ void add_directive() #define mymax(a,b) ((a)>(b)?(a):(b)) -void end_function() +void ptx_recognizer::end_function() { PTX_PARSE_DPRINTF("end_function"); @@ -250,7 +258,7 @@ void end_function() #define parse_error(msg, ...) parse_error_impl(__FILE__,__LINE__, msg, ##__VA_ARGS__) #define parse_assert(cond,msg, ...) parse_assert_impl((cond),__FILE__,__LINE__, msg, ##__VA_ARGS__) -void parse_error_impl( const char *file, unsigned line, const char *msg, ... ) +void ptx_recognizer::parse_error_impl( const char *file, unsigned line, const char *msg, ... ) { va_list ap; char buf[1024]; @@ -259,13 +267,13 @@ void parse_error_impl( const char *file, unsigned line, const char *msg, ... ) va_end(ap); g_error_detected = 1; - printf("%s:%u: Parse error: %s (%s:%u)\n\n", g_filename, ptx_lineno, buf, file, line); - ptx_error(NULL); + printf("%s:%u: Parse error: %s (%s:%u)\n\n", g_filename, ptx_get_lineno(scanner), buf, file, line); + ptx_error(scanner, NULL); abort(); exit(1); } -void parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... ) +void ptx_recognizer::parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... ) { va_list ap; char buf[1024]; @@ -280,7 +288,7 @@ void parse_assert_impl( int test_value, const char *file, unsigned line, const c extern char linebuf[4096]; -void set_return() +void ptx_recognizer::set_return() { parse_assert( (g_opcode == CALL_OP || g_opcode == CALLP_OP), "only call can have return value"); g_operands.front().set_return(); @@ -300,7 +308,7 @@ const ptx_instruction *ptx_instruction_lookup( const char *filename, unsigned li return l->second; } -void add_instruction() +void ptx_recognizer::add_instruction() { PTX_PARSE_DPRINTF("add_instruction: %s", ((g_opcode>0)?g_opcode_string[g_opcode]:"