Move ptx parser to reentrant

Signed-off-by: Mengchi Zhang <[email protected]>

8 files changed, 576 insertions, 533 deletions

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 <stdio.h>
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 <stdlib.h>
 #include <math.h>
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 <string.h>
 
 #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;
+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; 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;
+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); 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;
+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);
 
 <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;
+\.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; 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;
+\.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;
+"%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; ptx_lval.string_value = strdup(yytext); return IDENTIFIER;
-[$%][a-zA-Z0-9_$]+  TC; ptx_lval.string_value = strdup(yytext); return IDENTIFIER;
+[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", &ptx_lval.double_value); return DOUBLE_OPERAND;
+[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;
 }
 <IN_STRING>{
 "\"" 	TC; BEGIN(INITIAL); return STRING;
-[^\"]*	TC; ptx_lval.string_value = strdup(yytext); 
+[^\"]*	TC; yylval->string_value = strdup(yytext);
 }
 
 <*>\t@@DWARF.*\n
 
-<INITIAL,NOT_OPCODE,IN_FUNC_DECL>.  TC; ptx_error((const char*)NULL);
+<INITIAL,NOT_OPCODE,IN_FUNC_DECL>.  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 <stdlib.h>
 	#include <string.h>
 	#include <math.h>
-	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");}
+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 { 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 ); }
+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 { add_array_initializer(); } 
-	| LEFT_BRACE initializer_list RIGHT_BRACE { syntax_not_implemented(); }
+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); }
+	| 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 { 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); } 
+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);}
+	| 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 { 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); }
+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 { add_scalar_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 <stdio.h>
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 <stdarg.h>
 
-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<int> 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]:"<label>") );
    assert( g_shader_core_config != 0 );
@@ -316,15 +324,15 @@ void add_instruction()
                                              g_scalar_type,
                                              g_space_spec,
                                              g_filename,
-                                             ptx_lineno,
+                                             ptx_get_lineno(scanner),
                                              linebuf,
                                              g_shader_core_config );
    g_instructions.push_back(i);
-   g_inst_lookup[g_filename][ptx_lineno] = i;
+   g_inst_lookup[g_filename][ptx_get_lineno(scanner)] = i;
    init_instruction_state();
 }
 
