summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--.travis.yml5
-rw-r--r--Jenkinsfile2
-rw-r--r--Makefile1
-rw-r--r--configs/tested-cfgs/SM7_TITANV_fastlocalxbar/gpgpusim.config190
-rw-r--r--cuobjdump_to_ptxplus/Makefile8
-rw-r--r--cuobjdump_to_ptxplus/ptx.l471
-rw-r--r--cuobjdump_to_ptxplus/ptx.y629
-rw-r--r--libcuda/Makefile4
-rw-r--r--libcuda/cuda_runtime_api.cc380
-rw-r--r--libcuda/cuobjdump.h79
-rw-r--r--libcuda/cuobjdump.l9
-rw-r--r--libcuda/cuobjdump.y69
-rw-r--r--linux-so-version.txt4
-rw-r--r--nightly.jenkinsfile9
-rw-r--r--src/cuda-sim/cuda-sim.cc2
-rw-r--r--src/cuda-sim/instructions.cc2
-rw-r--r--src/cuda-sim/ptx.l320
-rw-r--r--src/cuda-sim/ptx.y494
-rw-r--r--src/cuda-sim/ptx_ir.cc1
-rw-r--r--src/cuda-sim/ptx_loader.cc49
-rw-r--r--src/cuda-sim/ptx_loader.h12
-rw-r--r--src/cuda-sim/ptx_parser.cc172
-rw-r--r--src/cuda-sim/ptx_parser.h137
-rw-r--r--src/cuda-sim/ptx_sim.cc2
-rw-r--r--src/cuda-sim/ptxinfo.l19
-rw-r--r--src/cuda-sim/ptxinfo.y10
-rw-r--r--src/gpgpu-sim/gpu-cache.h6
27 files changed, 2049 insertions, 1037 deletions
diff --git a/.travis.yml b/.travis.yml
index b38f468..82f0604 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -18,5 +18,10 @@ matrix:
- CONFIG=TITANV
- CUDA_INSTALL_PATH=/usr/local/cuda-9.1/
- PTXAS_CUDA_INSTALL_PATH=/usr/local/cuda-9.1/
+ - services: docker
+ env:
+ - CONFIG=TITANV-LOCALXBAR
+ - CUDA_INSTALL_PATH=/usr/local/cuda-9.1/
+ - PTXAS_CUDA_INSTALL_PATH=/usr/local/cuda-9.1/
script: docker run -v `pwd`:/home/runner/gpgpu-sim_distribution:rw tgrogers/gpgpu-sim_regress:volta_update /bin/bash -c "./start_torque.sh; chown -R runner /home/runner/gpgpu-sim_distribution; su - runner -c 'export CUDA_INSTALL_PATH=$CUDA_INSTALL_PATH && export PTXAS_CUDA_INSTALL_PATH=$PTXAS_CUDA_INSTALL_PATH && source /home/runner/gpgpu-sim_distribution/setup_environment && make -j -C /home/runner/gpgpu-sim_distribution && cd /home/runner/gpgpu-sim_simulations/ && git pull && /home/runner/gpgpu-sim_simulations/util/job_launching/run_simulations.py -C $CONFIG -B rodinia_2.0-ft -N regress && /home/runner/gpgpu-sim_simulations/util/job_launching/monitor_func_test.py -v -N regress'"
diff --git a/Jenkinsfile b/Jenkinsfile
index 4bdbddf..aefd7e0 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -24,7 +24,7 @@ pipeline {
stage('simulations-build'){
steps{
sh 'rm -rf gpgpu-sim_simulations'
- sh 'git clone [email protected]:gpgpu-sim/gpgpu-sim_simulations.git && \
+ sh 'git clone [email protected]:purdue-aalp/gpgpu-sim_simulations.git && \
cd gpgpu-sim_simulations && \
git pull && \
ln -s /home/tgrogers-raid/a/common/data_dirs benchmarks/'
diff --git a/Makefile b/Makefile
index 2d0466e..3db8ce8 100644
--- a/Makefile
+++ b/Makefile
@@ -163,6 +163,7 @@ $(SIM_LIB_DIR)/libcudart.so: makedirs $(LIBS) cudalib
if [ ! -f $(SIM_LIB_DIR)/libcudart.so.8.0 ]; then ln -s libcudart.so $(SIM_LIB_DIR)/libcudart.so.8.0; fi
if [ ! -f $(SIM_LIB_DIR)/libcudart.so.9.0 ]; then ln -s libcudart.so $(SIM_LIB_DIR)/libcudart.so.9.0; fi
if [ ! -f $(SIM_LIB_DIR)/libcudart.so.9.1 ]; then ln -s libcudart.so $(SIM_LIB_DIR)/libcudart.so.9.1; fi
+ if [ ! -f $(SIM_LIB_DIR)/libcudart.so.9.2 ]; then ln -s libcudart.so $(SIM_LIB_DIR)/libcudart.so.9.2; fi
$(SIM_LIB_DIR)/libcudart.dylib: makedirs $(LIBS) cudalib
g++ -dynamiclib -Wl,-headerpad_max_install_names,-undefined,dynamic_lookup,-compatibility_version,1.1,-current_version,1.1\
diff --git a/configs/tested-cfgs/SM7_TITANV_fastlocalxbar/gpgpusim.config b/configs/tested-cfgs/SM7_TITANV_fastlocalxbar/gpgpusim.config
deleted file mode 100644
index 4625ac4..0000000
--- a/configs/tested-cfgs/SM7_TITANV_fastlocalxbar/gpgpusim.config
+++ /dev/null
@@ -1,190 +0,0 @@
-# This config models the Volta Titan V
-# For more info about volta architecture:
-# http://images.nvidia.com/content/volta-architecture/pdf/volta-architecture-whitepaper.pdf
-# https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=8344474&tag=1#
-# http://on-demand.gputechconf.com/gtc/2018/presentation/s8122-dissecting-the-volta-gpu-architecture-through-microbenchmarking.pdf
-# https://en.wikipedia.org/wiki/Volta_(microarchitecture)
-# https://www.hotchips.org/wp-content/uploads/hc_archives/hc29/HC29.21-Monday-Pub/HC29.21.10-GPU-Gaming-Pub/HC29.21.132-Volta-Choquette-NVIDIA-Final3.pdf
-# https://devblogs.nvidia.com/inside-volta/
-# http://on-demand.gputechconf.com/gtc/2017/presentation/s7798-luke-durant-inside-volta.pdf
-
-# functional simulator specification
--gpgpu_ptx_instruction_classification 0
--gpgpu_ptx_sim_mode 0
--gpgpu_ptx_force_max_capability 70
-
-# SASS execution (only supported with CUDA >= 4.0)
--gpgpu_ptx_convert_to_ptxplus 0
--gpgpu_ptx_save_converted_ptxplus 0
-
-# high level architecture configuration
--gpgpu_n_clusters 40
--gpgpu_n_cores_per_cluster 2
--gpgpu_n_mem 24
--gpgpu_n_sub_partition_per_mchannel 2
-
-# volta clock domains
-#-gpgpu_clock_domains <Core Clock>:<Interconnect Clock>:<L2 Clock>:<DRAM Clock>
-# Volta NVIDIA TITANV clock domains are adopted from
-# https://en.wikipedia.org/wiki/Volta_(microarchitecture)
--gpgpu_clock_domains 1200.0:1200.0:1200.0:850.0
-# boost mode
-# -gpgpu_clock_domains 1455.0:1455.0:1455.0:850.0
-
-# shader core pipeline config
--gpgpu_shader_registers 65536
--gpgpu_occupancy_sm_number 70
-
-# This implies a maximum of 64 warps/SM
--gpgpu_shader_core_pipeline 2048:32
--gpgpu_shader_cta 32
--gpgpu_simd_model 1
-
-# Pipeline widths and number of FUs
-# ID_OC_SP,ID_OC_DP,ID_OC_INT,ID_OC_SFU,ID_OC_MEM,OC_EX_SP,OC_EX_DP,OC_EX_INT,OC_EX_SFU,OC_EX_MEM,EX_WB,ID_OC_TENSOR_CORE,OC_EX_TENSOR_CORE
-## Volta TITANV has 4 SP SIMD units, 4 SFU units, 4 DP units per core, 4 Tensor core units
-## we need to scale the number of pipeline registers to be equal to the number of SP units
--gpgpu_pipeline_widths 4,4,4,4,4,4,4,4,4,4,8,4,4
--gpgpu_num_sp_units 4
--gpgpu_num_sfu_units 4
--gpgpu_num_dp_units 4
--gpgpu_num_int_units 4
--gpgpu_tensor_core_avail 1
--gpgpu_num_tensor_core_units 4
-
-# Instruction latencies and initiation intervals
-# "ADD,MAX,MUL,MAD,DIV"
-# All Div operations are executed on SFU unit
-# Throughput (initiation latency) are adopted from
-# http://on-demand.gputechconf.com/gtc/2018/presentation/s8122-dissecting-the-volta-gpu-architecture-through-microbenchmarking.pdf
--ptx_opcode_latency_int 4,13,4,5,145
--ptx_opcode_initiation_int 2,2,2,2,8
--ptx_opcode_latency_fp 4,13,4,5,39
--ptx_opcode_initiation_fp 2,2,2,2,4
--ptx_opcode_latency_dp 8,19,8,8,330
--ptx_opcode_initiation_dp 4,4,4,4,130
--ptx_opcode_latency_sfu 100
--ptx_opcode_initiation_sfu 8
--ptx_opcode_latency_tesnor 64
--ptx_opcode_initiation_tensor 64
-
-# <nsets>:<bsize>:<assoc>,<rep>:<wr>:<alloc>:<wr_alloc>:<set_index_fn>,<mshr>:<N>:<merge>,<mq>:**<fifo_entry>
-# ** Optional parameter - Required when mshr_type==Texture Fifo
-# Defualt config is 32KB DL1 and 96KB shared memory
-# In Volta, we assign the remaining shared memory to L1 cache
-# if the assigned shd mem = 0, then L1 cache = 128KB
-# For more info, see https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#shared-memory-7-x
-# disable this mode in case of multi kernels/apps execution
--adaptive_volta_cache_config 1
-# Volta unified cache has four ports
--mem_unit_ports 4
--gpgpu_cache:dl1 S:4:128:64,L:L:s:N:L,A:256:8,16:0,32
--gpgpu_shmem_size 98304
--gmem_skip_L1D 0
--icnt_flit_size 40
--gpgpu_n_cluster_ejection_buffer_size 32
--l1_latency 28
--smem_latency 19
--gpgpu_flush_l1_cache 1
-
-# 32 sets, each 128 bytes 24-way for each memory sub partition (96 KB per memory sub partition). This gives us 4.5MB L2 cache
--gpgpu_cache:dl2 S:32:128:24,L:B:m:L:L,A:192:4,32:0,32
--gpgpu_cache:dl2_texture_only 0
--gpgpu_dram_partition_queues 64:64:64:64
--perf_sim_memcpy 1
--memory_partition_indexing 0
-
-# 128 KB Inst.
--gpgpu_cache:il1 N:64:128:16,L:R:f:N:L,S:2:48,4
-# 48 KB Tex
-# Note, TEX is deprected in Volta, It is used for legacy apps only. Use L1D cache instead with .nc modifier or __ldg mehtod
--gpgpu_tex_cache:l1 N:16:128:24,L:R:m:N:L,T:128:4,128:2
-# 64 KB Const
--gpgpu_const_cache:l1 N:128:64:8,L:R:f:N:L,S:2:64,4
-
-# Volta has sub core model, in which each scheduler has its own register file and EUs
-# i.e. schedulers are isolated
--sub_core_model 1
-# disable specialized operand collectors and use generic operand collectors instead
--enable_specialized_operand_collector 0
--gpgpu_operand_collector_num_units_gen 8
--gpgpu_operand_collector_num_in_ports_gen 8
--gpgpu_operand_collector_num_out_ports_gen 8
-# volta has 8 banks, 4 schedulers, two banks per scheduler
--gpgpu_num_reg_banks 8
-
-# shared memory bankconflict detection
--gpgpu_shmem_num_banks 32
--gpgpu_shmem_limited_broadcast 0
--gpgpu_shmem_warp_parts 1
--gpgpu_coalesce_arch 60
-
-## In Volta, a warp scheduler can issue 1 inst per cycle
--gpgpu_max_insn_issue_per_warp 1
--gpgpu_dual_issue_diff_exec_units 1
-
-# use local xbar interconnection
--network_mode 2
--inct_in_buffer_limit 512
--inct_out_buffer_limit 512
--inct_subnets 2
-
-# memory partition latency config
--rop_latency 120
--dram_latency 100
-
-# dram model config
--gpgpu_dram_scheduler 1
--gpgpu_frfcfs_dram_sched_queue_size 64
--gpgpu_dram_return_queue_size 192
-
-# for HBM, three stacks, 24 channles, each (128 bits) 16 bytes width
--gpgpu_n_mem_per_ctrlr 1
--gpgpu_dram_buswidth 16
--gpgpu_dram_burst_length 2
--dram_data_command_freq_ratio 2 # HBM is DDR
--gpgpu_mem_address_mask 1
--gpgpu_mem_addr_mapping dramid@8;00000000.00000000.00000000.00000000.0000RRRR.RRRRRRRR.RBBBCCCB.CCCSSSSS
-
-# HBM timing are adopted from hynix JESD235 standered and nVidia HPCA 2017 paper (http://www.cs.utah.edu/~nil/pubs/hpca17.pdf)
-# Timing for 1 GHZ
-# tRRDl and tWTR are missing, need to be added
-#-gpgpu_dram_timing_opt "nbk=16:CCD=1:RRD=4:RCD=14:RAS=33:RP=14:RC=47:
-# CL=14:WL=2:CDLR=3:WR=12:nbkgrp=4:CCDL=2:RTPL=4"
-
-# Timing for 850 MHZ, Tesla TITANV V100 HBM runs at 850 MHZ
--gpgpu_dram_timing_opt "nbk=16:CCD=1:RRD=3:RCD=12:RAS=28:RP=12:RC=40:
- CL=12:WL=2:CDLR=3:WR=10:nbkgrp=4:CCDL=2:RTPL=3"
-
-# HBM has dual bus interface, in which it can issue two col and row commands at a time
--dual_bus_interface 1
-# select lower bits for bnkgrp to increase bnkgrp parallelism
--dram_bnk_indexing_policy 0
--dram_bnkgrp_indexing_policy 1
-
-#-Seperate_Write_Queue_Enable 1
-#-Write_Queue_Size 64:56:32
-
-# Volta has four schedulers per core
--gpgpu_num_sched_per_core 4
-# Two Level Scheduler with active and pending pools
-#-gpgpu_scheduler two_level_active:6:0:1
-# Loose round robbin scheduler
-#-gpgpu_scheduler lrr
-# Greedy then oldest scheduler
--gpgpu_scheduler gto
-
-# stat collection
--gpgpu_memlatency_stat 14
--gpgpu_runtime_stat 500
--enable_ptx_file_line_stats 1
--visualizer_enabled 0
-
-# power model configs, disable it untill we create a real energy model for Volta
--power_simulation_enabled 0
-
-# tracing functionality
-#-trace_enabled 1
-#-trace_components WARP_SCHEDULER,SCOREBOARD
-#-trace_sampling_core 0
-
diff --git a/cuobjdump_to_ptxplus/Makefile b/cuobjdump_to_ptxplus/Makefile
index 242a066..e95136a 100644
--- a/cuobjdump_to_ptxplus/Makefile
+++ b/cuobjdump_to_ptxplus/Makefile
@@ -27,11 +27,11 @@ $(OUTPUT_DIR)/cuobjdump_to_ptxplus: $(OUTPUT_DIR)/cuobjdumpInst.o $(OUTPUT_DIR)/
${LD} ${LDFLAGS} -o $@ $(OUTPUT_DIR)/cuobjdumpInst.o $(OUTPUT_DIR)/cuobjdumpInstList.o $(OUTPUT_DIR)/cuobjdump_to_ptxplus.o $(PTX_PARSER_OBJECTS) $(SASS_PARSER_OBJECTS) $(ELF_PARSER_OBJECTS) $(HEADER_PARSER_OBJECTS)
-$(OUTPUT_DIR)/lex.ptx_.c : ../src/cuda-sim/ptx.l
- ${LEX} ${LEXFLAGS} -o$(OUTPUT_DIR)/lex.ptx_.c ../src/cuda-sim/ptx.l
+$(OUTPUT_DIR)/lex.ptx_.c : ptx.l
+ ${LEX} ${LEXFLAGS} -o$(OUTPUT_DIR)/lex.ptx_.c ptx.l
-$(OUTPUT_DIR)/ptx.tab.c : ../src/cuda-sim/ptx.y
- ${YACC} ${YFLAGS} --name-prefix=ptx_ -v ../src/cuda-sim/ptx.y --file-prefix=$(OUTPUT_DIR)/ptx
+$(OUTPUT_DIR)/ptx.tab.c : ptx.y
+ ${YACC} ${YFLAGS} --name-prefix=ptx_ -v ptx.y --file-prefix=$(OUTPUT_DIR)/ptx
$(OUTPUT_DIR)/ptx.tab.h :$(OUTPUT_DIR)/ptx.tab.c
diff --git a/cuobjdump_to_ptxplus/ptx.l b/cuobjdump_to_ptxplus/ptx.l
new file mode 100644
index 0000000..3232361
--- /dev/null
+++ b/cuobjdump_to_ptxplus/ptx.l
@@ -0,0 +1,471 @@
+/*
+Copyright (c) 2009-2011, Tor M. Aamodt
+The University of British Columbia
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+Neither the name of The University of British Columbia nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%option nounput
+%option noyywrap
+%option yylineno
+%option prefix="ptx_"
+%{
+#include "opcodes.h"
+#include "ptx.tab.h"
+#include <string.h>
+
+#define LINEBUF_SIZE (64*1024)
+char linebuf[LINEBUF_SIZE];
+unsigned col = 0;
+#define TC col+=strlen(ptx_text);
+#define CHECK_UNSIGNED \
+ if( yytext[strlen(yytext)-1]=='U' ) { \
+ printf("GPGPU-Sim: ERROR ** U modifier not implemented\n"); \
+ abort(); \
+ }
+int ptx_error( const char *s );
+%}
+
+%s IN_STRING
+%s IN_COMMENT
+%x IN_FUNC_DECL
+%x NOT_OPCODE
+%%
+
+abs TC; ptx_lval.int_value = ABS_OP; return OPCODE;
+add TC; ptx_lval.int_value = ADD_OP; return OPCODE;
+addp TC; ptx_lval.int_value = ADDP_OP; return OPCODE;
+addc TC; ptx_lval.int_value = ADDC_OP; return OPCODE;
+and TC; ptx_lval.int_value = AND_OP; return OPCODE;
+andn TC; ptx_lval.int_value = ANDN_OP; return OPCODE;
+atom TC; ptx_lval.int_value = ATOM_OP; return OPCODE;
+bar.warp TC; ptx_lval.int_value = NOP_OP; return OPCODE;
+bar TC; ptx_lval.int_value = BAR_OP; return OPCODE;
+bfe TC; ptx_lval.int_value = BFE_OP; return OPCODE;
+bfi TC; ptx_lval.int_value = BFI_OP; return OPCODE;
+bfind TC; ptx_lval.int_value = BFIND_OP; return OPCODE;
+bra TC; ptx_lval.int_value = BRA_OP; return OPCODE;
+brx TC; ptx_lval.int_value = BRX_OP; return OPCODE;
+brev TC; ptx_lval.int_value = BREV_OP; return OPCODE;
+brkpt TC; ptx_lval.int_value = BRKPT_OP; return OPCODE;
+
+wmma TC; ptx_lval.int_value = MMA_OP; return OPCODE;
+wmma\.load TC; ptx_lval.int_value = MMA_LD_OP; return OPCODE;
+wmma\.store TC; ptx_lval.int_value = MMA_ST_OP; return OPCODE;
+
+call TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = CALL_OP; return OPCODE; // blocking opcode token in case the callee has the same name as an opcode
+callp TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = CALLP_OP; return OPCODE;
+clz TC; ptx_lval.int_value = CLZ_OP; return OPCODE;
+cnot TC; ptx_lval.int_value = CNOT_OP; return OPCODE;
+cos TC; ptx_lval.int_value = COS_OP; return OPCODE;
+cvt TC; ptx_lval.int_value = CVT_OP; return OPCODE;
+cvta TC; ptx_lval.int_value = CVTA_OP; return OPCODE;
+div TC; ptx_lval.int_value = DIV_OP; return OPCODE;
+dp4a TC; ptx_lval.int_value = DP4A_OP; return OPCODE;
+ex2 TC; ptx_lval.int_value = EX2_OP; return OPCODE;
+exit TC; ptx_lval.int_value = EXIT_OP; return OPCODE;
+fma TC; ptx_lval.int_value = FMA_OP; return OPCODE;
+isspacep TC; ptx_lval.int_value = ISSPACEP_OP; return OPCODE;
+ld TC; ptx_lval.int_value = LD_OP; return OPCODE;
+ld.volatile TC; ptx_lval.int_value = LD_OP; return OPCODE;
+ldu TC; ptx_lval.int_value = LDU_OP; return OPCODE;
+lg2 TC; ptx_lval.int_value = LG2_OP; return OPCODE;
+mad24 TC; ptx_lval.int_value = MAD24_OP; return OPCODE;
+mad TC; ptx_lval.int_value = MAD_OP; return OPCODE;
+madc TC; ptx_lval.int_value = MADC_OP; return OPCODE;
+madp TC; ptx_lval.int_value = MADP_OP; return OPCODE;
+max TC; ptx_lval.int_value = MAX_OP; return OPCODE;
+membar TC; ptx_lval.int_value = MEMBAR_OP; return OPCODE;
+min TC; ptx_lval.int_value = MIN_OP; return OPCODE;
+mov TC; ptx_lval.int_value = MOV_OP; return OPCODE;
+mul24 TC; ptx_lval.int_value = MUL24_OP; return OPCODE;
+mul TC; ptx_lval.int_value = MUL_OP; return OPCODE;
+neg TC; ptx_lval.int_value = NEG_OP; return OPCODE;
+nandn TC; ptx_lval.int_value = NANDN_OP; return OPCODE;
+norn TC; ptx_lval.int_value = NORN_OP; return OPCODE;
+not TC; ptx_lval.int_value = NOT_OP; return OPCODE;
+or TC; ptx_lval.int_value = OR_OP; return OPCODE;
+orn TC; ptx_lval.int_value = ORN_OP; return OPCODE;
+pmevent TC; ptx_lval.int_value = PMEVENT_OP; return OPCODE;
+popc TC; ptx_lval.int_value = POPC_OP; return OPCODE;
+prefetch TC; ptx_lval.int_value = PREFETCH_OP; return OPCODE;
+prefetchu TC; ptx_lval.int_value = PREFETCHU_OP; return OPCODE;
+prmt TC; ptx_lval.int_value = PRMT_OP; return OPCODE;
+rcp TC; ptx_lval.int_value = RCP_OP; return OPCODE;
+red TC; ptx_lval.int_value = RED_OP; return OPCODE;
+rem TC; ptx_lval.int_value = REM_OP; return OPCODE;
+ret TC; ptx_lval.int_value = RET_OP; return OPCODE;
+retp TC; ptx_lval.int_value = RETP_OP; return OPCODE;
+rsqrt TC; ptx_lval.int_value = RSQRT_OP; return OPCODE;
+sad TC; ptx_lval.int_value = SAD_OP; return OPCODE;
+selp TC; ptx_lval.int_value = SELP_OP; return OPCODE;
+setp TC; ptx_lval.int_value = SETP_OP; return OPCODE;
+set TC; ptx_lval.int_value = SET_OP; return OPCODE;
+shfl TC; ptx_lval.int_value = SHFL_OP; return OPCODE;
+shl TC; ptx_lval.int_value = SHL_OP; return OPCODE;
+shr TC; ptx_lval.int_value = SHR_OP; return OPCODE;
+sin TC; ptx_lval.int_value = SIN_OP; return OPCODE;
+slct TC; ptx_lval.int_value = SLCT_OP; return OPCODE;
+sqrt TC; ptx_lval.int_value = SQRT_OP; return OPCODE;
+sst TC; ptx_lval.int_value = SST_OP; return OPCODE;
+ssy TC; ptx_lval.int_value = SSY_OP; return OPCODE;
+st TC; ptx_lval.int_value = ST_OP; return OPCODE;
+st.volatile TC; ptx_lval.int_value = ST_OP; return OPCODE;
+sub TC; ptx_lval.int_value = SUB_OP; return OPCODE;
+subc TC; ptx_lval.int_value = SUBC_OP; return OPCODE;
+suld TC; ptx_lval.int_value = SULD_OP; return OPCODE;
+sured TC; ptx_lval.int_value = SURED_OP; return OPCODE;
+surst TC; ptx_lval.int_value = SUST_OP; return OPCODE;
+suq TC; ptx_lval.int_value = SUQ_OP; return OPCODE;
+tex TC; BEGIN(NOT_OPCODE); ptx_lval.int_value = TEX_OP; return OPCODE;
+txq TC; ptx_lval.int_value = TEX_OP; return OPCODE;
+trap TC; ptx_lval.int_value = TRAP_OP; return OPCODE;
+vabsdiff TC; ptx_lval.int_value = VABSDIFF_OP; return OPCODE;
+vadd TC; ptx_lval.int_value = VADD_OP; return OPCODE;
+vmad TC; ptx_lval.int_value = VMAD_OP; return OPCODE;
+vmax TC; ptx_lval.int_value = VMAX_OP; return OPCODE;
+vmin TC; ptx_lval.int_value = VMIN_OP; return OPCODE;
+vset TC; ptx_lval.int_value = VSET_OP; return OPCODE;
+vshl TC; ptx_lval.int_value = VSHL_OP; return OPCODE;
+vshr TC; ptx_lval.int_value = VSHR_OP; return OPCODE;
+vsub TC; ptx_lval.int_value = VSUB_OP; return OPCODE;
+vote TC; ptx_lval.int_value = VOTE_OP; return OPCODE;
+xor TC; ptx_lval.int_value = XOR_OP; return OPCODE;
+nop TC; ptx_lval.int_value = NOP_OP; return OPCODE;
+break TC; ptx_lval.int_value = BREAK_OP; return OPCODE;
+breakaddr TC; ptx_lval.int_value = BREAKADDR_OP; return OPCODE;
+
+"CPTX_END" printf("ENDING CUSTOM PTX.\n"); BEGIN(IN_COMMENT);
+
+<INITIAL,NOT_OPCODE,IN_INST,IN_FUNC_DECL>{
+\.a\.sync TC; ptx_lval.int_value = LOAD_A; return WMMA_DIRECTIVE;
+\.b\.sync TC; ptx_lval.int_value = LOAD_B; return WMMA_DIRECTIVE;
+\.c\.sync TC; ptx_lval.int_value = LOAD_C; return WMMA_DIRECTIVE;
+\.d\.sync TC; ptx_lval.int_value = STORE_D; return WMMA_DIRECTIVE;
+\.mma\.sync TC;ptx_lval.int_value=MMA; return WMMA_DIRECTIVE;
+
+\.row TC; ptx_lval.int_value = ROW; return LAYOUT;
+\.col TC; ptx_lval.int_value = COL; return LAYOUT;
+\.m16n16k16 TC; ptx_lval.int_value = M16N16K16; return CONFIGURATION;
+\.f4e TC; return PRMT_F4E_MODE;
+\.b4e TC; return PRMT_B4E_MODE;
+\.rc8 TC; return PRMT_RC8_MODE;
+\.ecl TC; return PRMT_ECL_MODE;
+\.ecr TC; return PRMT_ECR_MODE;
+\.rc16 TC; return PRMT_RC16_MODE;
+
+\.align TC; return ALIGN_DIRECTIVE;
+\.branchtargets TC; return BRANCHTARGETS_DIRECTIVE;
+\.byte TC; return BYTE_DIRECTIVE; /* not in PTX 2.1 */
+\.callprototype TC; return CALLPROTOTYPE_DIRECTIVE;
+\.calltargets TC; return CALLTARGETS_DIRECTIVE;
+\.const\[[0-9]+\] TC; ptx_lval.int_value = atoi(yytext+7); return CONST_DIRECTIVE;
+\.const TC; ptx_lval.int_value = 0; return CONST_DIRECTIVE;
+\.entry TC; return ENTRY_DIRECTIVE;
+\.extern TC; return EXTERN_DIRECTIVE;
+\.file TC; BEGIN(INITIAL); return FILE_DIRECTIVE;
+\.func TC; BEGIN(IN_FUNC_DECL); return FUNC_DIRECTIVE; // blocking opcode parsing in case the function has the same name as an opcode (e.g. sin(), cos())
+\.global TC; return GLOBAL_DIRECTIVE;
+\.global.volatile TC; return GLOBAL_DIRECTIVE; //TODO: fix this!
+\.local TC; return LOCAL_DIRECTIVE;
+\.loc TC; return LOC_DIRECTIVE;
+\.maxnctapersm TC; return MAXNCTAPERSM_DIRECTIVE;
+\.maxnreg TC; return MAXNNREG_DIRECTIVE;
+\.maxntid TC; return MAXNTID_DIRECTIVE;
+\.minnctapersm TC; return MINNCTAPERSM_DIRECTIVE;
+\.param TC; return PARAM_DIRECTIVE;
+\.pragma TC; return PRAGMA_DIRECTIVE;
+\.reg TC; return REG_DIRECTIVE;
+\.reqntid TC; return REQNTID_DIRECTIVE;
+\.section TC; return SECTION_DIRECTIVE;
+\.shared TC; return SHARED_DIRECTIVE;
+\.sreg TC; return SREG_DIRECTIVE;
+\.sstarr TC; return SSTARR_DIRECTIVE;
+\.struct TC; return STRUCT_DIRECTIVE;
+\.surf TC; return SURF_DIRECTIVE; /* not in PTX 2.1 */
+\.target TC; return TARGET_DIRECTIVE;
+\.tex TC; BEGIN(NOT_OPCODE); return TEX_DIRECTIVE;
+\.union TC; return UNION_DIRECTIVE; /* not in PTX 2.1 */
+\.version TC; return VERSION_DIRECTIVE;
+\.visible TC; return VISIBLE_DIRECTIVE;
+\.weak TC; return WEAK_DIRECTIVE;
+\.address_size TC; return ADDRESS_SIZE_DIRECTIVE;
+\.weak TC; return WEAK_DIRECTIVE;
+
+\.constptr TC; return CONSTPTR_DIRECTIVE; /* Ptx plus directive for pointer to constant memory */
+\.ptr TC; return PTR_DIRECTIVE; /* Added for new OpenCL genrated code */
+
+"%clock" TC; ptx_lval.int_value = CLOCK_REG; return SPECIAL_REGISTER;
+"%halfclock" TC; ptx_lval.int_value = HALFCLOCK_ID; return SPECIAL_REGISTER;
+"%clock64" TC; ptx_lval.int_value = CLOCK64_REG; return SPECIAL_REGISTER;
+"%ctaid" TC; ptx_lval.int_value = CTAID_REG; return SPECIAL_REGISTER;
+"%envreg"[0-9]+ TC; sscanf(yytext+7,"%u",&ptx_lval.int_value); ptx_lval.int_value<<=16; ptx_lval.int_value += ENVREG_REG; return SPECIAL_REGISTER;
+"%gridid" TC; ptx_lval.int_value = GRIDID_REG; return SPECIAL_REGISTER;
+"%laneid" TC; ptx_lval.int_value = LANEID_REG; return SPECIAL_REGISTER;
+"%lanemask_eq" TC; ptx_lval.int_value = LANEMASK_EQ_REG; return SPECIAL_REGISTER;
+"%lanemask_le" TC; ptx_lval.int_value = LANEMASK_LE_REG; return SPECIAL_REGISTER;
+"%lanemask_lt" TC; ptx_lval.int_value = LANEMASK_LT_REG; return SPECIAL_REGISTER;
+"%lanemask_ge" TC; ptx_lval.int_value = LANEMASK_GE_REG; return SPECIAL_REGISTER;
+"%lanemask_gt" TC; ptx_lval.int_value = LANEMASK_GT_REG; return SPECIAL_REGISTER;
+"%nctaid" TC; ptx_lval.int_value = NCTAID_REG; return SPECIAL_REGISTER;
+"%ntid" TC; ptx_lval.int_value = NTID_REG; return SPECIAL_REGISTER;
+"%nsmid" TC; ptx_lval.int_value = NSMID_REG; return SPECIAL_REGISTER;
+"%nwarpid" TC; ptx_lval.int_value = NWARPID_REG; return SPECIAL_REGISTER;
+"%pm"[0-3] TC; sscanf(yytext+3,"%u",&ptx_lval.int_value); ptx_lval.int_value<<=16; ptx_lval.int_value += PM_REG; return SPECIAL_REGISTER;
+"%smid" TC; ptx_lval.int_value = SMID_REG; return SPECIAL_REGISTER;
+"%tid" TC; ptx_lval.int_value = TID_REG; return SPECIAL_REGISTER;
+"%warpid" TC; ptx_lval.int_value = WARPID_REG; return SPECIAL_REGISTER;
+"WARP_SZ" TC; ptx_lval.int_value = WARPSZ_REG; return SPECIAL_REGISTER;
+
+[a-zA-Z_][a-zA-Z0-9_$]* TC; ptx_lval.string_value = strdup(yytext); return IDENTIFIER;
+[$%][a-zA-Z0-9_$]+ TC; ptx_lval.string_value = strdup(yytext); return IDENTIFIER;
+
+[0-9]+\.[0-9]+ TC; sscanf(yytext,"%lf", &ptx_lval.double_value); return DOUBLE_OPERAND;
+
+0[xX][0-9a-fA-F]+U? TC; CHECK_UNSIGNED; sscanf(yytext,"%x", &ptx_lval.int_value); return INT_OPERAND;
+0[0-7]+U? TC; printf("GPGPU-Sim: ERROR ** parsing octal not (yet) implemented\n"); abort(); return INT_OPERAND;
+0[bB][01]+U? TC; printf("GPGPU-Sim: ERROR ** parsing binary not (yet) implemented\n"); abort(); return INT_OPERAND;
+[-]?[0-9]+U? TC; CHECK_UNSIGNED; ptx_lval.int_value = atoi(yytext); return INT_OPERAND;
+
+0[fF][0-9a-fA-F]{8} TC; sscanf(yytext+2,"%x", (unsigned*)(void*)&ptx_lval.float_value); return FLOAT_OPERAND;
+0[dD][0-9a-fA-F]{16} TC; sscanf(yytext+2,"%Lx", (unsigned long long*)(void*)&ptx_lval.double_value); return DOUBLE_OPERAND;
+
+\.s8 TC; return S8_TYPE;
+\.s16 TC; return S16_TYPE;
+\.s32 TC; return S32_TYPE;
+\.s64 TC; return S64_TYPE;
+\.u8 TC; return U8_TYPE;
+\.u16 TC; return U16_TYPE;
+\.u32 TC; return U32_TYPE;
+\.u64 TC; return U64_TYPE;
+\.f16 TC; return F16_TYPE;
+\.f16x2 TC; return F16_TYPE; /* TODO: figure out what this should really be */
+\.f32 TC; return F32_TYPE;
+\.f64 TC; return F64_TYPE;
+\.ff64 TC; return FF64_TYPE;
+\.b8 TC; return B8_TYPE;
+\.b16 TC; return B16_TYPE;
+\.b32 TC; return B32_TYPE;
+\.b64 TC; return B64_TYPE;
+\.bb64 TC; return BB64_TYPE;
+\.bb128 TC; return BB128_TYPE;
+\.pred TC; return PRED_TYPE;
+
+\.texref TC; BEGIN(NOT_OPCODE); return TEXREF_TYPE;
+\.samplerref TC; return SAMPLERREF_TYPE;
+\.surfref TC; return SURFREF_TYPE;
+
+\.v2 TC; return V2_TYPE;
+\.v3 TC; return V3_TYPE;
+\.v4 TC; return V4_TYPE;
+
+\.half TC; return HALF_OPTION; /* ptxplus */
+\.cc TC; return EXTP_OPTION; /* extended precision option */
+
+\.equ TC; return EQU_OPTION;
+\.neu TC; return NEU_OPTION;
+\.ltu TC; return LTU_OPTION;
+\.leu TC; return LEU_OPTION;
+\.gtu TC; return GTU_OPTION;
+\.geu TC; return GEU_OPTION;
+\.num TC; return NUM_OPTION;
+\.nan TC; return NAN_OPTION;
+
+\.sat TC; return SAT_OPTION;
+
+\.eq TC; return EQ_OPTION;
+\.ne TC; return NE_OPTION;
+\.lt TC; return LT_OPTION;
+\.le TC; return LE_OPTION;
+\.gt TC; return GT_OPTION;
+\.ge TC; return GE_OPTION;
+\.cf TC; return CF_OPTION;
+\.sf TC; return SF_OPTION;
+\.nsf TC; return NSF_OPTION;
+
+\.lo TC; return LO_OPTION;
+\.ls TC; return LS_OPTION;
+\.hi TC; return HI_OPTION;
+\.hs TC; return HS_OPTION;
+
+
+\.rni TC; return RNI_OPTION;
+\.rzi TC; return RZI_OPTION;
+\.rmi TC; return RMI_OPTION;
+\.rpi TC; return RPI_OPTION;
+
+\.rn TC; return RN_OPTION;
+\.rz TC; return RZ_OPTION;
+\.rm TC; return RM_OPTION;
+\.rp TC; return RP_OPTION;
+
+\.ftz TC; return FTZ_OPTION;
+
+\.neg TC; return NEG_OPTION;
+
+\.wide TC; return WIDE_OPTION;
+\.uni TC; return UNI_OPTION;
+
+\.sync TC; return SYNC_OPTION;
+\.arrive TC; return ARRIVE_OPTION;
+\.red TC; return RED_OPTION;
+
+
+\.approx TC; return APPROX_OPTION;
+\.full TC; return FULL_OPTION;
+
+\.any TC; return ANY_OPTION;
+\.all TC; return ALL_OPTION;
+\.ballot TC; return BALLOT_OPTION;
+\.gl TC; return GLOBAL_OPTION;
+\.cta TC; return CTA_OPTION;
+\.sys TC; return SYS_OPTION;
+
+\.exit TC; return EXIT_OPTION;
+
+\.abs TC; return ABS_OPTION;
+
+\.to TC; return TO_OPTION;
+
+\.ca TC; return CA_OPTION;
+\.cg TC; return CG_OPTION;
+\.cs TC; return CS_OPTION;
+\.lu TC; return LU_OPTION;
+\.cv TC; return CV_OPTION;
+
+\.wb TC; return WB_OPTION;
+\.wt TC; return WT_OPTION;
+
+\.nc TC; return NC_OPTION;
+
+\.up TC; return UP_OPTION;
+\.down TC; return DOWN_OPTION;
+\.bfly TC; return BFLY_OPTION;
+\.idx TC; return IDX_OPTION;
+
+\.popc TC; return ATOMIC_POPC;
+\.and TC; return ATOMIC_AND;
+\.or TC; return ATOMIC_OR;
+\.xor TC; return ATOMIC_XOR;
+\.cas TC; return ATOMIC_CAS;
+\.exch TC; return ATOMIC_EXCH;
+\.add TC; return ATOMIC_ADD;
+\.inc TC; return ATOMIC_INC;
+\.dec TC; return ATOMIC_DEC;
+\.min TC; return ATOMIC_MIN;
+\.max TC; return ATOMIC_MAX;
+
+
+
+\.1d TC; return GEOM_MODIFIER_1D;
+\.2d TC; return GEOM_MODIFIER_2D;
+\.3d TC; return GEOM_MODIFIER_3D;
+
+\.0 TC; ptx_lval.int_value = 0; return DIMENSION_MODIFIER;
+\.1 TC; ptx_lval.int_value = 1; return DIMENSION_MODIFIER;
+\.2 TC; ptx_lval.int_value = 2; return DIMENSION_MODIFIER;
+\.x TC; ptx_lval.int_value = 0; return DIMENSION_MODIFIER;
+\.y TC; ptx_lval.int_value = 1; return DIMENSION_MODIFIER;
+\.z TC; ptx_lval.int_value = 2; return DIMENSION_MODIFIER;
+
+"-" TC; return MINUS;
+"+" TC; return PLUS;
+"," TC; return COMMA;
+"@" TC; return PRED;
+"|" TC; return PIPE;
+"[" TC; return LEFT_SQUARE_BRACKET;
+"]" TC; return RIGHT_SQUARE_BRACKET;
+"<" TC; return LEFT_ANGLE_BRACKET;
+">" TC; return RIGHT_ANGLE_BRACKET;
+"(" TC; return LEFT_PAREN;
+")" TC; return RIGHT_PAREN;
+":" TC; BEGIN(INITIAL); return COLON;
+";" TC; BEGIN(INITIAL); return SEMI_COLON;
+"!" TC; return EXCLAMATION;
+"=" TC; return EQUALS;
+"}" TC; return RIGHT_BRACE;
+\. TC; return PERIOD;
+"/" TC; return BACKSLASH;
+
+"//"[^\n]* TC; // eat single
+
+\n.* col=0; strncpy(linebuf, yytext + 1, LINEBUF_SIZE); yyless( 1 );
+
+" " TC;
+"\t" TC;
+
+
+}
+
+<IN_FUNC_DECL>"{" TC; BEGIN(INITIAL); return LEFT_BRACE; // starting a statement block (allow next token to be parsed as an opcode)
+<INITIAL,NOT_OPCODE>"{" TC; return LEFT_BRACE; // starting a vector operand (next token cannot be opcode)
+
+<INITIAL>{
+"/*" BEGIN(IN_COMMENT);
+}
+<IN_COMMENT>{
+"*/" BEGIN(INITIAL);
+"CPTX_BEGIN" printf("BEGINNING CUSTOM PTX.\n"); BEGIN(INITIAL);
+[^C*\n]+ // eat comment in chunks
+"C" // eat the lone C
+"*" // eat the lone star
+\n TC;
+}
+
+<INITIAL>{
+"\"" BEGIN(IN_STRING);
+}
+<IN_STRING>{
+"\"" TC; BEGIN(INITIAL); return STRING;
+[^\"]* TC; ptx_lval.string_value = strdup(yytext);
+}
+
+<*>\t@@DWARF.*\n
+
+<INITIAL,NOT_OPCODE,IN_FUNC_DECL>. TC; ptx_error((const char*)NULL);
+%%
+
+extern int g_error_detected;
+extern const char *g_filename;
+
+int ptx_error( const char *s )
+{
+ int i;
+ g_error_detected = 1;
+ fflush(stdout);
+ if( s != NULL )
+ printf("%s:%u: Syntax error:\n\n", g_filename, ptx_lineno );
+ printf(" %s\n", linebuf );
+ printf(" ");
+ for( i=0; i < col-1; i++ ) {
+ if( linebuf[i] == '\t' ) printf("\t");
+ else printf(" ");
+ }
+
+ printf("^\n\n");
+ fflush(stdout);
+ //exit(1);
+ return 0;
+}
diff --git a/cuobjdump_to_ptxplus/ptx.y b/cuobjdump_to_ptxplus/ptx.y
new file mode 100644
index 0000000..45392fb
--- /dev/null
+++ b/cuobjdump_to_ptxplus/ptx.y
@@ -0,0 +1,629 @@
+/*
+Copyright (c) 2009-2011, Tor M. Aamodt
+The University of British Columbia
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+Neither the name of The University of British Columbia nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%union {
+ double double_value;
+ float float_value;
+ int int_value;
+ char * string_value;
+ void * ptr_value;
+}
+
+%token <string_value> STRING
+%token <int_value> OPCODE
+%token <int_value> WMMA_DIRECTIVE
+%token <int_value> LAYOUT
+%token <int_value> CONFIGURATION
+%token ALIGN_DIRECTIVE
+%token BRANCHTARGETS_DIRECTIVE
+%token BYTE_DIRECTIVE
+%token CALLPROTOTYPE_DIRECTIVE
+%token CALLTARGETS_DIRECTIVE
+%token <int_value> CONST_DIRECTIVE
+%token CONSTPTR_DIRECTIVE
+%token PTR_DIRECTIVE
+%token ENTRY_DIRECTIVE
+%token EXTERN_DIRECTIVE
+%token FILE_DIRECTIVE
+%token FUNC_DIRECTIVE
+%token GLOBAL_DIRECTIVE
+%token LOCAL_DIRECTIVE
+%token LOC_DIRECTIVE
+%token MAXNCTAPERSM_DIRECTIVE
+%token MAXNNREG_DIRECTIVE
+%token MAXNTID_DIRECTIVE
+%token MINNCTAPERSM_DIRECTIVE
+%token PARAM_DIRECTIVE
+%token PRAGMA_DIRECTIVE
+%token REG_DIRECTIVE
+%token REQNTID_DIRECTIVE
+%token SECTION_DIRECTIVE
+%token SHARED_DIRECTIVE
+%token SREG_DIRECTIVE
+%token SSTARR_DIRECTIVE
+%token STRUCT_DIRECTIVE
+%token SURF_DIRECTIVE
+%token TARGET_DIRECTIVE
+%token TEX_DIRECTIVE
+%token UNION_DIRECTIVE
+%token VERSION_DIRECTIVE
+%token ADDRESS_SIZE_DIRECTIVE
+%token VISIBLE_DIRECTIVE
+%token WEAK_DIRECTIVE
+%token <string_value> IDENTIFIER
+%token <int_value> INT_OPERAND
+%token <float_value> FLOAT_OPERAND
+%token <double_value> DOUBLE_OPERAND
+%token S8_TYPE
+%token S16_TYPE
+%token S32_TYPE
+%token S64_TYPE
+%token U8_TYPE
+%token U16_TYPE
+%token U32_TYPE
+%token U64_TYPE
+%token F16_TYPE
+%token F32_TYPE
+%token F64_TYPE
+%token FF64_TYPE
+%token B8_TYPE
+%token B16_TYPE
+%token B32_TYPE
+%token B64_TYPE
+%token BB64_TYPE
+%token BB128_TYPE
+%token PRED_TYPE
+%token TEXREF_TYPE
+%token SAMPLERREF_TYPE
+%token SURFREF_TYPE
+%token V2_TYPE
+%token V3_TYPE
+%token V4_TYPE
+%token COMMA
+%token PRED
+%token HALF_OPTION
+%token EXTP_OPTION
+%token EQ_OPTION
+%token NE_OPTION
+%token LT_OPTION
+%token LE_OPTION
+%token GT_OPTION
+%token GE_OPTION
+%token LO_OPTION
+%token LS_OPTION
+%token HI_OPTION
+%token HS_OPTION
+%token EQU_OPTION
+%token NEU_OPTION
+%token LTU_OPTION
+%token LEU_OPTION
+%token GTU_OPTION
+%token GEU_OPTION
+%token NUM_OPTION
+%token NAN_OPTION
+%token CF_OPTION
+%token SF_OPTION
+%token NSF_OPTION
+%token LEFT_SQUARE_BRACKET
+%token RIGHT_SQUARE_BRACKET
+%token WIDE_OPTION
+%token <int_value> SPECIAL_REGISTER
+%token MINUS
+%token PLUS
+%token COLON
+%token SEMI_COLON
+%token EXCLAMATION
+%token PIPE
+%token RIGHT_BRACE
+%token LEFT_BRACE
+%token EQUALS
+%token PERIOD
+%token BACKSLASH
+%token <int_value> DIMENSION_MODIFIER
+%token RN_OPTION
+%token RZ_OPTION
+%token RM_OPTION
+%token RP_OPTION
+%token RNI_OPTION
+%token RZI_OPTION
+%token RMI_OPTION
+%token RPI_OPTION
+%token UNI_OPTION
+%token GEOM_MODIFIER_1D
+%token GEOM_MODIFIER_2D
+%token GEOM_MODIFIER_3D
+%token SAT_OPTION
+%token FTZ_OPTION
+%token NEG_OPTION
+%token SYNC_OPTION
+%token RED_OPTION
+%token ARRIVE_OPTION
+%token ATOMIC_POPC
+%token ATOMIC_AND
+%token ATOMIC_OR
+%token ATOMIC_XOR
+%token ATOMIC_CAS
+%token ATOMIC_EXCH
+%token ATOMIC_ADD
+%token ATOMIC_INC
+%token ATOMIC_DEC
+%token ATOMIC_MIN
+%token ATOMIC_MAX
+%token LEFT_ANGLE_BRACKET
+%token RIGHT_ANGLE_BRACKET
+%token LEFT_PAREN
+%token RIGHT_PAREN
+%token APPROX_OPTION
+%token FULL_OPTION
+%token ANY_OPTION
+%token ALL_OPTION
+%token BALLOT_OPTION
+%token GLOBAL_OPTION
+%token CTA_OPTION
+%token SYS_OPTION
+%token EXIT_OPTION
+%token ABS_OPTION
+%token TO_OPTION
+%token CA_OPTION;
+%token CG_OPTION;
+%token CS_OPTION;
+%token LU_OPTION;
+%token CV_OPTION;
+%token WB_OPTION;
+%token WT_OPTION;
+%token NC_OPTION;
+%token UP_OPTION;
+%token DOWN_OPTION;
+%token BFLY_OPTION;
+%token IDX_OPTION;
+%token PRMT_F4E_MODE;
+%token PRMT_B4E_MODE;
+%token PRMT_RC8_MODE;
+%token PRMT_RC16_MODE;
+%token PRMT_ECL_MODE;
+%token PRMT_ECR_MODE;
+
+%type <int_value> function_decl_header
+%type <ptr_value> function_decl
+
+%{
+ #include "ptx_parser.h"
+ #include <stdlib.h>
+ #include <string.h>
+ #include <math.h>
+ void syntax_not_implemented();
+ extern int g_func_decl;
+ int ptx_lex(void);
+ int ptx_error(const char *);
+%}
+
+%%
+
+input: /* empty */
+ | input directive_statement
+ | input function_defn
+ | input function_decl
+ ;
+
+function_defn: function_decl { set_symtab($1); func_header(".skip"); } statement_block { end_function(); }
+ | function_decl { set_symtab($1); } block_spec_list { func_header(".skip"); } statement_block { end_function(); }
+ ;
+
+block_spec: MAXNTID_DIRECTIVE INT_OPERAND COMMA INT_OPERAND COMMA INT_OPERAND {func_header_info_int(".maxntid", $2);
+ func_header_info_int(",", $4);
+ func_header_info_int(",", $6);
+ maxnt_id($2, $4, $6);}
+ | MINNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".minnctapersm", $2); printf("GPGPU-Sim: Warning: .minnctapersm ignored. \n"); }
+ | MAXNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".maxnctapersm", $2); printf("GPGPU-Sim: Warning: .maxnctapersm ignored. \n"); }
+ ;
+
+block_spec_list: block_spec
+ | block_spec_list block_spec
+ ;
+
+function_decl: function_decl_header LEFT_PAREN { start_function($1); func_header_info("(");} param_entry RIGHT_PAREN {func_header_info(")");} function_ident_param { $$ = reset_symtab(); }
+ | function_decl_header { start_function($1); } function_ident_param { $$ = reset_symtab(); }
+ | function_decl_header { start_function($1); add_function_name(""); g_func_decl=0; $$ = reset_symtab(); }
+ ;
+
+function_ident_param: IDENTIFIER { add_function_name($1); } LEFT_PAREN {func_header_info("(");} param_list RIGHT_PAREN { g_func_decl=0; func_header_info(")"); }
+ | IDENTIFIER { add_function_name($1); g_func_decl=0; }
+ ;
+
+function_decl_header: ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
+ | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
+ | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
+ | FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; g_func_decl=1; func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+ ;
+
+param_list: /*empty*/
+ | param_entry { add_directive(); }
+ | param_list COMMA {func_header_info(",");} param_entry { add_directive(); }
+
+param_entry: PARAM_DIRECTIVE { add_space_spec(param_space_unclassified,0); } variable_spec ptr_spec identifier_spec { add_function_arg(); }
+ | REG_DIRECTIVE { add_space_spec(reg_space,0); } variable_spec identifier_spec { add_function_arg(); }
+
+ptr_spec: /*empty*/
+ | PTR_DIRECTIVE ptr_space_spec ptr_align_spec
+ | PTR_DIRECTIVE ptr_align_spec
+
+ptr_space_spec: GLOBAL_DIRECTIVE { add_ptr_spec(global_space); }
+ | LOCAL_DIRECTIVE { add_ptr_spec(local_space); }
+ | SHARED_DIRECTIVE { add_ptr_spec(shared_space); }
+ | CONST_DIRECTIVE { add_ptr_spec(global_space); }
+
+ptr_align_spec: ALIGN_DIRECTIVE INT_OPERAND
+
+statement_block: LEFT_BRACE statement_list RIGHT_BRACE
+
+statement_list: directive_statement { add_directive(); }
+ | instruction_statement { add_instruction(); }
+ | statement_list directive_statement { add_directive(); }
+ | statement_list instruction_statement { add_instruction(); }
+ | statement_list {start_inst_group();} statement_block {end_inst_group();}
+ | {start_inst_group();} statement_block {end_inst_group();}
+ ;
+
+directive_statement: variable_declaration SEMI_COLON
+ | VERSION_DIRECTIVE DOUBLE_OPERAND { add_version_info($2, 0); }
+ | VERSION_DIRECTIVE DOUBLE_OPERAND PLUS { add_version_info($2,1); }
+ | ADDRESS_SIZE_DIRECTIVE INT_OPERAND {/*Do nothing*/}
+ | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER { target_header2($2,$4); }
+ | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER { target_header3($2,$4,$6); }
+ | TARGET_DIRECTIVE IDENTIFIER { target_header($2); }
+ | FILE_DIRECTIVE INT_OPERAND STRING { add_file($2,$3); }
+ | FILE_DIRECTIVE INT_OPERAND STRING COMMA INT_OPERAND COMMA INT_OPERAND { add_file($2,$3); }
+ | LOC_DIRECTIVE INT_OPERAND INT_OPERAND INT_OPERAND
+ | PRAGMA_DIRECTIVE STRING SEMI_COLON { add_pragma($2); }
+ | function_decl SEMI_COLON {/*Do nothing*/}
+ ;
+
+variable_declaration: variable_spec identifier_list { add_variables(); }
+ | variable_spec identifier_spec EQUALS initializer_list { add_variables(); }
+ | variable_spec identifier_spec EQUALS literal_operand { add_variables(); }
+ | CONSTPTR_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA INT_OPERAND { add_constptr($2, $4, $6); }
+ ;
+
+variable_spec: var_spec_list { set_variable_type(); }
+
+identifier_list: identifier_spec
+ | identifier_list COMMA identifier_spec;
+
+identifier_spec: IDENTIFIER { add_identifier($1,0,NON_ARRAY_IDENTIFIER); func_header_info($1);}
+ | IDENTIFIER LEFT_ANGLE_BRACKET INT_OPERAND RIGHT_ANGLE_BRACKET { func_header_info($1); func_header_info_int("<", $3); func_header_info(">");
+ int i,lbase,l;
+ char *id = NULL;
+ lbase = strlen($1);
+ for( i=0; i < $3; i++ ) {
+ l = lbase + (int)log10(i+1)+10;
+ id = (char*) malloc(l);
+ snprintf(id,l,"%s%u",$1,i);
+ add_identifier(id,0,NON_ARRAY_IDENTIFIER);
+ }
+ free($1);
+ }
+ | IDENTIFIER LEFT_SQUARE_BRACKET RIGHT_SQUARE_BRACKET { add_identifier($1,0,ARRAY_IDENTIFIER_NO_DIM); func_header_info($1); func_header_info("["); func_header_info("]");}
+ | IDENTIFIER LEFT_SQUARE_BRACKET INT_OPERAND RIGHT_SQUARE_BRACKET { add_identifier($1,$3,ARRAY_IDENTIFIER); func_header_info($1); func_header_info_int("[",$3); func_header_info("]");}
+ ;
+
+var_spec_list: var_spec
+ | var_spec_list var_spec;
+
+var_spec: space_spec
+ | type_spec
+ | align_spec
+ | VISIBLE_DIRECTIVE
+ | EXTERN_DIRECTIVE { add_extern_spec(); }
+ | WEAK_DIRECTIVE
+ ;
+
+align_spec: ALIGN_DIRECTIVE INT_OPERAND { add_alignment_spec($2); }
+
+space_spec: REG_DIRECTIVE { add_space_spec(reg_space,0); }
+ | SREG_DIRECTIVE { add_space_spec(reg_space,0); }
+ | addressable_spec
+ ;
+
+addressable_spec: CONST_DIRECTIVE { add_space_spec(const_space,$1); }
+ | GLOBAL_DIRECTIVE { add_space_spec(global_space,0); }
+ | LOCAL_DIRECTIVE { add_space_spec(local_space,0); }
+ | PARAM_DIRECTIVE { add_space_spec(param_space_unclassified,0); }
+ | SHARED_DIRECTIVE { add_space_spec(shared_space,0); }
+ | SSTARR_DIRECTIVE { add_space_spec(sstarr_space,0); }
+ | SURF_DIRECTIVE { add_space_spec(surf_space,0); }
+ | TEX_DIRECTIVE { add_space_spec(tex_space,0); }
+ ;
+
+type_spec: scalar_type
+ | vector_spec scalar_type
+ ;
+
+vector_spec: V2_TYPE { add_option(V2_TYPE); func_header_info(".v2");}
+ | V3_TYPE { add_option(V3_TYPE); func_header_info(".v3");}
+ | V4_TYPE { add_option(V4_TYPE); func_header_info(".v4");}
+ ;
+
+scalar_type: S8_TYPE { add_scalar_type_spec( S8_TYPE ); }
+ | S16_TYPE { add_scalar_type_spec( S16_TYPE ); }
+ | S32_TYPE { add_scalar_type_spec( S32_TYPE ); }
+ | S64_TYPE { add_scalar_type_spec( S64_TYPE ); }
+ | U8_TYPE { add_scalar_type_spec( U8_TYPE ); }
+ | U16_TYPE { add_scalar_type_spec( U16_TYPE ); }
+ | U32_TYPE { add_scalar_type_spec( U32_TYPE ); }
+ | U64_TYPE { add_scalar_type_spec( U64_TYPE ); }
+ | F16_TYPE { add_scalar_type_spec( F16_TYPE ); }
+ | F32_TYPE { add_scalar_type_spec( F32_TYPE ); }
+ | F64_TYPE { add_scalar_type_spec( F64_TYPE ); }
+ | FF64_TYPE { add_scalar_type_spec( FF64_TYPE ); }
+ | B8_TYPE { add_scalar_type_spec( B8_TYPE ); }
+ | B16_TYPE { add_scalar_type_spec( B16_TYPE ); }
+ | B32_TYPE { add_scalar_type_spec( B32_TYPE ); }
+ | B64_TYPE { add_scalar_type_spec( B64_TYPE ); }
+ | BB64_TYPE { add_scalar_type_spec( BB64_TYPE ); }
+ | BB128_TYPE { add_scalar_type_spec( BB128_TYPE ); }
+ | PRED_TYPE { add_scalar_type_spec( PRED_TYPE ); }
+ | TEXREF_TYPE { add_scalar_type_spec( TEXREF_TYPE ); }
+ | SAMPLERREF_TYPE { add_scalar_type_spec( SAMPLERREF_TYPE ); }
+ | SURFREF_TYPE { add_scalar_type_spec( SURFREF_TYPE ); }
+ ;
+
+initializer_list: LEFT_BRACE literal_list RIGHT_BRACE { add_array_initializer(); }
+ | LEFT_BRACE initializer_list RIGHT_BRACE { syntax_not_implemented(); }
+
+literal_list: literal_operand
+ | literal_list COMMA literal_operand;
+
+instruction_statement: instruction SEMI_COLON
+ | IDENTIFIER COLON { add_label($1); }
+ | pred_spec instruction SEMI_COLON;
+
+instruction: opcode_spec LEFT_PAREN operand RIGHT_PAREN { set_return(); } COMMA operand COMMA LEFT_PAREN operand_list RIGHT_PAREN
+ | opcode_spec operand COMMA LEFT_PAREN operand_list RIGHT_PAREN
+ | opcode_spec operand COMMA LEFT_PAREN RIGHT_PAREN
+ | opcode_spec operand_list
+ | opcode_spec
+ ;
+
+opcode_spec: OPCODE { add_opcode($1); } option_list
+ | OPCODE { add_opcode($1); }
+
+pred_spec: PRED IDENTIFIER { add_pred($2,0, -1); }
+ | PRED EXCLAMATION IDENTIFIER { add_pred($3,1, -1); }
+ | PRED IDENTIFIER LT_OPTION { add_pred($2,0,1); }
+ | PRED IDENTIFIER EQ_OPTION { add_pred($2,0,2); }
+ | PRED IDENTIFIER LE_OPTION { add_pred($2,0,3); }
+ | PRED IDENTIFIER NE_OPTION { add_pred($2,0,5); }
+ | PRED IDENTIFIER GE_OPTION { add_pred($2,0,6); }
+ | PRED IDENTIFIER EQU_OPTION { add_pred($2,0,10); }
+ | PRED IDENTIFIER GTU_OPTION { add_pred($2,0,12); }
+ | PRED IDENTIFIER NEU_OPTION { add_pred($2,0,13); }
+ | PRED IDENTIFIER CF_OPTION { add_pred($2,0,17); }
+ | PRED IDENTIFIER SF_OPTION { add_pred($2,0,19); }
+ | PRED IDENTIFIER NSF_OPTION { add_pred($2,0,28); }
+ ;
+
+option_list: option
+ | option option_list ;
+
+option: type_spec
+ | compare_spec
+ | addressable_spec
+ | rounding_mode
+ | wmma_spec
+ | prmt_spec
+ | SYNC_OPTION { add_option(SYNC_OPTION); }
+ | ARRIVE_OPTION { add_option(ARRIVE_OPTION); }
+ | RED_OPTION { add_option(RED_OPTION); }
+ | UNI_OPTION { add_option(UNI_OPTION); }
+ | WIDE_OPTION { add_option(WIDE_OPTION); }
+ | ANY_OPTION { add_option(ANY_OPTION); }
+ | ALL_OPTION { add_option(ALL_OPTION); }
+ | BALLOT_OPTION { add_option(BALLOT_OPTION); }
+ | GLOBAL_OPTION { add_option(GLOBAL_OPTION); }
+ | CTA_OPTION { add_option(CTA_OPTION); }
+ | SYS_OPTION { add_option(SYS_OPTION); }
+ | GEOM_MODIFIER_1D { add_option(GEOM_MODIFIER_1D); }
+ | GEOM_MODIFIER_2D { add_option(GEOM_MODIFIER_2D); }
+ | GEOM_MODIFIER_3D { add_option(GEOM_MODIFIER_3D); }
+ | SAT_OPTION { add_option(SAT_OPTION); }
+ | FTZ_OPTION { add_option(FTZ_OPTION); }
+ | NEG_OPTION { add_option(NEG_OPTION); }
+ | APPROX_OPTION { add_option(APPROX_OPTION); }
+ | FULL_OPTION { add_option(FULL_OPTION); }
+ | EXIT_OPTION { add_option(EXIT_OPTION); }
+ | ABS_OPTION { add_option(ABS_OPTION); }
+ | atomic_operation_spec ;
+ | TO_OPTION { add_option(TO_OPTION); }
+ | HALF_OPTION { add_option(HALF_OPTION); }
+ | EXTP_OPTION { add_option(EXTP_OPTION); }
+ | CA_OPTION { add_option(CA_OPTION); }
+ | CG_OPTION { add_option(CG_OPTION); }
+ | CS_OPTION { add_option(CS_OPTION); }
+ | LU_OPTION { add_option(LU_OPTION); }
+ | CV_OPTION { add_option(CV_OPTION); }
+ | WB_OPTION { add_option(WB_OPTION); }
+ | WT_OPTION { add_option(WT_OPTION); }
+ | NC_OPTION { add_option(NC_OPTION); }
+ | UP_OPTION { add_option(UP_OPTION); }
+ | DOWN_OPTION { add_option(DOWN_OPTION); }
+ | BFLY_OPTION { add_option(BFLY_OPTION); }
+ | IDX_OPTION { add_option(IDX_OPTION); }
+ ;
+
+atomic_operation_spec: ATOMIC_AND { add_option(ATOMIC_AND); }
+ | ATOMIC_POPC { add_option(ATOMIC_POPC); }
+ | ATOMIC_OR { add_option(ATOMIC_OR); }
+ | ATOMIC_XOR { add_option(ATOMIC_XOR); }
+ | ATOMIC_CAS { add_option(ATOMIC_CAS); }
+ | ATOMIC_EXCH { add_option(ATOMIC_EXCH); }
+ | ATOMIC_ADD { add_option(ATOMIC_ADD); }
+ | ATOMIC_INC { add_option(ATOMIC_INC); }
+ | ATOMIC_DEC { add_option(ATOMIC_DEC); }
+ | ATOMIC_MIN { add_option(ATOMIC_MIN); }
+ | ATOMIC_MAX { add_option(ATOMIC_MAX); }
+ ;
+
+rounding_mode: floating_point_rounding_mode
+ | integer_rounding_mode;
+
+
+floating_point_rounding_mode: RN_OPTION { add_option(RN_OPTION); }
+ | RZ_OPTION { add_option(RZ_OPTION); }
+ | RM_OPTION { add_option(RM_OPTION); }
+ | RP_OPTION { add_option(RP_OPTION); }
+ ;
+
+integer_rounding_mode: RNI_OPTION { add_option(RNI_OPTION); }
+ | RZI_OPTION { add_option(RZI_OPTION); }
+ | RMI_OPTION { add_option(RMI_OPTION); }
+ | RPI_OPTION { add_option(RPI_OPTION); }
+ ;
+
+compare_spec:EQ_OPTION { add_option(EQ_OPTION); }
+ | NE_OPTION { add_option(NE_OPTION); }
+ | LT_OPTION { add_option(LT_OPTION); }
+ | LE_OPTION { add_option(LE_OPTION); }
+ | GT_OPTION { add_option(GT_OPTION); }
+ | GE_OPTION { add_option(GE_OPTION); }
+ | LO_OPTION { add_option(LO_OPTION); }
+ | LS_OPTION { add_option(LS_OPTION); }
+ | HI_OPTION { add_option(HI_OPTION); }
+ | HS_OPTION { add_option(HS_OPTION); }
+ | EQU_OPTION { add_option(EQU_OPTION); }
+ | NEU_OPTION { add_option(NEU_OPTION); }
+ | LTU_OPTION { add_option(LTU_OPTION); }
+ | LEU_OPTION { add_option(LEU_OPTION); }
+ | GTU_OPTION { add_option(GTU_OPTION); }
+ | GEU_OPTION { add_option(GEU_OPTION); }
+ | NUM_OPTION { add_option(NUM_OPTION); }
+ | NAN_OPTION { add_option(NAN_OPTION); }
+ ;
+
+prmt_spec: PRMT_F4E_MODE { add_option( PRMT_F4E_MODE); }
+ | PRMT_B4E_MODE { add_option( PRMT_B4E_MODE); }
+ | PRMT_RC8_MODE { add_option( PRMT_RC8_MODE); }
+ | PRMT_RC16_MODE{ add_option( PRMT_RC16_MODE);}
+ | PRMT_ECL_MODE { add_option( PRMT_ECL_MODE); }
+ | PRMT_ECR_MODE { add_option( PRMT_ECR_MODE); }
+ ;
+
+wmma_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ptr_spec(global_space); add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);}
+ | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);add_wmma_option($4);}
+ ;
+
+vp_spec: WMMA_DIRECTIVE LAYOUT CONFIGURATION{add_space_spec(global_space,0);add_ptr_spec(global_space);add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);}
+ | WMMA_DIRECTIVE LAYOUT LAYOUT CONFIGURATION{add_wmma_option($1);add_wmma_option($2);add_wmma_option($3);add_wmma_option($4);}
+ ;
+
+
+
+operand_list: operand
+ | operand COMMA operand_list;
+
+operand: IDENTIFIER { add_scalar_operand( $1 ); }
+ | EXCLAMATION IDENTIFIER { add_neg_pred_operand( $2 ); }
+ | MINUS IDENTIFIER { add_scalar_operand( $2 ); change_operand_neg(); }
+ | memory_operand
+ | literal_operand
+ | builtin_operand
+ | vector_operand
+ | MINUS vector_operand { change_operand_neg(); }
+ | tex_operand
+ | IDENTIFIER PLUS INT_OPERAND { add_address_operand($1,$3); }
+ | IDENTIFIER LO_OPTION { add_scalar_operand( $1 ); change_operand_lohi(1);}
+ | MINUS IDENTIFIER LO_OPTION { add_scalar_operand( $2 ); change_operand_lohi(1); change_operand_neg();}
+ | IDENTIFIER HI_OPTION { add_scalar_operand( $1 ); change_operand_lohi(2);}
+ | MINUS IDENTIFIER HI_OPTION { add_scalar_operand( $2 ); change_operand_lohi(2); change_operand_neg();}
+ | IDENTIFIER PIPE IDENTIFIER { add_2vector_operand($1,$3); change_double_operand_type(-1);}
+ | IDENTIFIER PIPE IDENTIFIER LO_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-1); change_operand_lohi(1);}
+ | IDENTIFIER PIPE IDENTIFIER HI_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-1); change_operand_lohi(2);}
+ | IDENTIFIER BACKSLASH IDENTIFIER { add_2vector_operand($1,$3); change_double_operand_type(-3);}
+ | IDENTIFIER BACKSLASH IDENTIFIER LO_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-3); change_operand_lohi(1);}
+ | IDENTIFIER BACKSLASH IDENTIFIER HI_OPTION { add_2vector_operand($1,$3); change_double_operand_type(-3); change_operand_lohi(2);}
+ ;
+
+vector_operand: LEFT_BRACE IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_2vector_operand($2,$4); }
+ | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_3vector_operand($2,$4,$6); }
+ | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_4vector_operand($2,$4,$6,$8); }
+ | LEFT_BRACE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER RIGHT_BRACE { add_8vector_operand($2,$4,$6,$8,$10,$12,$14,$16); }
+ | LEFT_BRACE IDENTIFIER RIGHT_BRACE { add_1vector_operand($2); }
+ ;
+
+tex_operand: LEFT_SQUARE_BRACKET IDENTIFIER COMMA { add_scalar_operand($2); }
+ vector_operand
+ RIGHT_SQUARE_BRACKET
+ ;
+
+builtin_operand: SPECIAL_REGISTER DIMENSION_MODIFIER { add_builtin_operand($1,$2); }
+ | SPECIAL_REGISTER { add_builtin_operand($1,-1); }
+ ;
+
+memory_operand : LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { add_memory_operand(); }
+ | IDENTIFIER LEFT_SQUARE_BRACKET address_expression RIGHT_SQUARE_BRACKET { add_memory_operand(); change_memory_addr_space($1); }
+ | IDENTIFIER LEFT_SQUARE_BRACKET literal_operand RIGHT_SQUARE_BRACKET { change_memory_addr_space($1); }
+ | IDENTIFIER LEFT_SQUARE_BRACKET twin_operand RIGHT_SQUARE_BRACKET { change_memory_addr_space($1); add_memory_operand();}
+ | MINUS memory_operand { change_operand_neg(); }
+ ;
+
+twin_operand : IDENTIFIER PLUS IDENTIFIER { add_double_operand($1,$3); change_double_operand_type(1); }
+ | IDENTIFIER PLUS IDENTIFIER LO_OPTION { add_double_operand($1,$3); change_double_operand_type(1); change_operand_lohi(1); }
+ | IDENTIFIER PLUS IDENTIFIER HI_OPTION { add_double_operand($1,$3); change_double_operand_type(1); change_operand_lohi(2); }
+ | IDENTIFIER PLUS EQUALS IDENTIFIER { add_double_operand($1,$4); change_double_operand_type(2); }
+ | IDENTIFIER PLUS EQUALS IDENTIFIER LO_OPTION { add_double_operand($1,$4); change_double_operand_type(2); change_operand_lohi(1); }
+ | IDENTIFIER PLUS EQUALS IDENTIFIER HI_OPTION { add_double_operand($1,$4); change_double_operand_type(2); change_operand_lohi(2); }
+ | IDENTIFIER PLUS EQUALS INT_OPERAND { add_address_operand($1,$4); change_double_operand_type(3); }
+ ;
+
+literal_operand : INT_OPERAND { add_literal_int($1); }
+ | FLOAT_OPERAND { add_literal_float($1); }
+ | DOUBLE_OPERAND { add_literal_double($1); }
+ ;
+
+address_expression: IDENTIFIER { add_address_operand($1,0); }
+ | IDENTIFIER LO_OPTION { add_address_operand($1,0); change_operand_lohi(1);}
+ | IDENTIFIER HI_OPTION { add_address_operand($1,0); change_operand_lohi(2); }
+ | IDENTIFIER PLUS INT_OPERAND { add_address_operand($1,$3); }
+ | INT_OPERAND { add_address_operand2($1); }
+ ;
+
+%%
+
+extern int ptx_lineno;
+extern const char *g_filename;
+
+void syntax_not_implemented()
+{
+ printf("Parse error (%s:%u): this syntax is not (yet) implemented:\n",g_filename,ptx_lineno);
+ ptx_error(NULL);
+ abort();
+}
diff --git a/libcuda/Makefile b/libcuda/Makefile
index 13932e2..c8ff2e3 100644
--- a/libcuda/Makefile
+++ b/libcuda/Makefile
@@ -111,10 +111,10 @@ $(OUTPUT_DIR)/%.o: %.cc
$(CPP) $(CXXFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@
$(OUTPUT_DIR)/%.o: %.c
- $(CC) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@
+ $(CPP) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@
$(OUTPUT_DIR)/%.o: $(OUTPUT_DIR)/%.c
- $(CC) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@
+ $(CPP) $(CCFLAGS) -I./ -I$(OUTPUT_DIR) -I$(CUDA_INSTALL_PATH)/include -c $< -o $@
$(OUTPUT_DIR)/cuobjdump_parser.c: cuobjdump.y
$(YACC) $(YFLAGS) -p cuobjdump_ -o$@ $< --file-prefix=$(OUTPUT_DIR)/cuobjdump
diff --git a/libcuda/cuda_runtime_api.cc b/libcuda/cuda_runtime_api.cc
index 11dcd5a..fcd5b07 100644
--- a/libcuda/cuda_runtime_api.cc
+++ b/libcuda/cuda_runtime_api.cc
@@ -139,6 +139,8 @@
#include "../src/gpgpusim_entrypoint.h"
#include "../src/stream_manager.h"
#include "../src/abstract_hardware_model.h"
+typedef void * yyscan_t;
+#include "cuobjdump.h"
#include <pthread.h>
#include <semaphore.h>
@@ -147,12 +149,6 @@
#include <mach-o/dyld.h>
#endif
-std::map<void *,void **> pinned_memory; //support for pinned memories added
-std::map<void *, size_t> pinned_memory_size;
-std::map<unsigned long long, size_t> g_mallocPtr_Size;
-int no_of_ptx=0;
-//maps sm version number to set of filenames
-std::map<unsigned, std::set<std::string> > version_filename;
extern void synchronize();
extern void exit_simulation();
@@ -239,12 +235,27 @@ private:
struct _cuda_device_id *m_next;
};
+class kernel_config;
+
+#ifndef OPENGL_SUPPORT
+typedef unsigned long GLuint;
+#endif
+
+struct glbmap_entry {
+ GLuint m_bufferObj;
+ void *m_devPtr;
+ size_t m_size;
+ struct glbmap_entry *m_next;
+};
+
struct CUctx_st {
CUctx_st( _cuda_device_id *gpu )
{
m_gpu = gpu;
m_binary_info.cmem = 0;
m_binary_info.gmem = 0;
+ no_of_ptx=0;
+ g_glbmap = NULL;
}
_cuda_device_id *get_device() { return m_gpu; }
@@ -302,6 +313,22 @@ struct CUctx_st {
return i->second;
}
+ std::list<cuobjdumpSection*> cuobjdumpSectionList;
+ std::list<cuobjdumpSection*> libSectionList;
+ //maps sm version number to set of filenames
+ std::map<unsigned, std::set<std::string> > version_filename;
+ std::list<kernel_config> g_cuda_launch_stack;
+ std::map<int, bool>fatbin_registered;
+ std::map<int, std::string> fatbinmap;
+ std::map<unsigned long long, size_t> g_mallocPtr_Size;
+ std::map<std::string, symbol_table*> name_symtab;
+ std::map<void *,void **> pinned_memory; //support for pinned memories added
+ std::map<void *, size_t> pinned_memory_size;
+ int no_of_ptx;
+ typedef struct glbmap_entry glbmap_entry_t;
+
+ glbmap_entry_t* g_glbmap;
+
private:
_cuda_device_id *m_gpu; // selected gpu
std::map<unsigned,symbol_table*> m_code; // fat binary handle => global symbol table
@@ -481,7 +508,62 @@ typedef std::map<unsigned,CUevent_st*> event_tracker_t;
int CUevent_st::m_next_event_uid;
event_tracker_t g_timer_events;
int g_active_device = 0; //active gpu that runs the code
-std::list<kernel_config> g_cuda_launch_stack;
+
+extern int cuobjdump_lex_init(yyscan_t* scanner);
+extern void cuobjdump_set_in (FILE * _in_str ,yyscan_t yyscanner );
+extern int cuobjdump_parse(yyscan_t scanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
+extern int cuobjdump_lex_destroy(yyscan_t scanner);
+
+enum cuobjdumpSectionType {
+ PTXSECTION=0,
+ ELFSECTION
+};
+
+
+// sectiontype: 0 for ptx, 1 for elf
+void addCuobjdumpSection(int sectiontype, std::list<cuobjdumpSection*> &cuobjdumpSectionList){
+ if (sectiontype)
+ cuobjdumpSectionList.push_front(new cuobjdumpELFSection());
+ else
+ cuobjdumpSectionList.push_front(new cuobjdumpPTXSection());
+ printf("## Adding new section %s\n", sectiontype?"ELF":"PTX");
+}
+
+void setCuobjdumparch(const char* arch, std::list<cuobjdumpSection*> &cuobjdumpSectionList){
+ unsigned archnum;
+ sscanf(arch, "sm_%u", &archnum);
+ assert (archnum && "cannot have sm_0");
+ printf("Adding arch: %s\n", arch);
+ cuobjdumpSectionList.front()->setArch(archnum);
+}
+
+void setCuobjdumpidentifier(const char* identifier, std::list<cuobjdumpSection*> &cuobjdumpSectionList){
+ printf("Adding identifier: %s\n", identifier);
+ cuobjdumpSectionList.front()->setIdentifier(identifier);
+}
+
+void setCuobjdumpptxfilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList){
+ printf("Adding ptx filename: %s\n", filename);
+ cuobjdumpSection* x = cuobjdumpSectionList.front();
+ if (dynamic_cast<cuobjdumpPTXSection*>(x) == NULL){
+ assert (0 && "You shouldn't be trying to add a ptxfilename to an elf section");
+ }
+ (dynamic_cast<cuobjdumpPTXSection*>(x))->setPTXfilename(filename);
+}
+
+void setCuobjdumpelffilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList){
+ if (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()) == NULL){
+ assert (0 && "You shouldn't be trying to add a elffilename to an ptx section");
+ }
+ (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()))->setELFfilename(filename);
+}
+
+void setCuobjdumpsassfilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList){
+ if (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()) == NULL){
+ assert (0 && "You shouldn't be trying to add a sassfilename to an ptx section");
+ }
+ (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()))->setSASSfilename(filename);
+}
/*******************************************************************************
* *
@@ -510,7 +592,7 @@ __host__ cudaError_t CUDARTAPI cudaMalloc(void **devPtr, size_t size)
*devPtr = context->get_device()->get_gpgpu()->gpu_malloc(size);
if(g_debug_execution >= 3){
printf("GPGPU-Sim PTX: cudaMallocing %zu bytes starting at 0x%llx..\n",size, (unsigned long long) *devPtr);
- g_mallocPtr_Size[(unsigned long long)*devPtr] = size;
+ context->g_mallocPtr_Size[(unsigned long long)*devPtr] = size;
}
if ( *devPtr ) {
return g_last_cudaError = cudaSuccess;
@@ -524,11 +606,11 @@ __host__ cudaError_t CUDARTAPI cudaMallocHost(void **ptr, size_t size)
if(g_debug_execution >= 3){
announce_call(__my_func__);
}
- GPGPUSim_Context();
+ CUctx_st* context = GPGPUSim_Context();
*ptr = malloc(size);
if ( *ptr ) {
//track pinned memory size allocated in the host so that same amount of memory is also allocated in GPU.
- pinned_memory_size[*ptr]=size;
+ context->pinned_memory_size[*ptr]=size;
return g_last_cudaError = cudaSuccess;
} else {
return g_last_cudaError = cudaErrorMemoryAllocation;
@@ -1444,7 +1526,8 @@ __host__ cudaError_t CUDARTAPI cudaConfigureCall(dim3 gridDim, dim3 blockDim, si
announce_call(__my_func__);
}
struct CUstream_st *s = (struct CUstream_st *)stream;
- g_cuda_launch_stack.push_back( kernel_config(gridDim,blockDim,sharedMem,s) );
+ CUctx_st *context = GPGPUSim_Context();
+ context->g_cuda_launch_stack.push_back( kernel_config(gridDim,blockDim,sharedMem,s) );
return g_last_cudaError = cudaSuccess;
}
@@ -1453,8 +1536,9 @@ __host__ cudaError_t CUDARTAPI cudaSetupArgument(const void *arg, size_t size, s
if(g_debug_execution >= 3){
announce_call(__my_func__);
}
- gpgpusim_ptx_assert( !g_cuda_launch_stack.empty(), "empty launch stack" );
- kernel_config &config = g_cuda_launch_stack.back();
+ CUctx_st *context = GPGPUSim_Context();
+ gpgpusim_ptx_assert( !context->g_cuda_launch_stack.empty(), "empty launch stack" );
+ kernel_config &config = context->g_cuda_launch_stack.back();
config.set_arg(arg,size,offset);
printf("GPGPU-Sim PTX: Setting up arguments for %zu bytes starting at 0x%llx..\n",size, (unsigned long long) arg);
@@ -1471,8 +1555,8 @@ __host__ cudaError_t CUDARTAPI cudaLaunch( const char *hostFun )
char *mode = getenv("PTX_SIM_MODE_FUNC");
if( mode )
sscanf(mode,"%u", &g_ptx_sim_mode);
- gpgpusim_ptx_assert( !g_cuda_launch_stack.empty(), "empty launch stack" );
- kernel_config config = g_cuda_launch_stack.back();
+ gpgpusim_ptx_assert( !context->g_cuda_launch_stack.empty(), "empty launch stack" );
+ kernel_config config = context->g_cuda_launch_stack.back();
struct CUstream_st *stream = config.get_stream();
printf("\nGPGPU-Sim PTX: cudaLaunch for 0x%p (mode=%s) on stream %u\n", hostFun,
g_ptx_sim_mode?"functional simulation":"performance simulation", stream?stream->get_uid():0 );
@@ -1513,14 +1597,14 @@ __host__ cudaError_t CUDARTAPI cudaLaunch( const char *hostFun )
g_checkpoint->load_global_mem(global_mem, f1name);
printf("Skipping kernel %d as resuming from kernel %d\n",grid->get_uid(),gpu->resume_kernel );
- g_cuda_launch_stack.pop_back();
+ context->g_cuda_launch_stack.pop_back();
return g_last_cudaError = cudaSuccess;
}
if(gpu->checkpoint_option==1 && (grid->get_uid()>gpu->checkpoint_kernel))
{
printf("Skipping kernel %d as checkpoint from kernel %d\n",grid->get_uid(),gpu->checkpoint_kernel );
- g_cuda_launch_stack.pop_back();
+ context->g_cuda_launch_stack.pop_back();
return g_last_cudaError = cudaSuccess;
}
@@ -1528,7 +1612,7 @@ __host__ cudaError_t CUDARTAPI cudaLaunch( const char *hostFun )
kname.c_str(), stream?stream->get_uid():0, gridDim.x,gridDim.y,gridDim.z,blockDim.x,blockDim.y,blockDim.z );
stream_operation op(grid,g_ptx_sim_mode,stream);
g_stream_manager->push(op);
- g_cuda_launch_stack.pop_back();
+ context->g_cuda_launch_stack.pop_back();
return g_last_cudaError = cudaSuccess;
}
@@ -1856,127 +1940,6 @@ __host__ cudaError_t CUDARTAPI cudaGetExportTable(const void **ppExportTable, co
//#include "../../cuobjdump_to_ptxplus/cuobjdump_parser.h"
-enum cuobjdumpSectionType {
- PTXSECTION=0,
- ELFSECTION
-};
-
-
-class cuobjdumpSection {
-public:
- //Constructor
- cuobjdumpSection() {
- arch = 0;
- identifier = "";
- }
- virtual ~cuobjdumpSection() {}
- unsigned getArch() {return arch;}
- void setArch(unsigned a) {arch = a;}
- std::string getIdentifier() {return identifier;}
- void setIdentifier(std::string i) {identifier = i;}
- virtual void print(){std::cout << "cuobjdump Section: unknown type" << std::endl;}
-private:
- unsigned arch;
- std::string identifier;
-};
-
-class cuobjdumpELFSection : public cuobjdumpSection
-{
-public:
- cuobjdumpELFSection() {}
- virtual ~cuobjdumpELFSection() {
- elffilename = "";
- sassfilename = "";
- }
- std::string getELFfilename() {return elffilename;}
- void setELFfilename(std::string f) {elffilename = f;}
- std::string getSASSfilename() {return sassfilename;}
- void setSASSfilename(std::string f) {sassfilename = f;}
- virtual void print() {
- std::cout << "ELF Section:" << std::endl;
- std::cout << "arch: sm_" << getArch() << std::endl;
- std::cout << "identifier: " << getIdentifier() << std::endl;
- std::cout << "elf filename: " << getELFfilename() << std::endl;
- std::cout << "sass filename: " << getSASSfilename() << std::endl;
- std::cout << std::endl;
- }
-private:
- std::string elffilename;
- std::string sassfilename;
-};
-
-class cuobjdumpPTXSection : public cuobjdumpSection
-{
-public:
- cuobjdumpPTXSection(){
- ptxfilename = "";
- }
- std::string getPTXfilename() {return ptxfilename;}
- void setPTXfilename(std::string f) {ptxfilename = f;}
- virtual void print() {
- std::cout << "PTX Section:" << std::endl;
- std::cout << "arch: sm_" << getArch() << std::endl;
- std::cout << "identifier: " << getIdentifier() << std::endl;
- std::cout << "ptx filename: " << getPTXfilename() << std::endl;
- std::cout << std::endl;
- }
-private:
- std::string ptxfilename;
-};
-
-std::list<cuobjdumpSection*> cuobjdumpSectionList;
-std::list<cuobjdumpSection*> libSectionList;
-
-// sectiontype: 0 for ptx, 1 for elf
-void addCuobjdumpSection(int sectiontype){
- if (sectiontype)
- cuobjdumpSectionList.push_front(new cuobjdumpELFSection());
- else
- cuobjdumpSectionList.push_front(new cuobjdumpPTXSection());
- printf("## Adding new section %s\n", sectiontype?"ELF":"PTX");
-}
-
-void setCuobjdumparch(const char* arch){
- unsigned archnum;
- sscanf(arch, "sm_%u", &archnum);
- assert (archnum && "cannot have sm_0");
- printf("Adding arch: %s\n", arch);
- cuobjdumpSectionList.front()->setArch(archnum);
-}
-
-void setCuobjdumpidentifier(const char* identifier){
- printf("Adding identifier: %s\n", identifier);
- cuobjdumpSectionList.front()->setIdentifier(identifier);
-}
-
-void setCuobjdumpptxfilename(const char* filename){
- printf("Adding ptx filename: %s\n", filename);
- cuobjdumpSection* x = cuobjdumpSectionList.front();
- if (dynamic_cast<cuobjdumpPTXSection*>(x) == NULL){
- assert (0 && "You shouldn't be trying to add a ptxfilename to an elf section");
- }
- (dynamic_cast<cuobjdumpPTXSection*>(x))->setPTXfilename(filename);
-}
-
-void setCuobjdumpelffilename(const char* filename){
- if (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()) == NULL){
- assert (0 && "You shouldn't be trying to add a elffilename to an ptx section");
- }
- (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()))->setELFfilename(filename);
-}
-
-void setCuobjdumpsassfilename(const char* filename){
- if (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()) == NULL){
- assert (0 && "You shouldn't be trying to add a sassfilename to an ptx section");
- }
- (dynamic_cast<cuobjdumpELFSection*>(cuobjdumpSectionList.front()))->setSASSfilename(filename);
-}
-typedef void * yyscan_t;
-extern int cuobjdump_lex_init(yyscan_t* scanner);
-extern void cuobjdump_set_in (FILE * _in_str ,yyscan_t yyscanner );
-extern int cuobjdump_parse(yyscan_t scanner);
-extern int cuobjdump_lex_destroy(yyscan_t scanner);
-
//! Return the executable file of the process containing the PTX/SASS code
//!
//! This Function returns the executable file ran by the process. This
@@ -2029,7 +1992,7 @@ char* get_app_binary_name(std::string abs_path){
}
//extracts all ptx files from binary and dumps into prog_name.unique_no.sm_<>.ptx files
-void extract_ptx_files_using_cuobjdump(){
+void extract_ptx_files_using_cuobjdump(CUctx_st *context){
extern bool g_cdp_enabled;
char command[1000];
char *pytorch_bin = getenv("PYTORCH_BIN");
@@ -2066,11 +2029,11 @@ void extract_ptx_files_using_cuobjdump(){
printf("ERROR: command: %s failed \n",command);
exit(0);
}
- no_of_ptx++;
+ context->no_of_ptx++;
}
}
- if(!no_of_ptx){
+ if(!context->no_of_ptx){
printf("WARNING: Number of ptx in the executable file are 0. One of the reasons might be\n");
printf("\t1. CDP is enabled\n");
printf("\t2. When using PyTorch, PYTORCH_BIN is not set correctly\n");
@@ -2090,10 +2053,10 @@ void extract_ptx_files_using_cuobjdump(){
}
std::string vstr = line.substr(pos1+3,pos2-pos1-3);
int version = atoi(vstr.c_str());
- if (version_filename.find(version)==version_filename.end()){
- version_filename[version] = std::set<std::string>();
+ if (context->version_filename.find(version)==context->version_filename.end()){
+ context->version_filename[version] = std::set<std::string>();
}
- version_filename[version].insert(line);
+ context->version_filename[version].insert(line);
}
}
@@ -2129,7 +2092,7 @@ static int get_app_cuda_version() {
* It is also responsible for extracting the libraries linked to the binary if the option is
* enabled
* */
-void extract_code_using_cuobjdump(){
+void extract_code_using_cuobjdump(std::list<cuobjdumpSection*> &cuobjdumpSectionList){
CUctx_st *context = GPGPUSim_Context();
unsigned forced_max_capability = context->get_device()->get_gpgpu()->get_config().get_forced_max_capability();
@@ -2151,7 +2114,7 @@ void extract_code_using_cuobjdump(){
//dump ptx for all individial ptx files into sepearte files which is later used by ptxas.
int result=0;
#if (CUDART_VERSION >= 6000)
- extract_ptx_files_using_cuobjdump();
+ extract_ptx_files_using_cuobjdump(context);
return;
#endif
//TODO: redundant to dump twice. how can it be prevented?
@@ -2187,11 +2150,13 @@ void extract_code_using_cuobjdump(){
FILE *cuobjdump_in;
cuobjdump_in = fopen(fname, "r");
- yyscan_t scanner;
- cuobjdump_lex_init(&scanner);
- cuobjdump_set_in(cuobjdump_in, scanner);
- cuobjdump_parse(scanner);
- cuobjdump_lex_destroy(scanner);
+ struct cuobjdump_parser parser;
+ parser.elfserial = 1;
+ parser.ptxserial = 1;
+ cuobjdump_lex_init(&(parser.scanner));
+ cuobjdump_set_in(cuobjdump_in, (parser.scanner));
+ cuobjdump_parse(parser.scanner, &parser, cuobjdumpSectionList);
+ cuobjdump_lex_destroy(parser.scanner);
fclose(cuobjdump_in);
printf("Done parsing!!!\n");
} else {
@@ -2241,15 +2206,17 @@ void extract_code_using_cuobjdump(){
std::cout << "Trying to parse " << libcodfn.str() << std::endl;
FILE *cuobjdump_in;
cuobjdump_in = fopen(libcodfn.str().c_str(), "r");
- yyscan_t scanner;
- cuobjdump_lex_init(&scanner);
- cuobjdump_set_in(cuobjdump_in, scanner);
- cuobjdump_parse(scanner);
- cuobjdump_lex_destroy(scanner);
+ struct cuobjdump_parser parser;
+ parser.elfserial = 1;
+ parser.ptxserial = 1;
+ cuobjdump_lex_init(&(parser.scanner));
+ cuobjdump_set_in(cuobjdump_in, (parser.scanner));
+ cuobjdump_parse(parser.scanner, &parser, cuobjdumpSectionList);
+ cuobjdump_lex_destroy(parser.scanner);
fclose(cuobjdump_in);
std::getline(libsf, line);
}
- libSectionList = cuobjdumpSectionList;
+ context->libSectionList = cuobjdumpSectionList;
//Restore the original section list
cuobjdumpSectionList = tmpsl;
@@ -2438,7 +2405,7 @@ cuobjdumpELFSection* findELFSectionInList(std::list<cuobjdumpSection*> sectionli
}
//! Find an ELF section in all the known lists
-cuobjdumpELFSection* findELFSection(const std::string identifier){
+cuobjdumpELFSection* findELFSection(const std::string identifier, std::list<cuobjdumpSection*> cuobjdumpSectionList, std::list<cuobjdumpSection*> &libSectionList){
cuobjdumpELFSection* sec = findELFSectionInList(cuobjdumpSectionList, identifier);
if (sec!=NULL)return sec;
sec = findELFSectionInList(libSectionList, identifier);
@@ -2473,7 +2440,7 @@ cuobjdumpPTXSection* findPTXSectionInList(std::list<cuobjdumpSection*> sectionli
}
//! Find an PTX section in all the known lists
-cuobjdumpPTXSection* findPTXSection(const std::string identifier){
+cuobjdumpPTXSection* findPTXSection(const std::string identifier, std::list<cuobjdumpSection*> cuobjdumpSectionList, std::list<cuobjdumpSection*> &libSectionList){
cuobjdumpPTXSection* sec = findPTXSectionInList(cuobjdumpSectionList, identifier);
if (sec!=NULL)return sec;
sec = findPTXSectionInList(libSectionList, identifier);
@@ -2486,9 +2453,9 @@ cuobjdumpPTXSection* findPTXSection(const std::string identifier){
//! Extract the code using cuobjdump and remove unnecessary sections
-void cuobjdumpInit(){
+void cuobjdumpInit(std::list<cuobjdumpSection*> &cuobjdumpSectionList){
CUctx_st *context = GPGPUSim_Context();
- extract_code_using_cuobjdump(); //extract all the output of cuobjdump to _cuobjdump_*.*
+ extract_code_using_cuobjdump(cuobjdumpSectionList); //extract all the output of cuobjdump to _cuobjdump_*.*
const char* pre_load = getenv("CUOBJDUMP_SIM_FILE");
if (pre_load ==NULL || strlen(pre_load)==0){
cuobjdumpSectionList = pruneSectionList(cuobjdumpSectionList, context);
@@ -2496,25 +2463,22 @@ void cuobjdumpInit(){
}
}
-std::map<int, std::string> fatbinmap;
-std::map<int, bool>fatbin_registered;
-std::map<std::string, symbol_table*> name_symtab;
//! Keep track of the association between filename and cubin handle
-void cuobjdumpRegisterFatBinary(unsigned int handle, const char* filename){
- fatbinmap[handle] = filename;
+void cuobjdumpRegisterFatBinary(unsigned int handle, const char* filename, CUctx_st *context){
+ context->fatbinmap[handle] = filename;
}
//! Either submit PTX for simulation or convert SASS to PTXPlus and submit it
void cuobjdumpParseBinary(unsigned int handle){
- if(fatbin_registered[handle]) return;
- fatbin_registered[handle] = true;
CUctx_st *context = GPGPUSim_Context();
- std::string fname = fatbinmap[handle];
+ if(context->fatbin_registered[handle]) return;
+ context->fatbin_registered[handle] = true;
+ std::string fname = context->fatbinmap[handle];
- if (name_symtab.find(fname) != name_symtab.end()) {
- symbol_table *symtab = name_symtab[fname];
+ if (context->name_symtab.find(fname) != context->name_symtab.end()) {
+ symbol_table *symtab = context->name_symtab[fname];
context->add_binary(symtab, handle);
return;
}
@@ -2523,7 +2487,7 @@ void cuobjdumpParseBinary(unsigned int handle){
#if (CUDART_VERSION >= 6000)
//loops through all ptx files from smallest sm version to largest
std::map<unsigned,std::set<std::string> >::iterator itr_m;
- for (itr_m = version_filename.begin(); itr_m!=version_filename.end(); itr_m++){
+ for (itr_m = context->version_filename.begin(); itr_m!=context->version_filename.end(); itr_m++){
std::set<std::string>::iterator itr_s;
for (itr_s = itr_m->second.begin(); itr_s!=itr_m->second.end(); itr_s++){
std::string ptx_filename = *itr_s;
@@ -2531,11 +2495,11 @@ void cuobjdumpParseBinary(unsigned int handle){
symtab = gpgpu_ptx_sim_load_ptx_from_filename( ptx_filename.c_str() );
}
}
- name_symtab[fname] = symtab;
+ context->name_symtab[fname] = symtab;
context->add_binary(symtab, handle);
load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu());
load_constants(symtab,STATIC_ALLOC_LIMIT,context->get_device()->get_gpgpu());
- for (itr_m = version_filename.begin(); itr_m!=version_filename.end(); itr_m++){
+ for (itr_m = context->version_filename.begin(); itr_m!=context->version_filename.end(); itr_m++){
std::set<std::string>::iterator itr_s;
for (itr_s = itr_m->second.begin(); itr_s!=itr_m->second.end(); itr_s++){
std::string ptx_filename = *itr_s;
@@ -2547,8 +2511,8 @@ void cuobjdumpParseBinary(unsigned int handle){
#endif
unsigned max_capability = 0;
- for ( std::list<cuobjdumpSection*>::iterator iter = cuobjdumpSectionList.begin();
- iter != cuobjdumpSectionList.end();
+ for ( std::list<cuobjdumpSection*>::iterator iter = context->cuobjdumpSectionList.begin();
+ iter != context->cuobjdumpSectionList.end();
iter++){
unsigned capability = (*iter)->getArch();
if (capability > max_capability) max_capability = capability;
@@ -2559,7 +2523,7 @@ void cuobjdumpParseBinary(unsigned int handle){
cuobjdumpPTXSection* ptx = NULL;
const char* pre_load = getenv("CUOBJDUMP_SIM_FILE");
if(pre_load==NULL || strlen(pre_load)==0)
- ptx = findPTXSection(fname);
+ ptx = findPTXSection(fname, context->cuobjdumpSectionList, context->libSectionList);
char *ptxcode;
const char *override_ptx_name = getenv("PTX_SIM_KERNELFILE");
if (override_ptx_name == NULL or getenv("PTX_SIM_USE_PTX_FILE") == NULL or strlen(getenv("PTX_SIM_USE_PTX_FILE"))==0) {
@@ -2569,7 +2533,7 @@ void cuobjdumpParseBinary(unsigned int handle){
ptxcode = readfile(override_ptx_name);
}
if(context->get_device()->get_gpgpu()->get_config().convert_to_ptxplus() ) {
- cuobjdumpELFSection* elfsection = findELFSection(ptx->getIdentifier());
+ cuobjdumpELFSection* elfsection = findELFSection(ptx->getIdentifier(), context->cuobjdumpSectionList, context->libSectionList);
assert (elfsection!= NULL);
char *ptxplus_str = gpgpu_ptx_sim_convert_ptx_and_sass_to_ptxplus(
ptx->getPTXfilename(),
@@ -2578,18 +2542,18 @@ void cuobjdumpParseBinary(unsigned int handle){
symtab=gpgpu_ptx_sim_load_ptx_from_string(ptxplus_str, handle);
printf("Adding %s with cubin handle %u\n", ptx->getPTXfilename().c_str(), handle);
context->add_binary(symtab, handle);
- gpgpu_ptxinfo_load_from_string( ptxcode, handle, max_capability );
+ gpgpu_ptxinfo_load_from_string( ptxcode, handle, max_capability, context->no_of_ptx );
delete[] ptxplus_str;
} else {
symtab=gpgpu_ptx_sim_load_ptx_from_string(ptxcode, handle);
//if CUOBJDUMP_SIM_FILE is not set, ptx is NULL. So comment below.
//printf("Adding %s with cubin handle %u\n", ptx->getPTXfilename().c_str(), handle);
context->add_binary(symtab, handle);
- gpgpu_ptxinfo_load_from_string( ptxcode, handle, max_capability );
+ gpgpu_ptxinfo_load_from_string( ptxcode, handle, max_capability, context->no_of_ptx );
}
load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu());
load_constants(symtab,STATIC_ALLOC_LIMIT,context->get_device()->get_gpgpu());
- name_symtab[fname] = symtab;
+ context->name_symtab[fname] = symtab;
//TODO: Remove temporarily files as per configurations
}
@@ -2657,8 +2621,8 @@ void** CUDARTAPI __cudaRegisterFatBinary( void *fatCubin )
* then for next calls, only returns the appropriate number
*/
assert(fat_cubin_handle >= 1);
- if (fat_cubin_handle==1) cuobjdumpInit();
- cuobjdumpRegisterFatBinary(fat_cubin_handle, filename);
+ if (fat_cubin_handle==1) cuobjdumpInit(context->cuobjdumpSectionList);
+ cuobjdumpRegisterFatBinary(fat_cubin_handle, filename, context);
return (void**)fat_cubin_handle;
}
@@ -2710,7 +2674,7 @@ void** CUDARTAPI __cudaRegisterFatBinary( void *fatCubin )
} else {
symtab=gpgpu_ptx_sim_load_ptx_from_string(ptx,source_num);
context->add_binary(symtab,fat_cubin_handle);
- gpgpu_ptxinfo_load_from_string( ptx, source_num, max_capability );
+ gpgpu_ptxinfo_load_from_string( ptx, source_num, max_capability, context->no_of_ptx );
}
source_num++;
load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu());
@@ -2870,10 +2834,6 @@ char __cudaInitModule(
}
-#ifndef OPENGL_SUPPORT
-typedef unsigned long GLuint;
-#endif
-
cudaError_t cudaGLRegisterBufferObject(GLuint bufferObj)
{
if(g_debug_execution >= 3){
@@ -2883,16 +2843,6 @@ cudaError_t cudaGLRegisterBufferObject(GLuint bufferObj)
return g_last_cudaError = cudaSuccess;
}
-struct glbmap_entry {
- GLuint m_bufferObj;
- void *m_devPtr;
- size_t m_size;
- struct glbmap_entry *m_next;
-};
-typedef struct glbmap_entry glbmap_entry_t;
-
-glbmap_entry_t* g_glbmap = NULL;
-
cudaError_t cudaGLMapBufferObject(void** devPtr, GLuint bufferObj)
{
if(g_debug_execution >= 3){
@@ -2902,7 +2852,7 @@ cudaError_t cudaGLMapBufferObject(void** devPtr, GLuint bufferObj)
GLint buffer_size=0;
CUctx_st* ctx = GPGPUSim_Context();
- glbmap_entry_t *p = g_glbmap;
+ glbmap_entry_t *p = ctx->g_glbmap;
while ( p && p->m_bufferObj != bufferObj )
p = p->m_next;
if ( p == NULL ) {
@@ -2913,8 +2863,8 @@ cudaError_t cudaGLMapBufferObject(void** devPtr, GLuint bufferObj)
// create entry and insert to front of list
glbmap_entry_t *n = (glbmap_entry_t *) calloc(1,sizeof(glbmap_entry_t));
- n->m_next = g_glbmap;
- g_glbmap = n;
+ n->m_next = ctx->g_glbmap;
+ ctx->g_glbmap = n;
// initialize entry
n->m_bufferObj = bufferObj;
@@ -2955,7 +2905,8 @@ cudaError_t cudaGLUnmapBufferObject(GLuint bufferObj)
announce_call(__my_func__);
}
#ifdef OPENGL_SUPPORT
- glbmap_entry_t *p = g_glbmap;
+ CUctx_st* ctx = GPGPUSim_Context();
+ glbmap_entry_t *p = ctx->g_glbmap;
while ( p && p->m_bufferObj != bufferObj )
p = p->m_next;
if ( p == NULL )
@@ -2995,7 +2946,8 @@ cudaError_t CUDARTAPI cudaHostAlloc(void **pHost, size_t bytes, unsigned int fl
*pHost = malloc(bytes);
//need to track the size allocated so that cudaHostGetDevicePointer() can function properly.
//TODO: vary this function behavior based on flags value (following nvidia documentation)
- pinned_memory_size[*pHost]=bytes;
+ CUctx_st* context = GPGPUSim_Context();
+ context->pinned_memory_size[*pHost]=bytes;
if( *pHost )
return g_last_cudaError = cudaSuccess;
else
@@ -3012,16 +2964,16 @@ cudaError_t CUDARTAPI cudaHostGetDevicePointer(void **pDevice, void *pHost, unsi
flags=0;
CUctx_st* context = GPGPUSim_Context();
gpgpu_t *gpu = context->get_device()->get_gpgpu();
- std::map<void *, size_t>::const_iterator i = pinned_memory_size.find(pHost);
- assert(i != pinned_memory_size.end());
+ std::map<void *, size_t>::const_iterator i = context->pinned_memory_size.find(pHost);
+ assert(i != context->pinned_memory_size.end());
size_t size = i->second;
*pDevice = gpu->gpu_malloc(size);
if(g_debug_execution >= 3){
printf("GPGPU-Sim PTX: cudaMallocing %zu bytes starting at 0x%llx..\n",size, (unsigned long long) *pDevice);
- g_mallocPtr_Size[(unsigned long long)*pDevice] = size;
+ context->g_mallocPtr_Size[(unsigned long long)*pDevice] = size;
}
if ( *pDevice ) {
- pinned_memory[pHost]=pDevice;
+ context->pinned_memory[pHost]=pDevice;
//Copy contents in cpu to gpu
gpu->memcpy_to_gpu((size_t)*pDevice,pHost,size);
return g_last_cudaError = cudaSuccess;
@@ -3256,14 +3208,6 @@ int CUDARTAPI __cudaSynchronizeThreads(void**, void*)
////////
-extern int ptx_parse();
-extern int ptx__scan_string(const char*);
-extern FILE *ptx_in;
-
-extern int ptxinfo_parse();
-extern int ptxinfo_debug;
-extern FILE *ptxinfo_in;
-
/// static functions
static int load_static_globals( symbol_table *symtab, unsigned min_gaddr, unsigned max_gaddr, gpgpu_t *gpu )
@@ -3383,7 +3327,7 @@ kernel_info_t *gpgpu_cuda_ptx_sim_init_grid( const char *hostFun,
fflush(stdout);
if(g_debug_execution >= 4){
- entry->ptx_jit_config(g_mallocPtr_Size, result->get_param_memory(), (gpgpu_t *) context->get_device()->get_gpgpu(), gridDim, blockDim);
+ entry->ptx_jit_config(context->g_mallocPtr_Size, result->get_param_memory(), (gpgpu_t *) context->get_device()->get_gpgpu(), gridDim, blockDim);
}
return result;
@@ -3868,7 +3812,7 @@ cuLinkAddFile(CUlinkState state, CUjitInputType type, const char *path,
strcat(file,path);
symbol_table *symtab = gpgpu_ptx_sim_load_ptx_from_filename( file );
std::string fname(path);
- name_symtab[fname] = symtab;
+ context->name_symtab[fname] = symtab;
context->add_binary(symtab, 1);
load_static_globals(symtab,STATIC_ALLOC_LIMIT,0xFFFFFFFF,context->get_device()->get_gpgpu());
load_constants(symtab,STATIC_ALLOC_LIMIT,context->get_device()->get_gpgpu());
diff --git a/libcuda/cuobjdump.h b/libcuda/cuobjdump.h
new file mode 100644
index 0000000..49af3e2
--- /dev/null
+++ b/libcuda/cuobjdump.h
@@ -0,0 +1,79 @@
+#ifndef __cuobjdump_h__
+#define __cuobjdump_h__
+#include <string>
+#include <list>
+#include <iostream>
+
+struct cuobjdump_parser {
+ yyscan_t scanner;
+ int elfserial;
+ int ptxserial;
+ FILE *ptxfile;
+ FILE *elffile;
+ FILE *sassfile;
+ char filename [1024];
+};
+
+class cuobjdumpSection {
+public:
+ //Constructor
+ cuobjdumpSection() {
+ arch = 0;
+ identifier = "";
+ }
+ virtual ~cuobjdumpSection() {}
+ unsigned getArch() {return arch;}
+ void setArch(unsigned a) {arch = a;}
+ std::string getIdentifier() {return identifier;}
+ void setIdentifier(std::string i) {identifier = i;}
+ virtual void print(){std::cout << "cuobjdump Section: unknown type" << std::endl;}
+private:
+ unsigned arch;
+ std::string identifier;
+};
+
+class cuobjdumpELFSection : public cuobjdumpSection
+{
+public:
+ cuobjdumpELFSection() {}
+ virtual ~cuobjdumpELFSection() {
+ elffilename = "";
+ sassfilename = "";
+ }
+ std::string getELFfilename() {return elffilename;}
+ void setELFfilename(std::string f) {elffilename = f;}
+ std::string getSASSfilename() {return sassfilename;}
+ void setSASSfilename(std::string f) {sassfilename = f;}
+ virtual void print() {
+ std::cout << "ELF Section:" << std::endl;
+ std::cout << "arch: sm_" << getArch() << std::endl;
+ std::cout << "identifier: " << getIdentifier() << std::endl;
+ std::cout << "elf filename: " << getELFfilename() << std::endl;
+ std::cout << "sass filename: " << getSASSfilename() << std::endl;
+ std::cout << std::endl;
+ }
+private:
+ std::string elffilename;
+ std::string sassfilename;
+};
+
+class cuobjdumpPTXSection : public cuobjdumpSection
+{
+public:
+ cuobjdumpPTXSection(){
+ ptxfilename = "";
+ }
+ std::string getPTXfilename() {return ptxfilename;}
+ void setPTXfilename(std::string f) {ptxfilename = f;}
+ virtual void print() {
+ std::cout << "PTX Section:" << std::endl;
+ std::cout << "arch: sm_" << getArch() << std::endl;
+ std::cout << "identifier: " << getIdentifier() << std::endl;
+ std::cout << "ptx filename: " << getPTXfilename() << std::endl;
+ std::cout << std::endl;
+ }
+private:
+ std::string ptxfilename;
+};
+
+#endif /* __cuobjdump_h__ */
diff --git a/libcuda/cuobjdump.l b/libcuda/cuobjdump.l
index 9359281..5a19d65 100644
--- a/libcuda/cuobjdump.l
+++ b/libcuda/cuobjdump.l
@@ -30,6 +30,7 @@
%{
#include <stdio.h>
#include <string.h>
+#include "cuobjdump.h"
#include "cuobjdump_parser.h"
#define YY_NEVER_INTERACTIVE 1
@@ -38,7 +39,9 @@
#define YYDEBUG 1
-void cuobjdump_error(yyscan_t yyscanner, const char* msg);
+void cuobjdump_error(yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList, const char* msg);
+#define YY_DECL int cuobjdump_lex \
+ (YYSTYPE * yylval_param , yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList)
%}
%option stack
@@ -153,10 +156,10 @@ newlines {newline}+
<<EOF>> BEGIN(INITIAL);return 0;
/*No other rule matched. Throw an error*/
-. cuobjdump_error(yyscanner, "Invalid token");
+. cuobjdump_error(yyscanner, parser, cuobjdumpSectionList, "Invalid token");
%%
-void cuobjdump_error(yyscan_t yyscanner, const char* msg)
+void cuobjdump_error(yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList, const char* msg)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
printf(" %s near \"%s\"",msg, yytext);
diff --git a/libcuda/cuobjdump.y b/libcuda/cuobjdump.y
index 66cbace..8d1bca6 100644
--- a/libcuda/cuobjdump.y
+++ b/libcuda/cuobjdump.y
@@ -30,30 +30,29 @@
#include <stdio.h>
typedef void * yyscan_t;
+#include "cuobjdump.h"
-extern void addCuobjdumpSection(int sectiontype);
-void setCuobjdumparch(const char* arch);
-void setCuobjdumpidentifier(const char* identifier);
-void setCuobjdumpptxfilename(const char* filename);
-void setCuobjdumpelffilename(const char* filename);
-void setCuobjdumpsassfilename(const char* filename);
-int elfserial = 1;
-int ptxserial = 1;
-FILE *ptxfile;
-FILE *elffile;
-FILE *sassfile;
-char filename [1024];
+extern void addCuobjdumpSection(int sectiontype, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
+void setCuobjdumparch(const char* arch, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
+void setCuobjdumpidentifier(const char* identifier, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
+void setCuobjdumpptxfilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
+void setCuobjdumpelffilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
+void setCuobjdumpsassfilename(const char* filename, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
%}
%define api.pure full
%parse-param {yyscan_t scanner}
+%parse-param {struct cuobjdump_parser* parser}
+%parse-param {std::list<cuobjdumpSection*> &cuobjdumpSectionList}
%lex-param {yyscan_t scanner}
+%lex-param {struct cuobjdump_parser* parser}
+%lex-param {std::list<cuobjdumpSection*> &cuobjdumpSectionList}
%union {
char* string_value;
}
%{
-int yylex(YYSTYPE * yylval_param, yyscan_t yyscanner);
-void yyerror(yyscan_t yyscanner, const char* msg);
+int yylex(YYSTYPE * yylval_param, yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList);
+void yyerror(yyscan_t yyscanner, struct cuobjdump_parser* parser, std::list<cuobjdumpSection*> &cuobjdumpSectionList, const char* msg);
%}
%token <string_value> H_SEPARATOR H_ARCH H_CODEVERSION H_PRODUCER H_HOST H_COMPILESIZE H_IDENTIFIER H_UNKNOWN H_COMPRESSED
%token <string_value> CODEVERSION
@@ -78,25 +77,25 @@ emptylines : emptylines NEWLINE
| ;
section : PTXHEADER {
- addCuobjdumpSection(0);
- snprintf(filename, 1024, "_cuobjdump_%d.ptx", ptxserial++);
- ptxfile = fopen(filename, "w");
- setCuobjdumpptxfilename(filename);
+ addCuobjdumpSection(0, cuobjdumpSectionList);
+ snprintf(parser->filename, 1024, "_cuobjdump_%d.ptx", parser->ptxserial++);
+ parser->ptxfile = fopen(parser->filename, "w");
+ setCuobjdumpptxfilename(parser->filename, cuobjdumpSectionList);
} headerinfo compressedkeyword identifier ptxcode {
- fclose(ptxfile);
+ fclose(parser->ptxfile);
}
| ELFHEADER {
- addCuobjdumpSection(1);
- snprintf(filename, 1024, "_cuobjdump_%d.elf", elfserial);
- elffile = fopen(filename, "w");
- setCuobjdumpelffilename(filename);
+ addCuobjdumpSection(1, cuobjdumpSectionList);
+ snprintf(parser->filename, 1024, "_cuobjdump_%d.elf", parser->elfserial);
+ parser->elffile = fopen(parser->filename, "w");
+ setCuobjdumpelffilename(parser->filename, cuobjdumpSectionList);
} headerinfo compressedkeyword identifier elfcode {
- fclose(elffile);
- snprintf(filename, 1024, "_cuobjdump_%d.sass", elfserial++);
- sassfile = fopen(filename, "w");
- setCuobjdumpsassfilename(filename);
+ fclose(parser->elffile);
+ snprintf(parser->filename, 1024, "_cuobjdump_%d.sass", parser->elfserial++);
+ parser->sassfile = fopen(parser->filename, "w");
+ setCuobjdumpsassfilename(parser->filename, cuobjdumpSectionList);
} sasscode {
- fclose(sassfile);
+ fclose(parser->sassfile);
};
headerinfo : H_SEPARATOR NEWLINE
@@ -104,27 +103,27 @@ headerinfo : H_SEPARATOR NEWLINE
H_CODEVERSION CODEVERSION NEWLINE
H_PRODUCER H_UNKNOWN NEWLINE
H_HOST IDENTIFIER NEWLINE
- H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4);};
+ H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4, cuobjdumpSectionList);};
| H_SEPARATOR NEWLINE
H_ARCH IDENTIFIER NEWLINE
H_CODEVERSION CODEVERSION NEWLINE
H_PRODUCER IDENTIFIER NEWLINE
H_HOST IDENTIFIER NEWLINE
- H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4);};
+ H_COMPILESIZE IDENTIFIER {setCuobjdumparch($4, cuobjdumpSectionList);};
-identifier : H_IDENTIFIER FILENAME emptylines {setCuobjdumpidentifier($2);}
- | {setCuobjdumpidentifier("default");};
+identifier : H_IDENTIFIER FILENAME emptylines {setCuobjdumpidentifier($2, cuobjdumpSectionList);}
+ | {setCuobjdumpidentifier("default", cuobjdumpSectionList);};
compressedkeyword : H_COMPRESSED emptylines
| ;
-ptxcode : ptxcode PTXLINE {fprintf(ptxfile, "%s", $2);}
+ptxcode : ptxcode PTXLINE {fprintf(parser->ptxfile, "%s", $2);}
| ;
-elfcode : elfcode ELFLINE {fprintf(elffile, "%s", $2);}
+elfcode : elfcode ELFLINE {fprintf(parser->elffile, "%s", $2);}
| ;
-sasscode : sasscode SASSLINE {fprintf(sassfile, "%s", $2);}
+sasscode : sasscode SASSLINE {fprintf(parser->sassfile, "%s", $2);}
| ;
diff --git a/linux-so-version.txt b/linux-so-version.txt
index c6e03e9..a7c2d3c 100644
--- a/linux-so-version.txt
+++ b/linux-so-version.txt
@@ -1,4 +1,8 @@
+libcudart.so.9.0{
+};
libcudart.so.9.1{
};
+libcudart.so.9.2{
+};
libcuda.so.1{
};
diff --git a/nightly.jenkinsfile b/nightly.jenkinsfile
index 5221b3b..ce2e226 100644
--- a/nightly.jenkinsfile
+++ b/nightly.jenkinsfile
@@ -23,9 +23,8 @@ pipeline {
stage('nightly-simulations-build'){
steps{
sh 'rm -rf gpgpu-sim_simulations'
- sh 'git clone [email protected]:TimRogersGroup/gpgpu-sim_simulations.git && \
+ sh 'git clone [email protected]:purdue-aalp/gpgpu-sim_simulations.git && \
cd gpgpu-sim_simulations && \
- git checkout purdue-cluster && \
git pull && \
ln -s /home/tgrogers-raid/a/common/data_dirs benchmarks/'
sh 'source /home/tgrogers-raid/a/common/gpgpu-sim-setup/9.1_env_setup.sh &&\
@@ -40,9 +39,9 @@ pipeline {
steps {
sh 'source /home/tgrogers-raid/a/common/gpgpu-sim-setup/9.1_env_setup.sh &&\
source `pwd`/setup_environment &&\
- ./gpgpu-sim_simulations/util/job_launching/run_simulations.py -B `cat ./gpgpu-sim_simulations/util/job_launching/apps/all-apps.list` -C TITANX-2B,TITANX-L1ON-2B,P100-2B,TITANV-2B -N nightly-$$ && \
+ ./gpgpu-sim_simulations/util/job_launching/run_simulations.py -B `cat ./gpgpu-sim_simulations/util/job_launching/apps/all-apps.list` -C TITANV-2B -N nightly-$$ && \
PLOTDIR="jenkins/${JOB_NAME}/${BUILD_NUMBER}/getstats" && ssh [email protected] mkdir -p /home/dynamo/a/tgrogers/website/gpgpu-sim-plots/$PLOTDIR && \
- ./gpgpu-sim_simulations/util/job_launching/monitor_func_test.py -I -S 1800 -v -s stats-$$.csv -N nightly-$$ && \
+ ./gpgpu-sim_simulations/util/job_launching/monitor_func_test.py -I -S 1800 -v -s stats-$$.csv -T 12 -N nightly-$$ && \
./gpgpu-sim_simulations/util/plotting/plot-get-stats.py -c stats-$$.csv -p [email protected]:~/website/gpgpu-sim-plots/$PLOTDIR -w https://engineering.purdue.edu/tgrogers/gpgpu-sim-plots/$PLOTDIR -n $PLOTDIR'
}
}
@@ -51,7 +50,7 @@ pipeline {
sh 'source /home/tgrogers-raid/a/common/gpgpu-sim-setup/9.1_env_setup.sh &&\
source `pwd`/setup_environment &&\
PLOTDIR="jenkins/${JOB_NAME}" &&\
- ./gpgpu-sim_simulations/util/job_launching/get_stats.py -R -K -k -B `cat ./gpgpu-sim_simulations/util/job_launching/apps/all-apps.list` -C TITANX-2B,TITANX-L1ON-2B,P100-2B,TITANV-2B > nightly-stats-per-kernel-9.1.csv &&\
+ ./gpgpu-sim_simulations/util/job_launching/get_stats.py -R -K -k -B `cat ./gpgpu-sim_simulations/util/job_launching/apps/all-apps.list` -C TITANV-2B > nightly-stats-per-kernel-9.1.csv &&\
./gpgpu-sim_simulations/util/plotting/correlate_and_publish.sh nightly-stats-per-kernel-9.1.csv $PLOTDIR ${BUILD_NUMBER}'
}
}
diff --git a/src/cuda-sim/cuda-sim.cc b/src/cuda-sim/cuda-sim.cc
index f7bb9cc..e733b7f 100644
--- a/src/cuda-sim/cuda-sim.cc
+++ b/src/cuda-sim/cuda-sim.cc
@@ -30,6 +30,8 @@
#include "instructions.h"
#include "ptx_ir.h"
+class ptx_recognizer;
+typedef void * yyscan_t;
#include "ptx.tab.h"
#include "ptx_sim.h"
#include <stdio.h>
diff --git a/src/cuda-sim/instructions.cc b/src/cuda-sim/instructions.cc
index 11001d7..69a97b6 100644
--- a/src/cuda-sim/instructions.cc
+++ b/src/cuda-sim/instructions.cc
@@ -31,6 +31,8 @@
#include "ptx_ir.h"
#include "opcodes.h"
#include "ptx_sim.h"
+typedef void * yyscan_t;
+class ptx_recognizer;
#include "ptx.tab.h"
#include <stdlib.h>
#include <math.h>
diff --git a/src/cuda-sim/ptx.l b/src/cuda-sim/ptx.l
index 3232361..2546a99 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,29 @@ 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;
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..8447693 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,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <stdlib.h>
#include <string.h>
#include <math.h>
- void syntax_not_implemented();
+ void syntax_not_implemented(yyscan_t yyscanner, ptx_recognizer* recognizer);
extern int g_func_decl;
- int ptx_lex(void);
- int ptx_error(const char *);
+ int ptx_lex(YYSTYPE * yylval_param, yyscan_t yyscanner, ptx_recognizer* recognizer);
+ int ptx_error( yyscan_t yyscanner, ptx_recognizer* recognizer, const char *s );
%}
%%
@@ -231,96 +242,96 @@ input: /* empty */
| input function_decl
;
-function_defn: function_decl { set_symtab($1); func_header(".skip"); } statement_block { end_function(); }
- | function_decl { set_symtab($1); } block_spec_list { func_header(".skip"); } statement_block { end_function(); }
+function_defn: function_decl { recognizer->set_symtab($1); recognizer->func_header(".skip"); } statement_block { recognizer->end_function(); }
+ | function_decl { recognizer->set_symtab($1); } block_spec_list { recognizer->func_header(".skip"); } statement_block { recognizer->end_function(); }
;
-block_spec: MAXNTID_DIRECTIVE INT_OPERAND COMMA INT_OPERAND COMMA INT_OPERAND {func_header_info_int(".maxntid", $2);
- func_header_info_int(",", $4);
- func_header_info_int(",", $6);
- maxnt_id($2, $4, $6);}
- | MINNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".minnctapersm", $2); printf("GPGPU-Sim: Warning: .minnctapersm ignored. \n"); }
- | MAXNCTAPERSM_DIRECTIVE INT_OPERAND { func_header_info_int(".maxnctapersm", $2); printf("GPGPU-Sim: Warning: .maxnctapersm ignored. \n"); }
+block_spec: MAXNTID_DIRECTIVE INT_OPERAND COMMA INT_OPERAND COMMA INT_OPERAND {recognizer->func_header_info_int(".maxntid", $2);
+ recognizer->func_header_info_int(",", $4);
+ recognizer->func_header_info_int(",", $6);
+ recognizer->maxnt_id($2, $4, $6);}
+ | MINNCTAPERSM_DIRECTIVE INT_OPERAND { recognizer->func_header_info_int(".minnctapersm", $2); printf("GPGPU-Sim: Warning: .minnctapersm ignored. \n"); }
+ | MAXNCTAPERSM_DIRECTIVE INT_OPERAND { recognizer->func_header_info_int(".maxnctapersm", $2); printf("GPGPU-Sim: Warning: .maxnctapersm ignored. \n"); }
;
block_spec_list: block_spec
| block_spec_list block_spec
;
-function_decl: function_decl_header LEFT_PAREN { start_function($1); func_header_info("(");} param_entry RIGHT_PAREN {func_header_info(")");} function_ident_param { $$ = reset_symtab(); }
- | function_decl_header { start_function($1); } function_ident_param { $$ = reset_symtab(); }
- | function_decl_header { start_function($1); add_function_name(""); g_func_decl=0; $$ = reset_symtab(); }
+function_decl: function_decl_header LEFT_PAREN { recognizer->start_function($1); recognizer->func_header_info("(");} param_entry RIGHT_PAREN {recognizer->func_header_info(")");} function_ident_param { $$ = recognizer->reset_symtab(); }
+ | function_decl_header { recognizer->start_function($1); } function_ident_param { $$ = recognizer->reset_symtab(); }
+ | function_decl_header { recognizer->start_function($1); recognizer->add_function_name(""); g_func_decl=0; $$ = recognizer->reset_symtab(); }
;
-function_ident_param: IDENTIFIER { add_function_name($1); } LEFT_PAREN {func_header_info("(");} param_list RIGHT_PAREN { g_func_decl=0; func_header_info(")"); }
- | IDENTIFIER { add_function_name($1); g_func_decl=0; }
+function_ident_param: IDENTIFIER { recognizer->add_function_name($1); } LEFT_PAREN {recognizer->func_header_info("(");} param_list RIGHT_PAREN { g_func_decl=0; recognizer->func_header_info(")"); }
+ | IDENTIFIER { recognizer->add_function_name($1); g_func_decl=0; }
;
-function_decl_header: ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
- | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
- | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; func_header(".entry"); }
- | FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
- | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
- | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
- | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; g_func_decl=1; func_header(".func"); }
- | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; func_header(".func"); }
+function_decl_header: ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; recognizer->func_header(".entry"); }
+ | VISIBLE_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; recognizer->func_header(".entry"); }
+ | WEAK_DIRECTIVE ENTRY_DIRECTIVE { $$ = 1; g_func_decl=1; recognizer->func_header(".entry"); }
+ | FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); }
+ | VISIBLE_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); }
+ | EXTERN_DIRECTIVE FUNC_DIRECTIVE { $$ = 2; g_func_decl=1; recognizer->func_header(".func"); }
+ | WEAK_DIRECTIVE FUNC_DIRECTIVE { $$ = 0; g_func_decl=1; recognizer->func_header(".func"); }
;
param_list: /*empty*/
- | param_entry { add_directive(); }
- | param_list COMMA {func_header_info(",");} param_entry { add_directive(); }
+ | param_entry { recognizer->add_directive(); }
+ | param_list COMMA {recognizer->func_header_info(",");} param_entry { recognizer->add_directive(); }
-param_entry: PARAM_DIRECTIVE { add_space_spec(param_space_unclassified,0); } variable_spec ptr_spec identifier_spec { add_function_arg(); }
- | REG_DIRECTIVE { add_space_spec(reg_space,0); } variable_spec identifier_spec { add_function_arg(); }
+param_entry: PARAM_DIRECTIVE { recognizer->add_space_spec(param_space_unclassified,0); } variable_spec ptr_spec identifier_spec { recognizer->add_function_arg(); }
+ | REG_DIRECTIVE { recognizer->add_space_spec(reg_space,0); } variable_spec identifier_spec { recognizer->add_function_arg(); }
ptr_spec: /*empty*/
| PTR_DIRECTIVE ptr_space_spec ptr_align_spec
| PTR_DIRECTIVE ptr_align_spec
-ptr_space_spec: GLOBAL_DIRECTIVE { add_ptr_spec(global_space); }
- | LOCAL_DIRECTIVE { add_ptr_spec(local_space); }
- | SHARED_DIRECTIVE { add_ptr_spec(shared_space); }
- | CONST_DIRECTIVE { add_ptr_spec(global_space); }
+ptr_space_spec: GLOBAL_DIRECTIVE { recognizer->add_ptr_spec(global_space); }
+ | LOCAL_DIRECTIVE { recognizer->add_ptr_spec(local_space); }
+ | SHARED_DIRECTIVE { recognizer->add_ptr_spec(shared_space); }
+ | CONST_DIRECTIVE { recognizer->add_ptr_spec(global_space); }
ptr_align_spec: ALIGN_DIRECTIVE INT_OPERAND
statement_block: LEFT_BRACE statement_list RIGHT_BRACE
-statement_list: directive_statement { add_directive(); }
- | instruction_statement { add_instruction(); }
- | statement_list directive_statement { add_directive(); }
- | statement_list instruction_statement { add_instruction(); }
- | statement_list {start_inst_group();} statement_block {end_inst_group();}
- | {start_inst_group();} statement_block {end_inst_group();}
+statement_list: directive_statement { recognizer->add_directive(); }
+ | instruction_statement { recognizer->add_instruction(); }
+ | statement_list directive_statement { recognizer->add_directive(); }
+ | statement_list instruction_statement { recognizer->add_instruction(); }
+ | statement_list {recognizer->start_inst_group();} statement_block {recognizer->end_inst_group();}
+ | {recognizer->start_inst_group();} statement_block {recognizer->end_inst_group();}
;
directive_statement: variable_declaration SEMI_COLON
- | VERSION_DIRECTIVE DOUBLE_OPERAND { add_version_info($2, 0); }
- | VERSION_DIRECTIVE DOUBLE_OPERAND PLUS { add_version_info($2,1); }
+ | VERSION_DIRECTIVE DOUBLE_OPERAND { recognizer->add_version_info($2, 0); }
+ | VERSION_DIRECTIVE DOUBLE_OPERAND PLUS { recognizer->add_version_info($2,1); }
| ADDRESS_SIZE_DIRECTIVE INT_OPERAND {/*Do nothing*/}
- | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER { target_header2($2,$4); }
- | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER { target_header3($2,$4,$6); }
- | TARGET_DIRECTIVE IDENTIFIER { target_header($2); }
- | FILE_DIRECTIVE INT_OPERAND STRING { add_file($2,$3); }
- | FILE_DIRECTIVE INT_OPERAND STRING COMMA INT_OPERAND COMMA INT_OPERAND { add_file($2,$3); }
+ | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER { recognizer->target_header2($2,$4); }
+ | TARGET_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA IDENTIFIER { recognizer->target_header3($2,$4,$6); }
+ | TARGET_DIRECTIVE IDENTIFIER { recognizer->target_header($2); }
+ | FILE_DIRECTIVE INT_OPERAND STRING { recognizer->add_file($2,$3); }
+ | FILE_DIRECTIVE INT_OPERAND STRING COMMA INT_OPERAND COMMA INT_OPERAND { recognizer->add_file($2,$3); }
| LOC_DIRECTIVE INT_OPERAND INT_OPERAND INT_OPERAND
- | PRAGMA_DIRECTIVE STRING SEMI_COLON { add_pragma($2); }
+ | PRAGMA_DIRECTIVE STRING SEMI_COLON { recognizer->add_pragma($2); }
| function_decl SEMI_COLON {/*Do nothing*/}
;
-variable_declaration: variable_spec identifier_list { add_variables(); }
- | variable_spec identifier_spec EQUALS initializer_list { add_variables(); }
- | variable_spec identifier_spec EQUALS literal_operand { add_variables(); }
- | CONSTPTR_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA INT_OPERAND { add_constptr($2, $4, $6); }
+variable_declaration: variable_spec identifier_list { recognizer->add_variables(); }
+ | variable_spec identifier_spec EQUALS initializer_list { recognizer->add_variables(); }
+ | variable_spec identifier_spec EQUALS literal_operand { recognizer->add_variables(); }
+ | CONSTPTR_DIRECTIVE IDENTIFIER COMMA IDENTIFIER COMMA INT_OPERAND { recognizer->add_constptr($2, $4, $6); }
;
-variable_spec: var_spec_list { set_variable_type(); }
+variable_spec: var_spec_list { recognizer->set_variable_type(); }
identifier_list: identifier_spec
| identifier_list COMMA identifier_spec;
-identifier_spec: IDENTIFIER { add_identifier($1,0,NON_ARRAY_IDENTIFIER); func_header_info($1);}
- | IDENTIFIER LEFT_ANGLE_BRACKET INT_OPERAND RIGHT_ANGLE_BRACKET { func_header_info($1); func_header_info_int("<", $3); func_header_info(">");
+identifier_spec: IDENTIFIER { recognizer->add_identifier($1,0,NON_ARRAY_IDENTIFIER); recognizer->func_header_info($1);}
+ | IDENTIFIER LEFT_ANGLE_BRACKET INT_OPERAND RIGHT_ANGLE_BRACKET { recognizer->func_header_info($1); recognizer->func_header_info_int("<", $3); recognizer->func_header_info(">");
int i,lbase,l;
char *id = NULL;
lbase = strlen($1);
@@ -328,12 +339,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 +354,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 +452,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 +561,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 da7c32d..f037c34 100644
--- a/src/cuda-sim/ptx_loader.cc
+++ b/src/cuda-sim/ptx_loader.cc
@@ -44,8 +44,12 @@ 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();
@@ -54,7 +58,7 @@ const char *g_ptxinfo_filename;
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);
+extern int ptxinfo_parse(yyscan_t scanner, ptxinfo_data* ptxinfo);
extern int ptxinfo_lex_destroy(yyscan_t scanner);
static bool g_save_embedded_ptx;
@@ -171,8 +175,10 @@ 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_recognizer recognizer;
+ ptx_lex_init(&(recognizer.scanner));
+ ptx__scan_string(p, recognizer.scanner);
+ int errors = ptx_parse (recognizer.scanner, &recognizer);
if ( errors ) {
char fname[1024];
snprintf(fname,1024,"_ptx_errors_XXXXXX");
@@ -185,6 +191,7 @@ symbol_table *gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source
abort();
exit(40);
}
+ ptx_lex_destroy(recognizer.scanner);
if ( g_debug_execution >= 100 )
print_ptx_file(p,source_num,buf);
@@ -352,15 +359,15 @@ void gpgpu_ptx_info_load_from_filename( const char *filename, unsigned sm_versio
g_ptxinfo_filename = strdup(ptxas_filename.c_str());
FILE *ptxinfo_in;
ptxinfo_in = fopen(g_ptxinfo_filename,"r");
- yyscan_t scanner;
- ptxinfo_lex_init(&scanner);
- ptxinfo_set_in(ptxinfo_in, scanner);
- ptxinfo_parse(scanner);
- ptxinfo_lex_destroy(scanner);
+ ptxinfo_data 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);
}
-void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version )
+void 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];
@@ -421,11 +428,11 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num
FILE *ptxinfo_in;
ptxinfo_in = fopen(tempfile_ptxinfo,"r");
g_ptxinfo_filename = tempfile_ptxinfo;
- yyscan_t scanner;
- ptxinfo_lex_init(&scanner);
- ptxinfo_set_in(ptxinfo_in, scanner);
- ptxinfo_parse(scanner);
- ptxinfo_lex_destroy(scanner);
+ ptxinfo_data 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);
@@ -512,11 +519,11 @@ void gpgpu_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num
FILE *ptxinfo_in;
ptxinfo_in = fopen(g_ptxinfo_filename,"r");
- yyscan_t scanner;
- ptxinfo_lex_init(&scanner);
- ptxinfo_set_in(ptxinfo_in, scanner);
- ptxinfo_parse(scanner);
- ptxinfo_lex_destroy(scanner);
+ ptxinfo_data 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);
snprintf(commandline,1024,"rm -f *info");
diff --git a/src/cuda-sim/ptx_loader.h b/src/cuda-sim/ptx_loader.h
index e5df6a9..c4d8292 100644
--- a/src/cuda-sim/ptx_loader.h
+++ b/src/cuda-sim/ptx_loader.h
@@ -29,12 +29,22 @@
#define PTX_LOADER_H_INCLUDED
#include <string>
+#define LINEBUF_SIZE 1024
+typedef void * yyscan_t;
+class ptxinfo_data{
+ public:
+ yyscan_t scanner;
+ char linebuf[LINEBUF_SIZE];
+ unsigned col;
+};
+
+
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_ptxinfo_load_from_string( const char *p_for_info, unsigned source_num, unsigned sm_version=20, int no_of_ptx=0 );
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..c4cc911 100644
--- a/src/cuda-sim/ptx_parser.cc
+++ b/src/cuda-sim/ptx_parser.cc
@@ -27,13 +27,19 @@
#include "ptx_parser.h"
#include "ptx_ir.h"
+
+typedef void * yyscan_t;
#include "ptx.tab.h"
#include <stdarg.h>
-extern int ptx_error( const char *s );
-extern int ptx_lineno;
-extern int ptx_parse();
-extern FILE *ptx_in;
+extern int ptx_get_lineno (yyscan_t yyscanner );
+extern 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)
@@ -80,7 +86,7 @@ std::list<int> g_scalar_type;
#define PTX_PARSE_DPRINTF(...) \
if( g_debug_ir_generation ) { \
- printf(" %s:%u => ",g_filename,ptx_lineno); \
+ printf(" %s:%u => ",g_filename,ptx_get_lineno(scanner)); \
printf(" (%s:%u) ", __FILE__, __LINE__); \
printf(__VA_ARGS__); \
printf("\n"); \
@@ -109,7 +115,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 +131,7 @@ void init_directive_state()
g_last_symbol = NULL;
}
-void init_instruction_state()
+void ptx_recognizer::init_instruction_state()
{
PTX_PARSE_DPRINTF("init_instruction_state");
g_pred = NULL;
@@ -149,7 +155,6 @@ symbol_table *init_parser( const char *ptx_filename )
/*else {
g_global_symbol_table = g_current_symbol_table = new symbol_table("global",0,g_global_allfiles_symbol_table);
}*/
- ptx_lineno = 1;
#define DEF(X,Y) g_ptx_token_decode[X] = Y;
#include "ptx_parser_decode.def"
@@ -169,18 +174,24 @@ symbol_table *init_parser( const char *ptx_filename )
g_ptx_token_decode[generic_space] = "generic_space";
g_ptx_token_decode[instruction_space] = "instruction_space";
- init_directive_state();
- init_instruction_state();
+ ptx_recognizer recognizer;
+ ptx_lex_init(&(recognizer.scanner));
+ recognizer.init_directive_state();
+ recognizer.init_instruction_state();
+ FILE *ptx_in;
ptx_in = fopen(ptx_filename, "r");
- ptx_parse();
+ ptx_set_in(ptx_in, recognizer.scanner);
+ ptx_parse(recognizer.scanner, &recognizer);
+ ptx_in = ptx_get_in(recognizer.scanner);
+ ptx_lex_destroy(recognizer.scanner);
fclose(ptx_in);
return g_global_symbol_table;
}
static int g_entry_point;
-void start_function( int entry_point )
+void ptx_recognizer::start_function( int entry_point )
{
PTX_PARSE_DPRINTF("start_function");
init_directive_state();
@@ -194,7 +205,7 @@ char *g_add_identifier_cached__identifier = NULL;
int g_add_identifier_cached__array_dim;
int g_add_identifier_cached__array_ident;
-void add_function_name( const char *name )
+void ptx_recognizer::add_function_name( const char *name )
{
PTX_PARSE_DPRINTF("add_function_name %s %s", name, ((g_entry_point==1)?"(entrypoint)":((g_entry_point==2)?"(extern)":"")));
bool prior_decl = g_global_symbol_table->add_function_decl( name, g_entry_point, &g_func_info, &g_current_symbol_table );
@@ -210,21 +221,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 +243,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 +261,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 +270,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 +288,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 +310,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 +326,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 +344,7 @@ void add_variables()
init_directive_state();
}
-void set_variable_type()
+void ptx_recognizer::set_variable_type()
{
PTX_PARSE_DPRINTF("set_variable_type space_spec=%s scalar_type_spec=%s",
g_ptx_token_decode[g_space_spec.get_type()].c_str(),
@@ -378,7 +388,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 +436,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 +579,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 +594,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 +607,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 +628,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 +647,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 +692,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 +721,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 +744,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 +753,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 +762,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 +772,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 +786,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 +809,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 +823,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 +870,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 +884,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 +923,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 +932,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 +966,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 +989,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 +1032,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..fdff6ce 100644
--- a/src/cuda-sim/ptx_parser.h
+++ b/src/cuda-sim/ptx_parser.h
@@ -37,69 +37,84 @@ class symbol_table* init_parser(const char*);
const class ptx_instruction *ptx_instruction_lookup( const char *filename, unsigned linenumber );
#endif
+typedef void * yyscan_t;
+class ptx_recognizer {
+ public:
+ ptx_recognizer() {
+ scanner = NULL;
+ }
+ yyscan_t scanner;
+#define LINEBUF_SIZE (4*1024)
+ char linebuf[LINEBUF_SIZE];
+ unsigned col;
+ void init_directive_state();
+ void init_instruction_state();
+ void start_function( int entry_point );
+ void add_function_name( const char *fname );
+ void add_directive();
+ void end_function();
+ void add_identifier( const char *s, int array_dim, unsigned array_ident );
+ void add_function_arg();
+ void add_scalar_type_spec( int type_spec );
+ void add_scalar_operand( const char *identifier );
+ void add_neg_pred_operand( const char *identifier );
+ void add_variables();
+ void set_variable_type();
+ void add_opcode( int opcode );
+ void add_pred( const char *identifier, int negate, int predModifier );
+ void add_1vector_operand( const char *d1 );
+ void add_2vector_operand( const char *d1, const char *d2 );
+ void add_3vector_operand( const char *d1, const char *d2, const char *d3 );
+ void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 );
+ void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ,const char *d5,const char *d6,const char *d7,const char *d8);
+ void add_option(int option );
+ void add_wmma_option(int option );
+ void add_builtin_operand( int builtin, int dim_modifier );
+ void add_memory_operand( );
+ void add_literal_int( int value );
+ void add_literal_float( float value );
+ void add_literal_double( double value );
+ void add_address_operand( const char *identifier, int offset );
+ void add_address_operand2( int offset );
+ void add_label( const char *idenfiier );
+ void add_vector_spec(int spec );
+ void add_space_spec( enum _memory_space_t spec, int value );
+ void add_ptr_spec( enum _memory_space_t spec );
+ void add_extern_spec();
+ void add_instruction();
+ void set_return();
+ void add_alignment_spec( int spec );
+ void add_array_initializer();
+ void add_file( unsigned num, const char *filename );
+ void add_version_info( float ver, unsigned ext);
+ void *reset_symtab();
+ void set_symtab(void*);
+ void add_pragma( const char *str );
+ void func_header(const char* a);
+ void func_header_info(const char* a);
+ void func_header_info_int(const char* a, int b);
+ void add_constptr(const char* identifier1, const char* identifier2, int offset);
+ void target_header(char* a);
+ void target_header2(char* a, char* b);
+ void target_header3(char* a, char* b, char* c);
+ void add_double_operand( const char *d1, const char *d2 );
+ void change_memory_addr_space( const char *identifier );
+ void change_operand_lohi( int lohi );
+ void change_double_operand_type( int addr_type );
+ void change_operand_neg( );
+ void set_immediate_operand_type( );
+ void version_header(double a);
+ void maxnt_id(int x, int y, int z);
+ void parse_error_impl( const char *file, unsigned line, const char *msg, ... );
+ void parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... );
+ //Jin: handle instructino group for cdp
+ void start_inst_group();
+ void end_inst_group();
+
+};
+
const char *decode_token( int type );
void read_parser_environment_variables();
-void start_function( int entry_point );
-void add_function_name( const char *fname );
-void init_directive_state();
-void add_directive();
-void end_function();
-void add_identifier( const char *s, int array_dim, unsigned array_ident );
-void add_function_arg();
-void add_scalar_type_spec( int type_spec );
-void add_scalar_operand( const char *identifier );
-void add_neg_pred_operand( const char *identifier );
-void add_variables();
-void set_variable_type();
-void add_opcode( int opcode );
-void add_pred( const char *identifier, int negate, int predModifier );
-void add_1vector_operand( const char *d1 );
-void add_2vector_operand( const char *d1, const char *d2 );
-void add_3vector_operand( const char *d1, const char *d2, const char *d3 );
-void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 );
-void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ,const char *d5,const char *d6,const char *d7,const char *d8);
-void add_option(int option );
-void add_wmma_option(int option );
-void add_builtin_operand( int builtin, int dim_modifier );
-void add_memory_operand( );
-void add_literal_int( int value );
-void add_literal_float( float value );
-void add_literal_double( double value );
-void add_address_operand( const char *identifier, int offset );
-void add_address_operand2( int offset );
-void add_label( const char *idenfiier );
-void add_vector_spec(int spec );
-void add_space_spec( enum _memory_space_t spec, int value );
-void add_ptr_spec( enum _memory_space_t spec );
-void add_extern_spec();
-void add_instruction();
-void set_return();
-void add_alignment_spec( int spec );
-void add_array_initializer();
-void add_file( unsigned num, const char *filename );
-void add_version_info( float ver, unsigned ext);
-void *reset_symtab();
-void set_symtab(void*);
-void add_pragma( const char *str );
-void func_header(const char* a);
-void func_header_info(const char* a);
-void func_header_info_int(const char* a, int b);
-void add_constptr(const char* identifier1, const char* identifier2, int offset);
-void target_header(char* a);
-void target_header2(char* a, char* b);
-void target_header3(char* a, char* b, char* c);
-void add_double_operand( const char *d1, const char *d2 );
-void change_memory_addr_space( const char *identifier );
-void change_operand_lohi( int lohi );
-void change_double_operand_type( int addr_type );
-void change_operand_neg( );
-void set_immediate_operand_type( );
-void version_header(double a);
-void maxnt_id(int x, int y, int z);
-
-//Jin: handle instructino group for cdp
-void start_inst_group();
-void end_inst_group();
#define NON_ARRAY_IDENTIFIER 1
#define ARRAY_IDENTIFIER_NO_DIM 2
diff --git a/src/cuda-sim/ptx_sim.cc b/src/cuda-sim/ptx_sim.cc
index 8ad651e..1b8831a 100644
--- a/src/cuda-sim/ptx_sim.cc
+++ b/src/cuda-sim/ptx_sim.cc
@@ -28,6 +28,8 @@
#include "ptx_sim.h"
#include <string>
#include "ptx_ir.h"
+class ptx_recognizer;
+typedef void * yyscan_t;
#include "ptx.tab.h"
#include "../gpgpu-sim/gpu-sim.h"
#include "../gpgpu-sim/shader.h"
diff --git a/src/cuda-sim/ptxinfo.l b/src/cuda-sim/ptxinfo.l
index a190e6d..92f7a30 100644
--- a/src/cuda-sim/ptxinfo.l
+++ b/src/cuda-sim/ptxinfo.l
@@ -36,14 +36,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
%option reentrant
%{
+#include "ptx_loader.h"
#include "ptxinfo.tab.h"
#include <string.h>
#define LINEBUF_SIZE 1024
-#define TC if( (yylineno == 1) && (yylval->col + strlen(yytext) < LINEBUF_SIZE) ) { \
- strncpy(yylval->linebuf+yylval->col,yytext,strlen(yytext)); \
+#define TC if( (yylineno == 1) && (ptxinfo->col + strlen(yytext) < LINEBUF_SIZE) ) { \
+ strncpy(ptxinfo->linebuf+ptxinfo->col,yytext,strlen(yytext)); \
} \
- yylval->col+=strlen(yytext);
+ ptxinfo->col+=strlen(yytext);
+#define YY_DECL int ptxinfo_lex \
+ (YYSTYPE * yylval_param , yyscan_t yyscanner, ptxinfo_data* ptxinfo)
%}
%%
@@ -80,7 +83,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
" " TC;
"\t" TC;
-\n.* yylval->col=0; strncpy(yylval->linebuf, yytext + 1, 1024); yyless( 1 );
+\n.* ptxinfo->col=0; strncpy(ptxinfo->linebuf, yytext + 1, 1024); yyless( 1 );
%%
@@ -88,7 +91,7 @@ extern int g_ptxinfo_error_detected;
extern const char *g_filename;
extern const char *g_ptxinfo_filename;
-int ptxinfo_error(yyscan_t yyscanner, const char* msg)
+int ptxinfo_error(yyscan_t yyscanner, ptxinfo_data* ptxinfo, const char* msg)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
int i;
@@ -97,10 +100,10 @@ int ptxinfo_error(yyscan_t yyscanner, const char* msg)
printf("GPGPU-Sim: ERROR while parsing output of ptxas (used to capture resource usage information)\n");
if( msg != NULL )
printf("GPGPU-Sim: %s (%s:%u) Syntax error:\n\n", g_filename, g_ptxinfo_filename, yylineno );
- printf(" %s\n", yylval->linebuf );
+ printf(" %s\n", ptxinfo->linebuf );
printf(" ");
- for( i=0; i < yylval->col-1; i++ ) {
- if( yylval->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 eed304c..00c81e0 100644
--- a/src/cuda-sim/ptxinfo.y
+++ b/src/cuda-sim/ptxinfo.y
@@ -29,18 +29,18 @@ 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 {
-#define LINEBUF_SIZE 1024
int int_value;
char * string_value;
- char linebuf[LINEBUF_SIZE];
- unsigned col;
}
%token <int_value> INT_OPERAND
@@ -77,8 +77,8 @@ typedef void * yyscan_t;
static unsigned g_declared;
static unsigned g_system;
- int ptxinfo_lex(YYSTYPE * yylval_param, yyscan_t yyscanner);
- void yyerror(yyscan_t yyscanner, const char* msg);
+ 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 );
diff --git a/src/gpgpu-sim/gpu-cache.h b/src/gpgpu-sim/gpu-cache.h
index 85e534e..d11a7fd 100644
--- a/src/gpgpu-sim/gpu-cache.h
+++ b/src/gpgpu-sim/gpu-cache.h
@@ -681,15 +681,15 @@ public:
// tag + index is required to check for hit/miss. Tag is now identical to the block address.
//return addr >> (m_line_sz_log2+m_nset_log2);
- return addr & ~(m_line_sz-1);
+ return addr & ~(new_addr_type)(m_line_sz-1);
}
new_addr_type block_addr( new_addr_type addr ) const
{
- return addr & ~(m_line_sz-1);
+ return addr & ~(new_addr_type)(m_line_sz-1);
}
new_addr_type mshr_addr( new_addr_type addr ) const
{
- return addr & ~(m_atom_sz-1);
+ return addr & ~(new_addr_type)(m_atom_sz-1);
}
enum mshr_config_t get_mshr_type() const
{
generated by cgit v1.3 (git 2.53.0) at 2026-07-11 18:40:18 +0000