1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
// 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.
#ifndef ptx_parser_INCLUDED
#define ptx_parser_INCLUDED
#include "../abstract_hardware_model.h"
#include "ptx_ir.h"
class gpgpu_context;
typedef void * yyscan_t;
class ptx_recognizer {
public:
ptx_recognizer( gpgpu_context* ctx ) {
scanner = NULL;
g_size = -1;
g_add_identifier_cached__identifier = NULL;
g_alignment_spec = -1;
g_var_type = NULL;
g_opcode = -1;
g_space_spec = undefined_space;
g_ptr_spec = undefined_space;
g_scalar_type_spec = -1;
g_vector_spec = -1;
g_extern_spec = 0;
g_func_decl = 0;
g_ident_add_uid = 0;
g_const_alloc = 1;
g_max_regs_per_thread = 0;
g_global_symbol_table = NULL;
g_current_symbol_table = NULL;
g_last_symbol = NULL;
g_error_detected = 0;
g_entry_func_param_index=0;
g_func_info = NULL;
g_debug_ir_generation=false;
gpgpu_ctx = ctx;
}
// global list
yyscan_t scanner;
#define PTX_LINEBUF_SIZE (4*1024)
char linebuf[PTX_LINEBUF_SIZE];
unsigned col;
int g_size;
char *g_add_identifier_cached__identifier;
int g_add_identifier_cached__array_dim;
int g_add_identifier_cached__array_ident;
int g_alignment_spec;
// variable declaration stuff:
type_info *g_var_type;
// instruction definition stuff:
const symbol *g_pred;
int g_neg_pred;
int g_pred_mod;
symbol *g_label;
int g_opcode;
std::list<operand_info> g_operands;
std::list<int> g_options;
std::list<int> g_wmma_options;
std::list<int> g_scalar_type;
// type specifier stuff:
memory_space_t g_space_spec;
memory_space_t g_ptr_spec;
int g_scalar_type_spec;
int g_vector_spec;
int g_extern_spec;
int g_func_decl;
int g_ident_add_uid;
unsigned g_const_alloc;
unsigned g_max_regs_per_thread;
symbol_table *g_global_symbol_table;
symbol_table *g_current_symbol_table;
symbol *g_last_symbol;
std::list<ptx_instruction*> g_instructions;
int g_error_detected;
unsigned g_entry_func_param_index;
function_info *g_func_info;
operand_info g_return_var;
bool g_debug_ir_generation;
int g_entry_point;
const struct core_config *g_shader_core_config;
std::map<std::string,std::map<unsigned,const ptx_instruction*> > g_inst_lookup;
// backward pointer
class gpgpu_context* gpgpu_ctx;
// member function list
void init_directive_state();
void init_instruction_state();
void start_function( int entry_point );
void add_function_name( const char *fname );
void add_directive();
void end_function();
void add_identifier( const char *s, int array_dim, unsigned array_ident );
void add_function_arg();
void add_scalar_type_spec( int type_spec );
void add_scalar_operand( const char *identifier );
void add_neg_pred_operand( const char *identifier );
void add_variables();
void set_variable_type();
void add_opcode( int opcode );
void add_pred( const char *identifier, int negate, int predModifier );
void add_1vector_operand( const char *d1 );
void add_2vector_operand( const char *d1, const char *d2 );
void add_3vector_operand( const char *d1, const char *d2, const char *d3 );
void add_4vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 );
void add_8vector_operand( const char *d1, const char *d2, const char *d3, const char *d4 ,const char *d5,const char *d6,const char *d7,const char *d8);
void add_option(int option );
void add_wmma_option(int option );
void add_builtin_operand( int builtin, int dim_modifier );
void add_memory_operand( );
void add_literal_int( int value );
void add_literal_float( float value );
void add_literal_double( double value );
void add_address_operand( const char *identifier, int offset );
void add_address_operand2( int offset );
void add_label( const char *idenfiier );
void add_vector_spec(int spec );
void add_space_spec( enum _memory_space_t spec, int value );
void add_ptr_spec( enum _memory_space_t spec );
void add_extern_spec();
void add_instruction();
void set_return();
void add_alignment_spec( int spec );
void add_array_initializer();
void add_file( unsigned num, const char *filename );
void add_version_info( float ver, unsigned ext);
void *reset_symtab();
void set_symtab(void*);
void add_pragma( const char *str );
void func_header(const char* a);
void func_header_info(const char* a);
void func_header_info_int(const char* a, int b);
void add_constptr(const char* identifier1, const char* identifier2, int offset);
void target_header(char* a);
void target_header2(char* a, char* b);
void target_header3(char* a, char* b, char* c);
void add_double_operand( const char *d1, const char *d2 );
void change_memory_addr_space( const char *identifier );
void change_operand_lohi( int lohi );
void change_double_operand_type( int addr_type );
void change_operand_neg( );
void set_immediate_operand_type( );
void version_header(double a);
void maxnt_id(int x, int y, int z);
void parse_error_impl( const char *file, unsigned line, const char *msg, ... );
void parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... );
//Jin: handle instructino group for cdp
void start_inst_group();
void end_inst_group();
bool check_for_duplicates( const char *identifier );
void read_parser_environment_variables();
void set_ptx_warp_size(const struct core_config * warp_size);
const class ptx_instruction *ptx_instruction_lookup( const char *filename, unsigned linenumber );
};
const char *decode_token( int type );
void read_parser_environment_variables();
#define NON_ARRAY_IDENTIFIER 1
#define ARRAY_IDENTIFIER_NO_DIM 2
#define ARRAY_IDENTIFIER 3
#endif
|