-void add_variables() 
+void ptx_recognizer::add_variables()
 {
    PTX_PARSE_DPRINTF("add_variables");
    if ( !g_operands.empty() ) {
@@ -334,7 +342,7 @@ void add_variables()
    init_directive_state();
 }
 
-void set_variable_type()
+void ptx_recognizer::set_variable_type()
 {
    PTX_PARSE_DPRINTF("set_variable_type space_spec=%s scalar_type_spec=%s", 
            g_ptx_token_decode[g_space_spec.get_type()].c_str(), 
@@ -378,7 +386,7 @@ int pad_address (new_addr_type address, unsigned size, unsigned maxalign) {
     return alignto ? ((alignto - (address % alignto)) % alignto) : 0;
 }
 
-void add_identifier( const char *identifier, int array_dim, unsigned array_ident ) 
+void ptx_recognizer::add_identifier( const char *identifier, int array_dim, unsigned array_ident )
 {
    if(array_ident==ARRAY_IDENTIFIER){
        g_size *= array_dim;
@@ -426,7 +434,7 @@ void add_identifier( const char *identifier, int array_dim, unsigned array_ident
    default:
       break;
    }
-   g_last_symbol = g_current_symbol_table->add_variable(identifier,type,num_bits/8,g_filename,ptx_lineno);
+   g_last_symbol = g_current_symbol_table->add_variable(identifier,type,num_bits/8,g_filename,ptx_get_lineno(scanner));
    switch ( ti.get_memory_space().get_type() ) {
    case reg_space: {
       regnum = g_current_symbol_table->next_reg_num();
@@ -569,7 +577,7 @@ void add_identifier( const char *identifier, int array_dim, unsigned array_ident
    }
 }
 
-void add_constptr(const char* identifier1, const char* identifier2, int offset)
+void ptx_recognizer::add_constptr(const char* identifier1, const char* identifier2, int offset)
 {
    symbol *s1 = g_current_symbol_table->lookup(identifier1);
    const symbol *s2 = g_current_symbol_table->lookup(identifier2);
@@ -584,7 +592,7 @@ void add_constptr(const char* identifier1, const char* identifier2, int offset)
    s1->set_address( addr + offset );
 }
 
-void add_function_arg()
+void ptx_recognizer::add_function_arg()
 {
    assert(g_size>0);
    if( g_func_info ) {
@@ -597,20 +605,20 @@ void add_function_arg()
 
 }
 
-void add_extern_spec() 
+void ptx_recognizer::add_extern_spec()
 {
    PTX_PARSE_DPRINTF("add_extern_spec");
    g_extern_spec = 1;
 }
 
-void add_alignment_spec( int spec )
+void ptx_recognizer::add_alignment_spec( int spec )
 {
    PTX_PARSE_DPRINTF("add_alignment_spec");
    parse_assert( g_alignment_spec == -1, "multiple .align specifiers per variable declaration not allowed." );
    g_alignment_spec = spec;
 }
 
-void add_ptr_spec( enum _memory_space_t spec ) 
+void ptx_recognizer::add_ptr_spec( enum _memory_space_t spec )
 {
    PTX_PARSE_DPRINTF("add_ptr_spec \"%s\"", g_ptx_token_decode[spec].c_str() );
    parse_assert( g_ptr_spec == undefined_space, "multiple ptr space specifiers not allowed." );
@@ -618,7 +626,7 @@ void add_ptr_spec( enum _memory_space_t spec )
    g_ptr_spec = spec; 
 }
 
-void add_space_spec( enum _memory_space_t spec, int value ) 
+void ptx_recognizer::add_space_spec( enum _memory_space_t spec, int value )
 {
    PTX_PARSE_DPRINTF("add_space_spec \"%s\"", g_ptx_token_decode[spec].c_str() );
    parse_assert( g_space_spec == undefined_space, "multiple space specifiers not allowed." );
@@ -637,14 +645,14 @@ void add_space_spec( enum _memory_space_t spec, int value )
    }
 }
 
-void add_vector_spec(int spec ) 
+void ptx_recognizer::add_vector_spec(int spec )
 {
    PTX_PARSE_DPRINTF("add_vector_spec");
    parse_assert( g_vector_spec == -1, "multiple vector specifiers not allowed." );
    g_vector_spec = spec;
 }
 
-void add_scalar_type_spec( int type_spec ) 
+void ptx_recognizer::add_scalar_type_spec( int type_spec )
 {
    //save size of parameter
    switch ( type_spec ) {
@@ -682,23 +690,23 @@ void add_scalar_type_spec( int type_spec )
    g_scalar_type_spec = type_spec;
 }
 
-void add_label( const char *identifier ) 
+void ptx_recognizer::add_label( const char *identifier )
 {
    PTX_PARSE_DPRINTF("add_label");
    symbol *s = g_current_symbol_table->lookup(identifier);
    if ( s != NULL ) {
       g_label = s;
    } else {
-      g_label = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_lineno);
+      g_label = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_get_lineno(scanner));
    }
 }
 
-void add_opcode( int opcode ) 
+void ptx_recognizer::add_opcode( int opcode )
 {
    g_opcode = opcode;
 }
 
-void add_pred( const char *identifier, int neg, int predModifier ) 
+void ptx_recognizer::add_pred( const char *identifier, int neg, int predModifier )
 {
    PTX_PARSE_DPRINTF("add_pred");
    const symbol *s = g_current_symbol_table->lookup(identifier);
@@ -711,17 +719,17 @@ void add_pred( const char *identifier, int neg, int predModifier )
    g_pred_mod = predModifier;
 }
 
-void add_option( int option ) 
+void ptx_recognizer::add_option( int option )
 {
    PTX_PARSE_DPRINTF("add_option");
    g_options.push_back( option );
 }
-void add_wmma_option( int option ) 
+void ptx_recognizer::add_wmma_option( int option )
 {
    PTX_PARSE_DPRINTF("add_option");
    g_wmma_options.push_back( option );
 }
-void add_double_operand( const char *d1, const char *d2 )
+void ptx_recognizer::add_double_operand( const char *d1, const char *d2 )
 {
    //operands that access two variables.
    //eg. s[$ofs1+$r0], g[$ofs1+=$r0]
@@ -734,7 +742,7 @@ void add_double_operand( const char *d1, const char *d2 )
    g_operands.push_back( operand_info(s1,s2) );
 }
 
-void add_1vector_operand( const char *d1 ) 
+void ptx_recognizer::add_1vector_operand( const char *d1 )
 {
    // handles the single element vector operand ({%v1}) found in tex.1d instructions
    PTX_PARSE_DPRINTF("add_1vector_operand");
@@ -743,7 +751,7 @@ void add_1vector_operand( const char *d1 )
    g_operands.push_back( operand_info(s1,NULL,NULL,NULL) );
 }
 
-void add_2vector_operand( const char *d1, const char *d2 ) 
+void ptx_recognizer::add_2vector_operand( const char *d1, const char *d2 )
 {
    PTX_PARSE_DPRINTF("add_2vector_operand");
    const symbol *s1 = g_current_symbol_table->lookup(d1);
@@ -752,7 +760,7 @@ void add_2vector_operand( const char *d1, const char *d2 )
    g_operands.push_back( operand_info(s1,s2,NULL,NULL) );
 }
 
-void add_3vector_operand( const char *d1, const char *d2, const char *d3 ) 
+void ptx_recognizer::add_3vector_operand( const char *d1, const char *d2, const char *d3 )
 {
    PTX_PARSE_DPRINTF("add_3vector_operand");
    const symbol *s1 = g_current_symbol_table->lookup(d1);
@@ -762,7 +770,7 @@ void add_3vector_operand( const char *d1, const char *d2, const char *d3 )
    g_operands.push_back( operand_info(s1,s2,s3,NULL) );
 }
 
-void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ) 
+void ptx_recognizer::add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 )
 {
    PTX_PARSE_DPRINTF("add_4vector_operand");
    const symbol *s1 = g_current_symbol_table->lookup(d1);
@@ -776,7 +784,7 @@ void add_4vector_operand( const char *d1, const char *d2, const char *d3, const
    if ( s4 == null_op ) s4 = NULL;
    g_operands.push_back( operand_info(s1,s2,s3,s4) );
 }
-void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4,const char *d5,const char *d6,const char *d7,const char *d8 ) 
+void ptx_recognizer::add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4,const char *d5,const char *d6,const char *d7,const char *d8 )
 {
    PTX_PARSE_DPRINTF("add_8vector_operand");
    const symbol *s1 = g_current_symbol_table->lookup(d1);
@@ -799,13 +807,13 @@ void add_8vector_operand( const char *d1, const char *d2, const char *d3, const
    g_operands.push_back( operand_info(s1,s2,s3,s4,s5,s6,s7,s8) );
 }
 
-void add_builtin_operand( int builtin, int dim_modifier ) 
+void ptx_recognizer::add_builtin_operand( int builtin, int dim_modifier )
 {
    PTX_PARSE_DPRINTF("add_builtin_operand");
    g_operands.push_back( operand_info(builtin,dim_modifier) );
 }
 
-void add_memory_operand() 
+void ptx_recognizer::add_memory_operand()
 {
    PTX_PARSE_DPRINTF("add_memory_operand");
    assert( !g_operands.empty() );
@@ -813,7 +821,7 @@ void add_memory_operand()
 }
 
 /*TODO: add other memory locations*/
-void change_memory_addr_space(const char *identifier) 
+void ptx_recognizer::change_memory_addr_space(const char *identifier)
 {
    /*0 = N/A, not reading from memory
     *1 = global memory
@@ -860,7 +868,7 @@ void change_memory_addr_space(const char *identifier)
    parse_assert(recognizedType, "Error: unrecognized memory type.");
 }
 
-void change_operand_lohi( int lohi )
+void ptx_recognizer::change_operand_lohi( int lohi )
 {
    /*0 = N/A, read entire operand
     *1 = lo, reading from lowest bits
@@ -874,14 +882,14 @@ void change_operand_lohi( int lohi )
 
 }
 
-void set_immediate_operand_type ()
+void ptx_recognizer::set_immediate_operand_type ()
 {
      PTX_PARSE_DPRINTF("set_immediate_operand_type");
      assert( !g_operands.empty() );
      g_operands.back().set_immediate_addr();
 }
 
-void change_double_operand_type( int operand_type )
+void ptx_recognizer::change_double_operand_type( int operand_type )
 {
    /*
     *-3 = reg / reg (set instruction, but both get same value)
@@ -913,7 +921,7 @@ void change_double_operand_type( int operand_type )
 
 }
 
-void change_operand_neg( )
+void ptx_recognizer::change_operand_neg( )
 {
    PTX_PARSE_DPRINTF("change_operand_neg");
    assert( !g_operands.empty() );
@@ -922,32 +930,32 @@ void change_operand_neg( )
 
 }
 
-void add_literal_int( int value ) 
+void ptx_recognizer::add_literal_int( int value )
 {
    PTX_PARSE_DPRINTF("add_literal_int");
    g_operands.push_back( operand_info(value) );
 }
 
-void add_literal_float( float value ) 
+void ptx_recognizer::add_literal_float( float value )
 {
    PTX_PARSE_DPRINTF("add_literal_float");
    g_operands.push_back( operand_info(value) );
 }
 
-void add_literal_double( double value ) 
+void ptx_recognizer::add_literal_double( double value )
 {
    PTX_PARSE_DPRINTF("add_literal_double");
    g_operands.push_back( operand_info(value) );
 }
 
-void add_scalar_operand( const char *identifier ) 
+void ptx_recognizer::add_scalar_operand( const char *identifier )
 {
    PTX_PARSE_DPRINTF("add_scalar_operand");
    const symbol *s = g_current_symbol_table->lookup(identifier);
    if ( s == NULL ) {
       if ( g_opcode == BRA_OP || g_opcode == CALLP_OP) {
          // forward branch target...
-         s = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_lineno);
+         s = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_get_lineno(scanner));
       } else {
          std::string msg = std::string("operand \"") + identifier + "\" has no declaration.";
          parse_error( msg.c_str() );
@@ -956,19 +964,19 @@ void add_scalar_operand( const char *identifier )
    g_operands.push_back( operand_info(s) );
 }
 
-void add_neg_pred_operand( const char *identifier ) 
+void ptx_recognizer::add_neg_pred_operand( const char *identifier )
 {
    PTX_PARSE_DPRINTF("add_neg_pred_operand");
    const symbol *s = g_current_symbol_table->lookup(identifier);
    if ( s == NULL ) {
-       s = g_current_symbol_table->add_variable(identifier,NULL,1,g_filename,ptx_lineno);
+       s = g_current_symbol_table->add_variable(identifier,NULL,1,g_filename,ptx_get_lineno(scanner));
    }
    operand_info op(s);
    op.set_neg_pred();
    g_operands.push_back( op );
 }
 
-void add_address_operand( const char *identifier, int offset ) 
+void ptx_recognizer::add_address_operand( const char *identifier, int offset )
 {
    PTX_PARSE_DPRINTF("add_address_operand");
    const symbol *s = g_current_symbol_table->lookup(identifier);
@@ -979,23 +987,23 @@ void add_address_operand( const char *identifier, int offset )
    g_operands.push_back( operand_info(s,offset) );
 }
 
-void add_address_operand2( int offset )
+void ptx_recognizer::add_address_operand2( int offset )
 {
    PTX_PARSE_DPRINTF("add_address_operand");
    g_operands.push_back( operand_info((unsigned)offset) );
 }
 
-void add_array_initializer()
+void ptx_recognizer::add_array_initializer()
 {
    g_last_symbol->add_initializer(g_operands);
 }
 
-void add_version_info( float ver, unsigned ext )
+void ptx_recognizer::add_version_info( float ver, unsigned ext )
 {
    g_global_symbol_table->set_ptx_version(ver,ext);
 }
 
-void add_file( unsigned num, const char *filename )
+void ptx_recognizer::add_file( unsigned num, const char *filename )
 {
    if( g_filename == NULL ) {
       char *b = strdup(filename);
@@ -1022,44 +1030,44 @@ void add_file( unsigned num, const char *filename )
    g_current_symbol_table = g_global_symbol_table;
 }
 
-void *reset_symtab()
+void * ptx_recognizer::reset_symtab()
 {
    void *result = g_current_symbol_table;
    g_current_symbol_table = g_global_symbol_table;
    return result;
 }
 
-void set_symtab(void*symtab)
+void ptx_recognizer::set_symtab(void*symtab)
 {
    g_current_symbol_table = (symbol_table*)symtab;
 }
 
-void add_pragma( const char *str )
+void ptx_recognizer::add_pragma( const char *str )
 {
    printf("GPGPU-Sim PTX: Warning -- ignoring pragma '%s'\n", str );
 }
 
-void version_header(double a) {}  //intentional dummy function
+void ptx_recognizer::version_header(double a) {}  //intentional dummy function
 
-void target_header(char* a) 
+void ptx_recognizer::target_header(char* a)
 {
    g_global_symbol_table->set_sm_target(a,NULL,NULL);
 }
 
-void target_header2(char* a, char* b) 
+void ptx_recognizer::target_header2(char* a, char* b)
 {
    g_global_symbol_table->set_sm_target(a,b,NULL);
 }
 
-void target_header3(char* a, char* b, char* c) 
+void ptx_recognizer::target_header3(char* a, char* b, char* c)
 {
    g_global_symbol_table->set_sm_target(a,b,c);
 }
 
-void maxnt_id(int x, int y, int z) {
+void ptx_recognizer::maxnt_id(int x, int y, int z) {
   g_func_info->set_maxnt_id(x * y * z);
 }
 
-void func_header(const char* a) {} //intentional dummy function
-void func_header_info(const char* a) {} //intentional dummy function
-void func_header_info_int(const char* a, int b) {} //intentional dummy function
+void ptx_recognizer::func_header(const char* a) {} //intentional dummy function
+void ptx_recognizer::func_header_info(const char* a) {} //intentional dummy function
+void ptx_recognizer::func_header_info_int(const char* a, int b) {} //intentional dummy function
diff --git a/src/cuda-sim/ptx_parser.h b/src/cuda-sim/ptx_parser.h
index 7b6e3a2..70c4dfb 100644
--- a/src/cuda-sim/ptx_parser.h
+++ b/src/cuda-sim/ptx_parser.h
@@ -37,69 +37,81 @@ class symbol_table* init_parser(const char*);
 const class ptx_instruction *ptx_instruction_lookup( const char *filename, unsigned linenumber );
 #endif
 
+typedef void * yyscan_t;
+class ptx_recognizer {
+    public:
+	ptx_recognizer() {
+	    scanner = NULL;
+	}
+	yyscan_t scanner;
+	void init_directive_state();
+	void init_instruction_state();
+	void start_function( int entry_point );
+	void add_function_name( const char *fname );
+	void add_directive();
+	void end_function();
+	void add_identifier( const char *s, int array_dim, unsigned array_ident );
+	void add_function_arg();
+	void add_scalar_type_spec( int type_spec );
+	void add_scalar_operand( const char *identifier );
+	void add_neg_pred_operand( const char *identifier );
+	void add_variables();
+	void set_variable_type();
+	void add_opcode( int opcode );
+	void add_pred( const char *identifier, int negate, int predModifier );
+	void add_1vector_operand( const char *d1 );
+	void add_2vector_operand( const char *d1, const char *d2 );
+	void add_3vector_operand( const char *d1, const char *d2, const char *d3 );
+	void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 );
+	void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ,const char *d5,const char *d6,const char *d7,const char *d8);
+	void add_option(int option );
+	void add_wmma_option(int option );
+	void add_builtin_operand( int builtin, int dim_modifier );
+	void add_memory_operand( );
+	void add_literal_int( int value );
+	void add_literal_float( float value );
+	void add_literal_double( double value );
+	void add_address_operand( const char *identifier, int offset );
+	void add_address_operand2( int offset );
+	void add_label( const char *idenfiier );
+	void add_vector_spec(int spec );
+	void add_space_spec( enum _memory_space_t spec, int value );
+	void add_ptr_spec( enum _memory_space_t spec );
+	void add_extern_spec();
+	void add_instruction();
+	void set_return();
+	void add_alignment_spec( int spec );
+	void add_array_initializer();
+	void add_file( unsigned num, const char *filename );
+	void add_version_info( float ver, unsigned ext);
+	void *reset_symtab();
+	void set_symtab(void*);
+	void add_pragma( const char *str );
+	void func_header(const char* a);
+	void func_header_info(const char* a);
+	void func_header_info_int(const char* a, int b);
+	void add_constptr(const char* identifier1, const char* identifier2, int offset);
+	void target_header(char* a);
+	void target_header2(char* a, char* b);
+	void target_header3(char* a, char* b, char* c);
+	void add_double_operand( const char *d1, const char *d2 );
+	void change_memory_addr_space( const char *identifier );
+	void change_operand_lohi( int lohi );
+	void change_double_operand_type( int addr_type );
+	void change_operand_neg( );
+	void set_immediate_operand_type( );
+	void version_header(double a);
+	void maxnt_id(int x, int y, int z);
+	void parse_error_impl( const char *file, unsigned line, const char *msg, ... );
+	void parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... );
+	//Jin: handle instructino group for cdp
+	void start_inst_group();
+	void end_inst_group();
+
+};
+
 const char *decode_token( int type );
 void read_parser_environment_variables();
-void start_function( int entry_point );
-void add_function_name( const char *fname );
-void init_directive_state();
-void add_directive(); 
-void end_function();
-void add_identifier( const char *s, int array_dim, unsigned array_ident );
-void add_function_arg();
-void add_scalar_type_spec( int type_spec );
-void add_scalar_operand( const char *identifier );
-void add_neg_pred_operand( const char *identifier );
-void add_variables();
-void set_variable_type();
-void add_opcode( int opcode );
-void add_pred( const char *identifier, int negate, int predModifier );
-void add_1vector_operand( const char *d1 );
-void add_2vector_operand( const char *d1, const char *d2 );
-void add_3vector_operand( const char *d1, const char *d2, const char *d3 );
-void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 );
-void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ,const char *d5,const char *d6,const char *d7,const char *d8);
-void add_option(int option );
-void add_wmma_option(int option );
-void add_builtin_operand( int builtin, int dim_modifier );
-void add_memory_operand( );
-void add_literal_int( int value );
-void add_literal_float( float value );
-void add_literal_double( double value );
-void add_address_operand( const char *identifier, int offset );
-void add_address_operand2( int offset );
-void add_label( const char *idenfiier );
-void add_vector_spec(int spec );
-void add_space_spec( enum _memory_space_t spec, int value );
-void add_ptr_spec( enum _memory_space_t spec ); 
-void add_extern_spec();
-void add_instruction();
-void set_return();
-void add_alignment_spec( int spec );
-void add_array_initializer();
-void add_file( unsigned num, const char *filename );
-void add_version_info( float ver, unsigned ext);
-void *reset_symtab();
-void set_symtab(void*);
-void add_pragma( const char *str );
-void func_header(const char* a);
-void func_header_info(const char* a);
-void func_header_info_int(const char* a, int b);
-void add_constptr(const char* identifier1, const char* identifier2, int offset);
-void target_header(char* a);
-void target_header2(char* a, char* b);
-void target_header3(char* a, char* b, char* c);
-void add_double_operand( const char *d1, const char *d2 );
-void change_memory_addr_space( const char *identifier );
-void change_operand_lohi( int lohi );
-void change_double_operand_type( int addr_type );
-void change_operand_neg( );
-void set_immediate_operand_type( );
-void version_header(double a);
-void maxnt_id(int x, int y, int z);
-
-//Jin: handle instructino group for cdp
-void start_inst_group();
-void end_inst_group();
 
 #define NON_ARRAY_IDENTIFIER 1
 #define ARRAY_IDENTIFIER_NO_DIM 2
diff --git a/src/cuda-sim/ptx_sim.cc b/src/cuda-sim/ptx_sim.cc
index 8ad651e..1b8831a 100644
--- a/src/cuda-sim/ptx_sim.cc
+++ b/src/cuda-sim/ptx_sim.cc
@@ -28,6 +28,8 @@
 #include "ptx_sim.h"
 #include <string>
 #include "ptx_ir.h"
+class ptx_recognizer;
+typedef void * yyscan_t;
 #include "ptx.tab.h"
 #include "../gpgpu-sim/gpu-sim.h"
 #include "../gpgpu-sim/shader.h"