aboutsummaryrefslogtreecommitdiff
path: root/src/cuda-sim
diff options
context:
space:
mode:
Diffstat (limited to 'src/cuda-sim')
-rw-r--r--src/cuda-sim/Makefile8
-rw-r--r--src/cuda-sim/cuda-math.h16
-rw-r--r--src/cuda-sim/cuda-sim.cc40
-rw-r--r--src/cuda-sim/cuda_device_runtime.cc7
-rw-r--r--src/cuda-sim/instructions.cc12
-rw-r--r--src/cuda-sim/ptx.l323
-rw-r--r--src/cuda-sim/ptx.y495
-rw-r--r--src/cuda-sim/ptx_ir.cc1
-rw-r--r--src/cuda-sim/ptx_loader.cc72
-rw-r--r--src/cuda-sim/ptx_loader.h16
-rw-r--r--src/cuda-sim/ptx_parser.cc222
-rw-r--r--src/cuda-sim/ptx_parser.h198
-rw-r--r--src/cuda-sim/ptx_sim.cc10
-rw-r--r--src/cuda-sim/ptxinfo.l39
-rw-r--r--src/cuda-sim/ptxinfo.y15
15 files changed, 790 insertions, 684 deletions
diff --git a/src/cuda-sim/Makefile b/src/cuda-sim/Makefile
index 999dad7..85d1c8c 100644
--- a/src/cuda-sim/Makefile
+++ b/src/cuda-sim/Makefile
@@ -79,16 +79,16 @@ libgpgpu_ptx_sim.a: $(OBJS)
ar rcs $(OUTPUT_DIR)/libgpgpu_ptx_sim.a $(OUTPUT_DIR)/ptx.tab.o $(OUTPUT_DIR)/lex.ptx_.o $(OUTPUT_DIR)/ptxinfo.tab.o $(OUTPUT_DIR)/lex.ptxinfo_.o $(OBJS)
$(OUTPUT_DIR)/ptx.tab.o: $(OUTPUT_DIR)/ptx.tab.c
- $(CPP) -c $(OPT) -DYYDEBUG $(OUTPUT_DIR)/ptx.tab.c -o $(OUTPUT_DIR)/ptx.tab.o
+ $(CPP) -c $(CXX_OPT) -DYYDEBUG $(OUTPUT_DIR)/ptx.tab.c -o $(OUTPUT_DIR)/ptx.tab.o
$(OUTPUT_DIR)/lex.ptx_.o: $(OUTPUT_DIR)/lex.ptx_.c
- $(CPP) -c $(OPT) $(OUTPUT_DIR)/lex.ptx_.c -o $(OUTPUT_DIR)/lex.ptx_.o
+ $(CPP) -c $(CXX_OPT) $(OUTPUT_DIR)/lex.ptx_.c -o $(OUTPUT_DIR)/lex.ptx_.o
$(OUTPUT_DIR)/ptxinfo.tab.o: $(OUTPUT_DIR)/ptxinfo.tab.c
- $(CPP) -c $(OPT) -DYYDEBUG $(OUTPUT_DIR)/ptxinfo.tab.c -o $(OUTPUT_DIR)/ptxinfo.tab.o
+ $(CPP) -c $(CXX_OPT) -DYYDEBUG $(OUTPUT_DIR)/ptxinfo.tab.c -o $(OUTPUT_DIR)/ptxinfo.tab.o
$(OUTPUT_DIR)/lex.ptxinfo_.o: $(OUTPUT_DIR)/lex.ptxinfo_.c $(OUTPUT_DIR)/ptxinfo.tab.c
- $(CPP) -c $(OPT) $(OUTPUT_DIR)/lex.ptxinfo_.c -o $(OUTPUT_DIR)/lex.ptxinfo_.o
+ $(CPP) -c $(CXX_OPT) $(OUTPUT_DIR)/lex.ptxinfo_.c -o $(OUTPUT_DIR)/lex.ptxinfo_.o
$(OUTPUT_DIR)/ptx.tab.c: ptx.y
bison --name-prefix=ptx_ -v -d ptx.y --file-prefix=$(OUTPUT_DIR)/ptx
diff --git a/src/cuda-sim/cuda-math.h b/src/cuda-sim/cuda-math.h
index a5db337..9a5468c 100644
--- a/src/cuda-sim/cuda-math.h
+++ b/src/cuda-sim/cuda-math.h
@@ -277,10 +277,10 @@ int float2int(float a, enum cudaRoundMode mode)
{
int tmp;
switch (mode) {
- case cuda_math::cudaRoundZero: tmp = truncf(a); break;
- case cuda_math::cudaRoundNearest: tmp = nearbyintf(a); break;
- case cuda_math::cudaRoundMinInf: tmp = floorf(a); break;
- case cuda_math::cudaRoundPosInf: tmp = ceilf(a); break;
+ case cudaRoundZero: tmp = truncf(a); break;
+ case cudaRoundNearest: tmp = nearbyintf(a); break;
+ case cudaRoundMinInf: tmp = floorf(a); break;
+ case cudaRoundPosInf: tmp = ceilf(a); break;
default: abort();
}
return tmp;
@@ -296,10 +296,10 @@ unsigned int float2uint(float a, enum cudaRoundMode mode)
{
unsigned int tmp;
switch (mode) {
- case cuda_math::cudaRoundZero: tmp = truncf(a); break;
- case cuda_math::cudaRoundNearest: tmp = nearbyintf(a); break;
- case cuda_math::cudaRoundMinInf: tmp = floorf(a); break;
- case cuda_math::cudaRoundPosInf: tmp = ceilf(a); break;
+ case cudaRoundZero: tmp = truncf(a); break;
+ case cudaRoundNearest: tmp = nearbyintf(a); break;
+ case cudaRoundMinInf: tmp = floorf(a); break;
+ case cudaRoundPosInf: tmp = ceilf(a); break;
default: abort();
}
return tmp;
diff --git a/src/cuda-sim/cuda-sim.cc b/src/cuda-sim/cuda-sim.cc
index f7bb9cc..261d605 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>
@@ -446,8 +448,8 @@ void gpgpu_t::memcpy_to_gpu( size_t dst_start_addr, const void *src, size_t coun
m_global_mem->write(dst_start_addr+n,1, src_data+n,NULL,NULL);
// Copy into the performance model.
- extern gpgpu_sim* g_the_gpu;
- g_the_gpu->perf_memcpy_to_gpu(dst_start_addr, count);
+ //extern gpgpu_sim* g_the_gpu;
+ g_the_gpu()->perf_memcpy_to_gpu(dst_start_addr, count);
if(g_debug_execution >= 3) {
printf( " done.\n");
fflush(stdout);
@@ -465,8 +467,8 @@ void gpgpu_t::memcpy_from_gpu( void *dst, size_t src_start_addr, size_t count )
m_global_mem->read(src_start_addr+n,1,dst_data+n);
// Copy into the performance model.
- extern gpgpu_sim* g_the_gpu;
- g_the_gpu->perf_memcpy_to_gpu(src_start_addr, count);
+ //extern gpgpu_sim* g_the_gpu;
+ g_the_gpu()->perf_memcpy_to_gpu(src_start_addr, count);
if(g_debug_execution >= 3) {
printf( " done.\n");
fflush(stdout);
@@ -1268,8 +1270,8 @@ void function_info::finalize( memory_space *param_mem )
void function_info::param_to_shared( memory_space *shared_mem, symbol_table *symtab )
{
// TODO: call this only for PTXPlus with GT200 models
- extern gpgpu_sim* g_the_gpu;
- if (not g_the_gpu->get_config().convert_to_ptxplus()) return;
+ //extern gpgpu_sim* g_the_gpu;
+ if (not g_the_gpu()->get_config().convert_to_ptxplus()) return;
// copies parameters into simulated shared memory
for( std::map<unsigned,param_info>::iterator i=m_ptx_kernel_param_info.begin(); i!=m_ptx_kernel_param_info.end(); i++ ) {
@@ -2148,7 +2150,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
printf("GPGPU-Sim: Performing Functional Simulation, executing kernel %s...\n",kernel.name().c_str());
//using a shader core object for book keeping, it is not needed but as most function built for performance simulation need it we use it here
- extern gpgpu_sim *g_the_gpu;
+ //extern gpgpu_sim *g_the_gpu;
//before we execute, we should do PDOM analysis for functional simulation scenario.
function_info *kernel_func_info = kernel.entry();
const struct gpgpu_ptx_sim_info *kernel_info = ptx_sim_kernel_info(kernel_func_info);
@@ -2163,7 +2165,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
kernel_func_info->set_pdom();
}
- unsigned max_cta_tot = max_cta(kernel_info,kernel.threads_per_cta(), g_the_gpu->getShaderCoreConfig()->warp_size, g_the_gpu->getShaderCoreConfig()->n_thread_per_shader, g_the_gpu->getShaderCoreConfig()->gpgpu_shmem_size, g_the_gpu->getShaderCoreConfig()->gpgpu_shader_registers, g_the_gpu->getShaderCoreConfig()->max_cta_per_core);
+ unsigned max_cta_tot = max_cta(kernel_info,kernel.threads_per_cta(), g_the_gpu()->getShaderCoreConfig()->warp_size, g_the_gpu()->getShaderCoreConfig()->n_thread_per_shader, g_the_gpu()->getShaderCoreConfig()->gpgpu_shmem_size, g_the_gpu()->getShaderCoreConfig()->gpgpu_shader_registers, g_the_gpu()->getShaderCoreConfig()->max_cta_per_core);
printf("Max CTA : %d\n",max_cta_tot);
@@ -2171,11 +2173,11 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
int inst_count=50;
- int cp_op= g_the_gpu->checkpoint_option;
- int cp_CTA = g_the_gpu->checkpoint_CTA;
- int cp_kernel= g_the_gpu->checkpoint_kernel;
- cp_count= g_the_gpu->checkpoint_insn_Y;
- cp_cta_resume= g_the_gpu->checkpoint_CTA_t;
+ int cp_op= g_the_gpu()->checkpoint_option;
+ int cp_CTA = g_the_gpu()->checkpoint_CTA;
+ int cp_kernel= g_the_gpu()->checkpoint_kernel;
+ cp_count= g_the_gpu()->checkpoint_insn_Y;
+ cp_cta_resume= g_the_gpu()->checkpoint_CTA_t;
int cta_launched =0;
//we excute the kernel one CTA (Block) at the time, as synchronization functions work block wise
@@ -2187,8 +2189,8 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
{
functionalCoreSim cta(
&kernel,
- g_the_gpu,
- g_the_gpu->getShaderCoreConfig()->warp_size
+ g_the_gpu(),
+ g_the_gpu()->getShaderCoreConfig()->warp_size
);
cta.execute(cp_count,temp);
@@ -2209,7 +2211,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
{
char f1name[2048];
snprintf(f1name,2048,"checkpoint_files/global_mem_%d.txt", kernel.get_uid() );
- g_checkpoint->store_global_mem(g_the_gpu->get_global_memory(), f1name , "%08x");
+ g_checkpoint->store_global_mem(g_the_gpu()->get_global_memory(), f1name , "%08x");
}
@@ -2219,8 +2221,8 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
//openCL kernel simulation calls don't register the kernel so we don't register its exit
if(!openCL) {
- extern stream_manager *g_stream_manager;
- g_stream_manager->register_finished_kernel(kernel.get_uid());
+ //extern stream_manager *g_stream_manager;
+ g_stream_manager()->register_finished_kernel(kernel.get_uid());
}
//******PRINTING*******
@@ -2235,7 +2237,7 @@ void gpgpu_cuda_ptx_sim_main_func( kernel_info_t &kernel, bool openCL )
//g_simulation_starttime is initilized by gpgpu_ptx_sim_init_perf() in gpgpusim_entrypoint.cc upon starting gpgpu-sim
time_t end_time, elapsed_time, days, hrs, minutes, sec;
end_time = time((time_t *)NULL);
- elapsed_time = MAX(end_time - g_simulation_starttime, 1);
+ elapsed_time = MAX(end_time - GPGPUsim_ctx_ptr()->g_simulation_starttime, 1);
//calculating and printing simulation time in terms of days, hours, minutes and seconds
diff --git a/src/cuda-sim/cuda_device_runtime.cc b/src/cuda-sim/cuda_device_runtime.cc
index 917e7a8..be8369f 100644
--- a/src/cuda-sim/cuda_device_runtime.cc
+++ b/src/cuda-sim/cuda_device_runtime.cc
@@ -18,6 +18,7 @@ unsigned long long g_max_total_param_size = 0;
#include "cuda-sim.h"
#include "ptx_ir.h"
#include "../stream_manager.h"
+#include "../gpgpusim_entrypoint.h"
#include "cuda_device_runtime.h"
#define DEV_RUNTIME_REPORT(a) \
@@ -64,7 +65,7 @@ public:
std::map<void *, device_launch_config_t> g_cuda_device_launch_param_map;
std::list<device_launch_operation_t> g_cuda_device_launch_op;
-extern stream_manager *g_stream_manager;
+//extern stream_manager *g_stream_manager();
//Handling device runtime api:
//void * cudaGetParameterBufferV2(void *func, dim3 gridDimension, dim3 blockDimension, unsigned int sharedMemSize)
@@ -200,7 +201,7 @@ void gpgpusim_cuda_launchDeviceV2(const ptx_instruction * pI, ptx_thread_info *
//create child kernel_info_t and index it with parameter_buffer address
gpgpu_t* gpu=thread->get_gpu();
device_grid = new kernel_info_t(config.grid_dim, config.block_dim, device_kernel_entry, gpu->getNameArrayMapping(), gpu->getNameInfoMapping());
- device_grid->launch_cycle = gpu_sim_cycle + gpu_tot_sim_cycle;
+ device_grid->launch_cycle = gpu->gpu_sim_cycle + gpu->gpu_tot_sim_cycle;
kernel_info_t & parent_grid = thread->get_kernel();
DEV_RUNTIME_REPORT("child kernel launched by " << parent_grid.name() << ", cta (" <<
thread->get_ctaid().x << ", " << thread->get_ctaid().y << ", " << thread->get_ctaid().z <<
@@ -322,7 +323,7 @@ void launch_one_device_kernel() {
device_launch_operation_t &op = g_cuda_device_launch_op.front();
stream_operation stream_op = stream_operation(op.grid, g_ptx_sim_mode, op.stream);
- g_stream_manager->push(stream_op);
+ g_stream_manager()->push(stream_op);
g_cuda_device_launch_op.pop_front();
}
}
diff --git a/src/cuda-sim/instructions.cc b/src/cuda-sim/instructions.cc
index 11001d7..186bb1e 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>
@@ -2300,12 +2302,12 @@ ptx_reg_t f2x( ptx_reg_t x, unsigned from_width, unsigned to_width, int to_sign,
half_float::half tmp_h;
//assert( from_width == 32);
- enum cuda_math::cudaRoundMode mode = cuda_math::cudaRoundZero;
+ enum cudaRoundMode mode = cudaRoundZero;
switch (rounding_mode) {
- case RZI_OPTION: mode = cuda_math::cudaRoundZero; break;
- case RNI_OPTION: mode = cuda_math::cudaRoundNearest; break;
- case RMI_OPTION: mode = cuda_math::cudaRoundMinInf; break;
- case RPI_OPTION: mode = cuda_math::cudaRoundPosInf; break;
+ case RZI_OPTION: mode = cudaRoundZero; break;
+ case RNI_OPTION: mode = cudaRoundNearest; break;
+ case RMI_OPTION: mode = cudaRoundMinInf; break;
+ case RPI_OPTION: mode = cudaRoundPosInf; break;
default: break;
}
diff --git a/src/cuda-sim/ptx.l b/src/cuda-sim/ptx.l
index 3232361..18952a9 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"
+#include "ptx_parser.h"
#include "ptx.tab.h"
#include <string.h>
-#define LINEBUF_SIZE (64*1024)
-char linebuf[LINEBUF_SIZE];
-unsigned col = 0;
-#define TC col+=strlen(ptx_text);
+#define LINEBUF_SIZE (4*1024)
+#define TC recognizer->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 );
+#define YY_DECL int ptx_lex \
+ (YYSTYPE * yylval_param , yyscan_t yyscanner, ptx_recognizer* recognizer)
+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;
@@ -411,7 +416,7 @@ breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE;
"//"[^\n]* TC; // eat single
-\n.* col=0; strncpy(linebuf, yytext + 1, LINEBUF_SIZE); yyless( 1 );
+\n.* recognizer->col=0; strncpy(recognizer->linebuf, yytext + 1, LINEBUF_SIZE); yyless( 1 );
" " TC;
"\t" TC;
@@ -439,28 +444,28 @@ 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, recognizer, (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;
+ recognizer->g_error_detected = 1;
fflush(stdout);
if( s != NULL )
- printf("%s:%u: Syntax error:\n\n", g_filename, ptx_lineno );
- printf(" %s\n", linebuf );
+ printf("%s:%u Syntax error:\n\n", g_filename, yylineno );
+ printf(" %s\n", recognizer->linebuf );
printf(" ");
- for( i=0; i < col-1; i++ ) {
- if( linebuf[i] == '\t' ) printf("\t");
+ for( i=0; i < recognizer->col-1; i++ ) {
+ if( recognizer->linebuf[i] == '\t' ) printf("\t");
else printf(" ");
}
diff --git a/src/cuda-sim/ptx.y b/src/cuda-sim/ptx.y
index 45392fb..837fbe9 100644
--- a/src/cuda-sim/ptx.y
+++ b/src/cuda-sim/ptx.y
@@ -27,6 +27,17 @@ 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}
+%lex-param {ptx_recognizer* recognizer}
+
%union {
double double_value;
float float_value;
@@ -217,10 +228,9 @@ 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();
- extern int g_func_decl;
- int ptx_lex(void);
- int ptx_error(const char *);
+ void syntax_not_implemented(yyscan_t yyscanner, ptx_recognizer* recognizer);
+ int ptx_lex(YYSTYPE * yylval_param, yyscan_t yyscanner, ptx_recognizer* recognizer);
+ 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(""); recognizer->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 { recognizer->g_func_decl=0; recognizer->func_header_info(")"); }
+ | IDENTIFIER { recognizer->add_function_name($1); recognizer->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; recognizer->g_func_decl=1; recognizer->func_header(".entry"); }
+ | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; recognizer->g_func_decl=1; recognizer->func_header(".entry"); }
+ | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; recognizer->g_func_decl=1; recognizer->func_header(".entry"); }
+ | FUNC_DIRECTIVE { $$ = 0; recognizer->g_func_decl=1; recognizer->func_header(".func"); }
+ | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; recognizer->g_func_decl=1; recognizer->func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; recognizer->g_func_decl=1; recognizer->func_header(".func"); }
+ | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; recognizer->g_func_decl=1; recognizer->func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; recognizer->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_loader.cc b/src/cuda-sim/ptx_loader.cc
index 8c6f361..921d1e6 100644
--- a/src/cuda-sim/ptx_loader.cc
+++ b/src/cuda-sim/ptx_loader.cc
@@ -33,26 +33,28 @@
#include <dirent.h>
#include <fstream>
#include <sstream>
+#include "../../libcuda/gpgpu_context.h"
/// globals
-memory_space *g_global_mem;
-memory_space *g_tex_mem;
-memory_space *g_surf_mem;
-memory_space *g_param_mem;
bool g_override_embedded_ptx = false;
/// extern prototypes
-extern int ptx_parse();
-extern int ptx__scan_string(const char*);
+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);
+extern int ptx__scan_string(const char*, yyscan_t scanner);
extern std::map<unsigned,const char*> get_duplicate();
-const char *g_ptxinfo_filename;
-extern int ptxinfo_parse();
-extern int ptxinfo_debug;
-extern FILE *ptxinfo_in;
+typedef void * yyscan_t;
+extern int ptxinfo_lex_init(yyscan_t* scanner);
+extern void ptxinfo_set_in (FILE * _in_str ,yyscan_t yyscanner );
+extern int ptxinfo_parse(yyscan_t scanner, ptxinfo_data* ptxinfo);
+extern int ptxinfo_lex_destroy(yyscan_t scanner);
static bool g_save_embedded_ptx;
static int g_occupancy_sm_number;
@@ -79,7 +81,7 @@ void ptx_reg_options(option_parser_t opp)
"0");
}
-void print_ptx_file( const char *p, unsigned source_num, const char *filename )
+void gpgpu_context::print_ptx_file( const char *p, unsigned source_num, const char *filename )
{
printf("\nGPGPU-Sim PTX: file _%u.ptx contents:\n\n", source_num );
char *s = strdup(p);
@@ -158,7 +160,7 @@ char* gpgpu_ptx_sim_convert_ptx_and_sass_to_ptxplus(const std::string ptxfilenam
}
-symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num )
+symbol_table *gpgpu_context::gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num )
{
char buf[1024];
snprintf(buf,1024,"_%u.ptx", source_num );
@@ -168,8 +170,9 @@ symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source
fclose(fp);
}
symbol_table *symtab=init_parser(buf);
- ptx__scan_string(p);
- int errors = ptx_parse ();
+ ptx_lex_init(&(ptx_parser->scanner));
+ ptx__scan_string(p, ptx_parser->scanner);
+ int errors = ptx_parse (ptx_parser->scanner, ptx_parser);
if ( errors ) {
char fname[1024];
snprintf(fname,1024,"_ptx_errors_XXXXXX");
@@ -182,6 +185,7 @@ symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source
abort();
exit(40);
}
+ ptx_lex_destroy(ptx_parser->scanner);
if ( g_debug_execution >= 100 )
print_ptx_file(p,source_num,buf);
@@ -190,7 +194,7 @@ symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source
return symtab;
}
-symbol_table *gpgpu_ptx_sim_load_ptx_from_filename( const char *filename )
+symbol_table *gpgpu_context::gpgpu_ptx_sim_load_ptx_from_filename( const char *filename )
{
symbol_table *symtab=init_parser(filename);
printf("GPGPU-Sim PTX: finished parsing EMBEDDED .ptx file %s\n",filename);
@@ -327,7 +331,7 @@ char* get_app_binary_name(){
return self_exe_path;
}
-void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_version)
+void gpgpu_context::gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_version)
{
std::string ptxas_filename(std::string(filename) + "as");
char buff[1024], extra_flags[1024];
@@ -346,13 +350,17 @@ void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_versio
exit(1);
}
- g_ptxinfo_filename = strdup(ptxas_filename.c_str());
- ptxinfo_in = fopen(g_ptxinfo_filename,"r");
- ptxinfo_parse();
+ FILE *ptxinfo_in;
+ ptxinfo->g_ptxinfo_filename = strdup(ptxas_filename.c_str());
+ ptxinfo_in = fopen(ptxinfo->g_ptxinfo_filename,"r");
+ ptxinfo_lex_init(&(ptxinfo->scanner));
+ ptxinfo_set_in(ptxinfo_in, ptxinfo->scanner);
+ ptxinfo_parse(ptxinfo->scanner, ptxinfo);
+ ptxinfo_lex_destroy(ptxinfo->scanner);
fclose(ptxinfo_in);
}
-void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version )
+void gpgpu_context::gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version, int no_of_ptx )
{
//do ptxas for individual files instead of one big embedded ptx. This prevents the duplicate defs and declarations.
char ptx_file[1000];
@@ -410,9 +418,14 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num
if( result != 0 ) {
// 65280 = duplicate errors
if (result == 65280) {
+ FILE *ptxinfo_in;
ptxinfo_in = fopen(tempfile_ptxinfo,"r");
- g_ptxinfo_filename = tempfile_ptxinfo;
- ptxinfo_parse();
+ ptxinfo->g_ptxinfo_filename = tempfile_ptxinfo;
+ ptxinfo_lex_init(&(ptxinfo->scanner));
+ ptxinfo_set_in(ptxinfo_in, ptxinfo->scanner);
+ ptxinfo_parse(ptxinfo->scanner, ptxinfo);
+ ptxinfo_lex_destroy(ptxinfo->scanner);
+ fclose(ptxinfo_in);
fix_duplicate_errors(fname2);
snprintf(commandline,1024,"$CUDA_INSTALL_PATH/bin/ptxas %s -v %s --output-file /dev/null 2> %s",
@@ -492,12 +505,17 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num
}
if(no_of_ptx>0)
- g_ptxinfo_filename = final_tempfile_ptxinfo;
+ ptxinfo->g_ptxinfo_filename = final_tempfile_ptxinfo;
else
- g_ptxinfo_filename = tempfile_ptxinfo;
- ptxinfo_in = fopen(g_ptxinfo_filename,"r");
+ ptxinfo->g_ptxinfo_filename = tempfile_ptxinfo;
+ FILE *ptxinfo_in;
+ ptxinfo_in = fopen(ptxinfo->g_ptxinfo_filename,"r");
- ptxinfo_parse();
+ ptxinfo_lex_init(&(ptxinfo->scanner));
+ ptxinfo_set_in(ptxinfo_in, ptxinfo->scanner);
+ ptxinfo_parse(ptxinfo->scanner, ptxinfo);
+ ptxinfo_lex_destroy(ptxinfo->scanner);
+ fclose(ptxinfo_in);
snprintf(commandline,1024,"rm -f *info");
if( system(commandline) != 0 ) {
@@ -515,4 +533,4 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num
exit(1);
}
}
-} \ No newline at end of file
+}
diff --git a/src/cuda-sim/ptx_loader.h b/src/cuda-sim/ptx_loader.h
index e5df6a9..ee09e16 100644
--- a/src/cuda-sim/ptx_loader.h
+++ b/src/cuda-sim/ptx_loader.h
@@ -29,13 +29,21 @@
#define PTX_LOADER_H_INCLUDED
#include <string>
+#define PTXINFO_LINEBUF_SIZE 1024
+typedef void * yyscan_t;
+class ptxinfo_data{
+ public:
+ yyscan_t scanner;
+ char linebuf[PTXINFO_LINEBUF_SIZE];
+ unsigned col;
+ const char *g_ptxinfo_filename;
+
+};
+
+
extern bool g_override_embedded_ptx;
extern int no_of_ptx; //counter to track number of ptx files to be extracted in an application.
-class symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num );
-class symbol_table *gpgpu_ptx_sim_load_ptx_from_filename( const char *filename );
-void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version=20 );
-void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_version );
char* gpgpu_ptx_sim_convert_ptx_and_sass_to_ptxplus(const std::string ptx_str, const std::string sass_str, const std::string elf_str);
bool keep_intermediate_files();
diff --git a/src/cuda-sim/ptx_parser.cc b/src/cuda-sim/ptx_parser.cc
index 25758dd..2872b84 100644
--- a/src/cuda-sim/ptx_parser.cc
+++ b/src/cuda-sim/ptx_parser.cc
@@ -27,13 +27,20 @@
#include "ptx_parser.h"
#include "ptx_ir.h"
+#include "../../libcuda/gpgpu_context.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 YYSTYPE* ptx_get_lval (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 FILE *ptx_get_in (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)
@@ -43,54 +50,20 @@ void set_ptx_warp_size(const struct core_config * warp_size)
static bool g_debug_ir_generation=false;
const char *g_filename;
-unsigned g_max_regs_per_thread = 0;
// the program intermediate representation...
-static symbol_table *g_global_allfiles_symbol_table = NULL;
-static symbol_table *g_global_symbol_table = NULL;
std::map<std::string,symbol_table*> g_sym_name_to_symbol_table;
-static symbol_table *g_current_symbol_table = NULL;
-static std::list<ptx_instruction*> g_instructions;
-static symbol *g_last_symbol = NULL;
-
-int g_error_detected = 0;
-
-// type specifier stuff:
-memory_space_t g_space_spec = undefined_space;
-memory_space_t g_ptr_spec = undefined_space;
-int g_scalar_type_spec = -1;
-int g_vector_spec = -1;
-int g_alignment_spec = -1;
-int g_size = -1;
-int g_extern_spec = 0;
-
-// variable declaration stuff:
-type_info *g_var_type = NULL;
-
-// instruction definition stuff:
-const symbol *g_pred;
-int g_neg_pred;
-int g_pred_mod;
-symbol *g_label;
-int g_opcode = -1;
-std::list<operand_info> g_operands;
-std::list<int> g_options;
-std::list<int> g_wmma_options;
-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"); \
fflush(stdout); \
}
-static unsigned g_entry_func_param_index=0;
-static function_info *g_func_info = NULL;
static std::map<unsigned,std::string> g_ptx_token_decode;
-static operand_info g_return_var;
const char *decode_token( int type )
{
@@ -109,7 +82,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 +98,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;
@@ -139,17 +112,16 @@ void init_instruction_state()
init_directive_state();
}
-symbol_table *init_parser( const char *ptx_filename )
+symbol_table * gpgpu_context::init_parser( const char *ptx_filename )
{
g_filename = strdup(ptx_filename);
if (g_global_allfiles_symbol_table == NULL) {
g_global_allfiles_symbol_table = new symbol_table("global_allfiles", 0, NULL);
- g_global_symbol_table = g_current_symbol_table = g_global_allfiles_symbol_table;
+ ptx_parser->g_global_symbol_table = ptx_parser->g_current_symbol_table = g_global_allfiles_symbol_table;
}
/*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 +141,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_lex_init(&(ptx_parser->scanner));
+ ptx_parser->init_directive_state();
+ ptx_parser->init_instruction_state();
+ FILE *ptx_in;
ptx_in = fopen(ptx_filename, "r");
- ptx_parse();
+ ptx_set_in(ptx_in, ptx_parser->scanner);
+ ptx_parse(ptx_parser->scanner, ptx_parser);
+ ptx_in = ptx_get_in(ptx_parser->scanner);
+ ptx_lex_destroy(ptx_parser->scanner);
fclose(ptx_in);
- return g_global_symbol_table;
+ return ptx_parser->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();
@@ -190,11 +167,7 @@ void start_function( int entry_point )
g_entry_func_param_index=0;
}
-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 +183,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 +205,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 +223,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 +232,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];
@@ -277,10 +250,9 @@ void parse_assert_impl( int test_value, const char *file, unsigned line, const c
parse_error_impl(file,line, msg);
}
-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 +272,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 +288,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 +306,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(),
@@ -348,7 +320,7 @@ void set_variable_type()
g_extern_spec );
}
-bool check_for_duplicates( const char *identifier )
+bool ptx_recognizer::check_for_duplicates( const char *identifier )
{
const symbol *s = g_current_symbol_table->lookup(identifier);
return ( s != NULL );
@@ -357,10 +329,6 @@ bool check_for_duplicates( const char *identifier )
extern std::set<std::string> g_globals;
extern std::set<std::string> g_constants;
-int g_func_decl = 0;
-int g_ident_add_uid = 0;
-unsigned g_const_alloc = 1;
-
// Returns padding that needs to be inserted ahead of address to make it aligned to min(size, maxalign)
/*
* @param address the address in bytes
@@ -378,7 +346,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 +394,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 +537,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 +552,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 +565,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 +586,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 +605,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 +650,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 +679,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 +702,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 +711,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 +720,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 +730,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 +744,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 +767,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 +781,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 +828,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 +842,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 +881,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 +890,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 +924,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 +947,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 +990,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..25c01fe 100644
--- a/src/cuda-sim/ptx_parser.h
+++ b/src/cuda-sim/ptx_parser.h
@@ -29,77 +29,151 @@
#define ptx_parser_INCLUDED
#include "../abstract_hardware_model.h"
+#include "ptx_ir.h"
extern const char *g_filename;
extern int g_error_detected;
#ifdef __cplusplus
-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;
+ g_size = -1;
+ g_add_identifier_cached__identifier = NULL;
+ g_alignment_spec = -1;
+ g_var_type = NULL;
+ g_opcode = -1;
+ g_space_spec = undefined_space;
+ g_ptr_spec = undefined_space;
+ g_scalar_type_spec = -1;
+ g_vector_spec = -1;
+ g_extern_spec = 0;
+ g_func_decl = 0;
+ g_ident_add_uid = 0;
+ g_const_alloc = 1;
+ g_max_regs_per_thread = 0;
+ g_global_symbol_table = NULL;
+ g_current_symbol_table = NULL;
+ g_last_symbol = NULL;
+ g_error_detected = 0;
+ g_entry_func_param_index=0;
+ g_func_info = NULL;
+ }
+ // global list
+ yyscan_t scanner;
+#define PTX_LINEBUF_SIZE (4*1024)
+ char linebuf[PTX_LINEBUF_SIZE];
+ unsigned col;
+ int g_size;
+ char *g_add_identifier_cached__identifier;
+ int g_add_identifier_cached__array_dim;
+ int g_add_identifier_cached__array_ident;
+ int g_alignment_spec;
+ // variable declaration stuff:
+ type_info *g_var_type;
+ // instruction definition stuff:
+ const symbol *g_pred;
+ int g_neg_pred;
+ int g_pred_mod;
+ symbol *g_label;
+ int g_opcode;
+ std::list<operand_info> g_operands;
+ std::list<int> g_options;
+ std::list<int> g_wmma_options;
+ std::list<int> g_scalar_type;
+ // type specifier stuff:
+ memory_space_t g_space_spec;
+ memory_space_t g_ptr_spec;
+ int g_scalar_type_spec;
+ int g_vector_spec;
+ int g_extern_spec;
+ int g_func_decl;
+ int g_ident_add_uid;
+ unsigned g_const_alloc;
+ unsigned g_max_regs_per_thread;
+ symbol_table *g_global_symbol_table;
+ symbol_table *g_current_symbol_table;
+ symbol *g_last_symbol;
+ std::list<ptx_instruction*> g_instructions;
+ int g_error_detected;
+ unsigned g_entry_func_param_index;
+ function_info *g_func_info;
+ operand_info g_return_var;
+
+ // member function list
+ 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();
+ bool check_for_duplicates( const char *identifier );
+
+};
+
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 820287d..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"
@@ -222,7 +224,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 +232,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;
diff --git a/src/cuda-sim/ptxinfo.l b/src/cuda-sim/ptxinfo.l
index 33c2748..b0ada09 100644
--- a/src/cuda-sim/ptxinfo.l
+++ b/src/cuda-sim/ptxinfo.l
@@ -31,17 +31,22 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
%option noyywrap
%option yylineno
%option prefix="ptxinfo_"
+
+%option bison-bridge
+%option reentrant
+
%{
+#include "ptx_loader.h"
#include "ptxinfo.tab.h"
#include <string.h>
#define LINEBUF_SIZE 1024
-char ptxinfo_linebuf[LINEBUF_SIZE];
-unsigned ptxinfo_col = 0;
-#define TC if( (ptxinfo_lineno == 1) && ((ptxinfo_col + strlen(ptxinfo_text)) < LINEBUF_SIZE) ) { \
- strncpy(ptxinfo_linebuf+ptxinfo_col,ptxinfo_text,strlen(ptxinfo_text)); \
+#define TC if( (yylineno == 1) && (ptxinfo->col + strlen(yytext) < LINEBUF_SIZE) ) { \
+ strncpy(ptxinfo->linebuf+ptxinfo->col,yytext,strlen(yytext)); \
} \
- ptxinfo_col+=strlen(ptxinfo_text);
+ ptxinfo->col+=strlen(yytext);
+#define YY_DECL int ptxinfo_lex \
+ (YYSTYPE * yylval_param , yyscan_t yyscanner, ptxinfo_data* ptxinfo)
%}
%%
@@ -61,12 +66,12 @@ unsigned ptxinfo_col = 0;
"for" TC; return FOR;
"textures" TC; return TEXTURES;
"error : Duplicate definition of" TC; return DUPLICATE;
-"function" TC; ptxinfo_lval.string_value = strdup(yytext); return FUNCTION;
-"variable" TC; ptxinfo_lval.string_value = strdup(yytext); return VARIABLE;
+"function" TC; yylval->string_value = strdup(yytext); return FUNCTION;
+"variable" TC; yylval->string_value = strdup(yytext); return VARIABLE;
"fatal : Ptx assembly aborted due to errors" TC; return FATAL;
-[_A-Za-z$%][_0-9A-Za-z$]* TC; ptxinfo_lval.string_value = strdup(yytext); return IDENTIFIER;
-[-]{0,1}[0-9]+ TC; ptxinfo_lval.int_value = atoi(yytext); return INT_OPERAND;
+[_A-Za-z$%][_0-9A-Za-z$]* TC; yylval->string_value = strdup(yytext); return IDENTIFIER;
+[-]{0,1}[0-9]+ TC; yylval->int_value = atoi(yytext); return INT_OPERAND;
"+" TC; return PLUS;
"," TC; return COMMA;
@@ -78,26 +83,26 @@ unsigned ptxinfo_col = 0;
" " TC;
"\t" TC;
-\n.* ptxinfo_col=0; strncpy(ptxinfo_linebuf, yytext + 1, 1024); yyless( 1 );
+\n.* ptxinfo->col=0; strncpy(ptxinfo->linebuf, yytext + 1, 1024); yyless( 1 );
%%
extern int g_ptxinfo_error_detected;
extern const char *g_filename;
-extern const char *g_ptxinfo_filename;
-int ptxinfo_error( const char *s )
+int ptxinfo_error(yyscan_t yyscanner, ptxinfo_data* ptxinfo, const char* msg)
{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
int i;
g_ptxinfo_error_detected = 1;
fflush(stdout);
printf("GPGPU-Sim: ERROR while parsing output of ptxas (used to capture resource usage information)\n");
- if( s != NULL )
- printf("GPGPU-Sim: %s (%s:%u) Syntax error:\n\n", g_filename, g_ptxinfo_filename, ptxinfo_lineno );
- printf(" %s\n", ptxinfo_linebuf );
+ if( msg != NULL )
+ printf("GPGPU-Sim: %s (%s:%u) Syntax error:\n\n", g_filename, ptxinfo->g_ptxinfo_filename, yylineno );
+ printf(" %s\n", ptxinfo->linebuf );
printf(" ");
- for( i=0; i < ptxinfo_col-1; i++ ) {
- if( ptxinfo_linebuf[i] == '\t' ) printf("\t");
+ for( i=0; i < ptxinfo->col-1; i++ ) {
+ if( ptxinfo->linebuf[i] == '\t' ) printf("\t");
else printf(" ");
}
diff --git a/src/cuda-sim/ptxinfo.y b/src/cuda-sim/ptxinfo.y
index d241d8c..00c81e0 100644
--- a/src/cuda-sim/ptxinfo.y
+++ b/src/cuda-sim/ptxinfo.y
@@ -27,6 +27,17 @@ 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 ptxinfo_data;
+%}
+
+%define api.pure full
+%parse-param {yyscan_t scanner}
+%parse-param {ptxinfo_data* ptxinfo}
+%lex-param {yyscan_t scanner}
+%lex-param {ptxinfo_data* ptxinfo}
+
%union {
int int_value;
char * string_value;
@@ -66,7 +77,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
static unsigned g_declared;
static unsigned g_system;
- int ptxinfo_lex(void);
+ int ptxinfo_lex(YYSTYPE * yylval_param, yyscan_t yyscanner, ptxinfo_data* ptxinfo);
+ void yyerror(yyscan_t yyscanner, ptxinfo_data* ptxinfo, const char* msg);
void ptxinfo_addinfo();
void ptxinfo_function(const char *fname );
void ptxinfo_regs( unsigned nregs );
@@ -74,7 +86,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
void ptxinfo_gmem( unsigned declared, unsigned system );
void ptxinfo_smem( unsigned declared, unsigned system );
void ptxinfo_cmem( unsigned nbytes, unsigned bank );
- int ptxinfo_error(const char*);
void ptxinfo_linenum( unsigned );
void ptxinfo_dup_type( const char* );
%}
generated by cgit v1.3 (git 2.53.0) at 2026-07-20 07:14:11 +0000