refactoring: moving PTX parsing functions into ptx_parser.*

[git-p4: depot-paths = "//depot/gpgpu_sim_research/fermi/distribution/": change = 7167]

1 files changed, 7 insertions, 668 deletions

diff --git a/src/cuda-sim/ptx_ir.cc b/src/cuda-sim/ptx_ir.cc
index 51ad05f..cd70daf 100644
--- a/src/cuda-sim/ptx_ir.cc
+++ b/src/cuda-sim/ptx_ir.cc
@@ -61,6 +61,7 @@
  * Vancouver, BC V6T 1Z4
  */
 
+#include "ptx_parser.h"
 #include "ptx_ir.h"
 #include "ptx.tab.h"
 #include "opcodes.h"
@@ -69,612 +70,8 @@
 #include <list>
 #include <assert.h>
 #include <algorithm>
-#include <stdarg.h>
 
 #include "cuda-sim.h"
-#include "../option_parser.h"
-
-extern "C" int ptx_error( const char *s );
-extern int ptx_lineno;
-
-// the program intermediate representation...
-symbol_table *g_global_symbol_table = NULL;
-std::map<std::string,symbol_table*> g_sym_name_to_symbol_table;
-static symbol_table *g_current_symbol_table = NULL;
-static std::list<ptx_instruction*> g_instructions;
-static symbol *g_last_symbol = NULL;
-
-int g_error_detected = 0;
-
-// type specifier stuff:
-memory_space_t g_space_spec = undefined_space;
-int g_scalar_type_spec = -1;
-int g_vector_spec = -1;
-int g_alignment_spec = -1;
-int g_extern_spec = 0;
-
-// variable declaration stuff:
-type_info *g_var_type = NULL;
-
-// instruction definition stuff:
-const symbol *g_pred;
-int g_neg_pred;
-symbol *g_label;
-int g_opcode = -1;
-std::list<operand_info> g_operands;
-std::list<int> g_options;
-std::list<int> g_scalar_type;
-
-#define DPRINTF(...) \
-   if( g_debug_ir_generation ) { \
-      printf(" %s:%u => ",g_filename,ptx_lineno); \
-      printf("   (%s:%u) ", __FILE__, __LINE__); \
-      printf(__VA_ARGS__); \
-      printf("\n"); \
-      fflush(stdout); \
-   }
-
-unsigned g_entry_func_param_index=0;
-function_info *g_func_info = NULL;
-function_info *g_entrypoint_func_info = NULL;
-symbol_table *g_entrypoint_symbol_table = NULL;
-std::map<unsigned,std::string> g_ptx_token_decode;
-operand_info g_return_var;
-
-void init_parser()
-{
-   g_global_symbol_table = g_current_symbol_table = new symbol_table("global",0,NULL);
-   ptx_lineno = 1;
-
-#define DEF(X,Y) g_ptx_token_decode[X] = Y;
-#include "ptx_parser_decode.def"
-#undef DEF
-}
-
-void init_directive_state()
-{
-   DPRINTF("init_directive_state");
-   g_space_spec=undefined_space;
-   g_scalar_type_spec=-1;
-   g_vector_spec=-1;
-   g_opcode=-1;
-   g_alignment_spec = -1;
-   g_extern_spec = 0;
-   g_scalar_type.clear();
-   g_operands.clear();
-   g_last_symbol = NULL;
-}
-
-void init_instruction_state()
-{
-   DPRINTF("init_instruction_state");
-   g_pred = NULL;
-   g_neg_pred = 0;
-   g_label = NULL;
-   g_opcode = -1;
-   g_options.clear();
-   g_return_var = operand_info();
-   init_directive_state();
-}
-
-extern void register_ptx_function( const char *name, function_info *impl, symbol_table *symtab );
-
-static int g_entry_point;
-
-void start_function( int entry_point ) 
-{
-   DPRINTF("start_function");
-   init_directive_state();
-   init_instruction_state();
-   g_entry_point = entry_point;
-   g_func_info = NULL;
-   g_entry_func_param_index=0;
-}
-
-char *g_add_identifier_cached__identifier = NULL;
-int g_add_identifier_cached__array_dim;
-int g_add_identifier_cached__array_ident;
-
-void add_function_name( const char *name ) 
-{
-   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 );
-   if( g_entry_point ) {
-      g_entrypoint_func_info = g_func_info;
-      g_entrypoint_symbol_table = g_current_symbol_table;
-   }
-   if( g_add_identifier_cached__identifier ) {
-      add_identifier( g_add_identifier_cached__identifier,
-                      g_add_identifier_cached__array_dim,
-                      g_add_identifier_cached__array_ident );
-      free( g_add_identifier_cached__identifier );
-      g_add_identifier_cached__identifier = NULL;
-      g_func_info->add_return_var( g_last_symbol );
-      init_directive_state();
-   }
-   if( prior_decl ) {
-      g_func_info->remove_args();
-   }
-   g_global_symbol_table->add_function( g_func_info );
-}
-
-void add_directive() 
-{
-   DPRINTF("add_directive");
-   init_directive_state();
-}
-
-#define mymax(a,b) ((a)>(b)?(a):(b))
-
-void end_function() 
-{
-   DPRINTF("end_function");
-
-   init_directive_state();
-   init_instruction_state();
-   g_max_regs_per_thread = mymax( g_max_regs_per_thread, (g_current_symbol_table->next_reg_num()-1)); 
-   g_func_info->add_inst( g_instructions );
-   g_instructions.clear();
-   gpgpu_ptx_assemble( g_func_info->get_name(), g_func_info );
-   g_current_symbol_table = g_global_symbol_table;
-
-   DPRINTF("function %s, PC = %d\n", g_func_info->get_name().c_str(), g_func_info->get_start_PC());
-}
-
-#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, ... )
-{
-   va_list ap;
-   char buf[1024];
-   va_start(ap,msg);
-   vsnprintf(buf,1024,msg,ap);
-   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);
-   abort();
-   exit(1);
-}
-
-void parse_assert_impl( int test_value, const char *file, unsigned line, const char *msg, ... )
-{
-   va_list ap;
-   char buf[1024];
-   va_start(ap,msg);
-   vsnprintf(buf,1024,msg,ap);
-   va_end(ap);
-
-   if ( test_value == 0 )
-      parse_error_impl(file,line, msg);
-}
-
-extern "C" char linebuf[1024];
-
-
-void set_return()
-{
-   parse_assert( (g_opcode == CALL_OP), "only call can have return value");
-   g_operands.front().set_return();
-   g_return_var = g_operands.front();
-}
-
-std::map<std::string,std::map<unsigned,const ptx_instruction*> > g_inst_lookup;
-
-const ptx_instruction *ptx_instruction_lookup( const char *filename, unsigned linenumber )
-{
-   std::map<std::string,std::map<unsigned,const ptx_instruction*> >::iterator f=g_inst_lookup.find(filename);
-   if( f == g_inst_lookup.end() ) 
-      return NULL;
-   std::map<unsigned,const ptx_instruction*>::iterator l=f->second.find(linenumber);
-   if( l == f->second.end() ) 
-      return NULL;
-   return l->second; 
-}
-
-void add_instruction() 
-{
-   DPRINTF("add_instruction: %s", ((g_opcode>0)?g_opcode_string[g_opcode]:"<label>") );
-   ptx_instruction *i = new ptx_instruction( g_opcode, 
-                                             g_pred, 
-                                             g_neg_pred, 
-                                             g_label, 
-                                             g_operands,
-                                             g_return_var,
-                                             g_options, 
-                                             g_scalar_type,
-                                             g_space_spec,
-                                             g_filename,
-                                             ptx_lineno,
-                                             linebuf );
-   g_instructions.push_back(i);
-   g_inst_lookup[g_filename][ptx_lineno] = i;
-   init_instruction_state();
-}
-
-void add_variables() 
-{
-   DPRINTF("add_variables");
-   if ( !g_operands.empty() ) {
-      assert( g_last_symbol != NULL ); 
-      g_last_symbol->add_initializer(g_operands);
-   }
-   init_directive_state();
-}
-
-void set_variable_type()
-{
-   DPRINTF("set_variable_type space_spec=%s scalar_type_spec=%s", 
-           g_ptx_token_decode[g_space_spec.get_type()].c_str(), 
-           g_ptx_token_decode[g_scalar_type_spec].c_str() );
-   parse_assert( g_space_spec != undefined_space, "variable has no space specification" );
-   parse_assert( g_scalar_type_spec != -1, "variable has no type information" ); // need to extend for structs?
-   g_var_type = g_current_symbol_table->add_type( g_space_spec, 
-                                                  g_scalar_type_spec, 
-                                                  g_vector_spec, 
-                                                  g_alignment_spec, 
-                                                  g_extern_spec );
-}
-
-bool check_for_duplicates( const char *identifier )
-{
-   const symbol *s = g_current_symbol_table->lookup(identifier);
-   return ( s != NULL );
-}
-
-extern std::set<std::string>   g_globals;
-extern std::set<std::string>   g_constants;
-
-int g_func_decl = 0;
-int g_ident_add_uid = 0;
-unsigned g_const_alloc = 1;
-
-void add_identifier( const char *identifier, int array_dim, unsigned array_ident ) 
-{
-   if( g_func_decl && (g_func_info == NULL) ) {
-      // return variable decl...
-      assert( g_add_identifier_cached__identifier == NULL );
-      g_add_identifier_cached__identifier = strdup(identifier);
-      g_add_identifier_cached__array_dim = array_dim;
-      g_add_identifier_cached__array_ident = array_ident;
-      return;
-   }
-   DPRINTF("add_identifier \"%s\" (%u)", identifier, g_ident_add_uid);
-   g_ident_add_uid++;
-   type_info *type = g_var_type;
-   type_info_key ti = type->get_key();
-   int basic_type;
-   int regnum;
-   size_t num_bits;
-   unsigned addr, addr_pad;
-   ti.type_decode(num_bits,basic_type);
-
-   bool duplicates = check_for_duplicates( identifier );
-   if( duplicates ) {
-      symbol *s = g_current_symbol_table->lookup(identifier);
-      g_last_symbol = s;
-      if( g_func_decl ) 
-         return;
-      std::string msg = std::string(identifier) + " was delcared previous at " + s->decl_location() + " skipping new declaration"; 
-      printf("GPGPU-Sim PTX: Warning %s\n", msg.c_str());
-      return;
-   }
-
-   assert( g_var_type != NULL );
-   switch ( array_ident ) {
-   case ARRAY_IDENTIFIER:
-      type = g_current_symbol_table->get_array_type(type,array_dim);
-      num_bits = array_dim * num_bits;
-      break;
-   case ARRAY_IDENTIFIER_NO_DIM:
-      type = g_current_symbol_table->get_array_type(type,(unsigned)-1);
-      num_bits = 0;
-      break;
-   default:
-      break;
-   }
-   g_last_symbol = g_current_symbol_table->add_variable(identifier,type,num_bits/8,g_filename,ptx_lineno);
-   switch ( ti.get_memory_space().get_type() ) {
-   case reg_space: {
-      regnum = g_current_symbol_table->next_reg_num();
-      int arch_regnum = -1;
-      for (int d = 0; d < strlen(identifier); d++) {
-         if (isdigit(identifier[d])) {
-            sscanf(identifier + d, "%d", &arch_regnum);
-            break;
-         }
-      }
-      if (strcmp(identifier, "%sp") == 0) {
-         arch_regnum = 0;
-      }
-      g_last_symbol->set_regno(regnum, arch_regnum);
-      } break;
-   case shared_space:
-      printf("GPGPU-Sim PTX: allocating shared region for \"%s\" from 0x%x to 0x%lx (shared memory space)\n",
-             identifier,
-             g_current_symbol_table->get_shared_next(),
-             g_current_symbol_table->get_shared_next() + num_bits/8 );
-      fflush(stdout);
-      assert( (num_bits%8) == 0  );
-      addr = g_current_symbol_table->get_shared_next();
-      addr_pad = num_bits ? (((num_bits/8) - (addr % (num_bits/8))) % (num_bits/8)) : 0;
-      g_last_symbol->set_address( addr+addr_pad );
-      g_current_symbol_table->alloc_shared( num_bits/8 + addr_pad );
-      break;
-   case const_space:
-      if( array_ident == ARRAY_IDENTIFIER_NO_DIM ) {
-         printf("GPGPU-Sim PTX: deferring allocation of constant region for \"%s\" (need size information)\n", identifier );
-      } else {
-         printf("GPGPU-Sim PTX: allocating constant region for \"%s\" from 0x%x to 0x%lx (global memory space) %u\n",
-                identifier,
-                g_current_symbol_table->get_global_next(),
-                g_current_symbol_table->get_global_next() + num_bits/8,
-                g_const_alloc++ );
-         fflush(stdout);
-         assert( (num_bits%8) == 0  ); 
-         addr = g_current_symbol_table->get_global_next();
-         addr_pad = num_bits ? (((num_bits/8) - (addr % (num_bits/8))) % (num_bits/8)) : 0;
-         g_last_symbol->set_address( addr + addr_pad );
-         g_current_symbol_table->alloc_global( num_bits/8 + addr_pad ); 
-      }
-      if( g_current_symbol_table == g_global_symbol_table ) { 
-         g_constants.insert( identifier ); 
-      }
-      assert( g_current_symbol_table != NULL );
-      g_sym_name_to_symbol_table[ identifier ] = g_current_symbol_table;
-      break;
-   case global_space:
-      printf("GPGPU-Sim PTX: allocating global region for \"%s\" from 0x%x to 0x%lx (global memory space)\n",
-             identifier,
-             g_current_symbol_table->get_global_next(),
-             g_current_symbol_table->get_global_next() + num_bits/8 );
-      fflush(stdout);
-      assert( (num_bits%8) == 0  );
-      addr = g_current_symbol_table->get_global_next();
-      addr_pad = num_bits ? (((num_bits/8) - (addr % (num_bits/8))) % (num_bits/8)) : 0;
-      g_last_symbol->set_address( addr+addr_pad );
-      g_current_symbol_table->alloc_global( num_bits/8 + addr_pad );
-      g_globals.insert( identifier );
-      assert( g_current_symbol_table != NULL );
-      g_sym_name_to_symbol_table[ identifier ] = g_current_symbol_table;
-      break;
-   case local_space:
-      if( g_func_info == NULL ) {
-         printf("GPGPU-Sim PTX: not allocating .local \"%s\" declared at global scope\n", identifier);
-         break;
-      }
-      printf("GPGPU-Sim PTX: allocating stack frame region for .local \"%s\" from 0x%x to 0x%lx\n",
-             identifier,
-             g_current_symbol_table->get_local_next(),
-             g_current_symbol_table->get_local_next() + num_bits/8 );
-      fflush(stdout);
-      assert( (num_bits%8) == 0  );
-      g_last_symbol->set_address( g_current_symbol_table->get_local_next() );
-      g_current_symbol_table->alloc_local( num_bits/8 );
-      g_func_info->set_framesize( g_current_symbol_table->get_local_next() );
-      break;
-   case tex_space:
-      printf("GPGPU-Sim PTX: encountered texture directive %s.\n", identifier);
-      break;
-   case param_space_local:
-      printf("GPGPU-Sim PTX: allocating stack frame region for .param \"%s\" from 0x%x to 0x%lx\n",
-             identifier,
-             g_current_symbol_table->get_local_next(),
-             g_current_symbol_table->get_local_next() + num_bits/8 );
-      fflush(stdout);
-      assert( (num_bits%8) == 0  );
-      g_last_symbol->set_address( g_current_symbol_table->get_local_next() );
-      g_current_symbol_table->alloc_local( num_bits/8 );
-      g_func_info->set_framesize( g_current_symbol_table->get_local_next() );
-      break;
-   case param_space_kernel:
-      break;
-   default:
-      abort();
-      break;
-   }
-
-   assert( !ti.is_param_unclassified() );
-   if ( ti.is_param_kernel() ) {
-      g_func_info->add_param_name_type_size(g_entry_func_param_index,identifier, ti.scalar_type(), num_bits );
-      g_entry_func_param_index++;
-   }
-}
-
-void add_function_arg()
-{
-   if( g_func_info ) {
-      DPRINTF("add_function_arg \"%s\"", g_last_symbol->name().c_str() );
-      g_func_info->add_arg(g_last_symbol);
-   }
-}
-
-void add_extern_spec() 
-{
-   DPRINTF("add_extern_spec");
-   g_extern_spec = 1;
-}
-
-void add_alignment_spec( int spec )
-{
-   DPRINTF("add_alignment_spec");
-   parse_assert( g_alignment_spec == -1, "multiple .align specifiers per variable declaration not allowed." );
-   g_alignment_spec = spec;
-}
-
-void add_space_spec( enum _memory_space_t spec, int value ) 
-{
-   DPRINTF("add_space_spec \"%s\"", g_ptx_token_decode[spec].c_str() );
-   parse_assert( g_space_spec == undefined_space, "multiple space specifiers not allowed." );
-   if( spec == param_space_unclassified ) {
-      if( g_func_decl ) {
-         if( g_entry_point == 1) 
-            g_space_spec = param_space_kernel;
-         else 
-            g_space_spec = param_space_local;
-      } else
-         g_space_spec = param_space_unclassified;
-   } else {
-      g_space_spec = spec;
-      if( g_space_spec == const_space )
-         g_space_spec.set_bank((unsigned)value);
-   }
-}
-
-void add_vector_spec(int spec ) 
-{
-   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 ) 
-{
-   DPRINTF("add_scalar_type_spec \"%s\"", g_ptx_token_decode[type_spec].c_str());
-   g_scalar_type.push_back( type_spec );
-   if ( g_scalar_type.size() > 1 ) {
-      parse_assert( (g_opcode == -1) || (g_opcode == CVT_OP) || (g_opcode == SET_OP) || (g_opcode == SLCT_OP)
-                    || (g_opcode == TEX_OP), 
-                    "only cvt, set, slct, and tex can have more than one type specifier.");
-   }
-   g_scalar_type_spec = type_spec;
-}
-
-void add_label( const char *identifier ) 
-{
-   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);
-   }
-}
-
-void add_opcode( int opcode ) 
-{
-   g_opcode = opcode;
-}
-
-void add_pred( const char *identifier, int neg ) 
-{
-   DPRINTF("add_pred");
-   const symbol *s = g_current_symbol_table->lookup(identifier);
-   if ( s == NULL ) {
-      std::string msg = std::string("predicate \"") + identifier + "\" has no declaration.";
-      parse_error( msg.c_str() );
-   }
-   g_pred = s;
-   g_neg_pred = neg;
-}
-
-void add_option( int option ) 
-{
-   DPRINTF("add_option");
-   g_options.push_back( option );
-}
-
-void add_2vector_operand( const char *d1, const char *d2 ) 
-{
-   DPRINTF("add_2vector_operand");
-   const symbol *s1 = g_current_symbol_table->lookup(d1);
-   const symbol *s2 = g_current_symbol_table->lookup(d2);
-   parse_assert( s1 != NULL && s2 != NULL, "v2 component(s) missing declarations.");
-   g_operands.push_back( operand_info(s1,s2,NULL,NULL) );
-}
-
-void add_3vector_operand( const char *d1, const char *d2, const char *d3 ) 
-{
-   DPRINTF("add_3vector_operand");
-   const symbol *s1 = g_current_symbol_table->lookup(d1);
-   const symbol *s2 = g_current_symbol_table->lookup(d2);
-   const symbol *s3 = g_current_symbol_table->lookup(d3);
-   parse_assert( s1 != NULL && s2 != NULL && s3 != NULL, "v3 component(s) missing declarations.");
-   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 ) 
-{
-   DPRINTF("add_4vector_operand");
-   const symbol *s1 = g_current_symbol_table->lookup(d1);
-   const symbol *s2 = g_current_symbol_table->lookup(d2);
-   const symbol *s3 = g_current_symbol_table->lookup(d3);
-   const symbol *s4 = g_current_symbol_table->lookup(d4);
-   parse_assert( s1 != NULL && s2 != NULL && s3 != NULL && s4 != NULL, "v4 component(s) missing declarations.");
-   g_operands.push_back( operand_info(s1,s2,s3,s4) );
-}
-
-void add_builtin_operand( int builtin, int dim_modifier ) 
-{
-   DPRINTF("add_builtin_operand");
-   g_operands.push_back( operand_info(builtin,dim_modifier) );
-}
-
-void add_memory_operand() 
-{
-   DPRINTF("add_memory_operand");
-   assert( !g_operands.empty() );
-   g_operands.back().make_memory_operand();
-}
-
-void add_literal_int( int value ) 
-{
-   DPRINTF("add_literal_int");
-   g_operands.push_back( operand_info(value) );
-}
-
-void add_literal_float( float value ) 
-{
-   DPRINTF("add_literal_float");
-   g_operands.push_back( operand_info(value) );
-}
-
-void add_literal_double( double value ) 
-{
-   DPRINTF("add_literal_double");
-   g_operands.push_back( operand_info(value) );
-}
-
-void add_scalar_operand( const char *identifier ) 
-{
-   DPRINTF("add_scalar_operand");
-   const symbol *s = g_current_symbol_table->lookup(identifier);
-   if ( s == NULL ) {
-      if ( g_opcode == BRA_OP ) {
-         // forward branch target...
-         s = g_current_symbol_table->add_variable(identifier,NULL,0,g_filename,ptx_lineno);
-      } else {
-         std::string msg = std::string("operand \"") + identifier + "\" has no declaration.";
-         parse_error( msg.c_str() );
-      }
-   }
-   g_operands.push_back( operand_info(s) );
-}
-
-void add_neg_pred_operand( const char *identifier ) 
-{
-   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);
-   }
-   operand_info op(s);
-   op.set_neg_pred();
-   g_operands.push_back( op );
-}
-
-void add_address_operand( const char *identifier, int offset ) 
-{
-   DPRINTF("add_address_operand");
-   const symbol *s = g_current_symbol_table->lookup(identifier);
-   if ( s == NULL ) {
-      std::string msg = std::string("operand \"") + identifier + "\" has no declaration.";
-      parse_error( msg.c_str() );
-   }
-   g_operands.push_back( operand_info(s,offset) );
-}
 
 unsigned symbol::sm_next_uid = 1;
 
@@ -781,13 +178,13 @@ symbol *symbol_table::add_variable( const char *identifier, const type_info *typ
    return s;
 }
 
-void symbol_table::add_function( function_info *func )
+void symbol_table::add_function( function_info *func, const char *filename, unsigned linenumber )
 {
    std::map<std::string, symbol *>::iterator i = m_symbols.find( func->get_name() );
    if( i != m_symbols.end() )
       return;
    char buf[1024];
-   snprintf(buf,1024,"%s:%u",g_filename,ptx_lineno);
+   snprintf(buf,1024,"%s:%u",filename,linenumber);
    type_info *type = add_type( func );
    symbol *s = new symbol(func->get_name().c_str(),type,buf,0);
    s->set_function(func);
@@ -883,12 +280,6 @@ unsigned operand_info::get_uid()
    return result;
 }
 
-void add_array_initializer()
-{
-   g_last_symbol->add_initializer(g_operands);
-}
-
-
 std::list<ptx_instruction*>::iterator function_info::find_next_real_instruction( std::list<ptx_instruction*>::iterator i)
 {
    while( (i != m_instructions.end()) && (*i)->is_label() ) 
@@ -1258,56 +649,6 @@ void function_info::print_basic_block_dot()
    printf("}\n");
 }
 
-extern "C" void add_version_info( float ver )
-{
-   g_global_symbol_table->set_ptx_version(ver,0);
-}
-
-
-extern "C" void add_file( unsigned num, const char *filename )
-{
-   if( g_filename == NULL ) {
-      char *b = strdup(filename);
-      char *l=b;
-      char *n=b;
-      while( *n != '\0' ) {
-          if( *n == '/' ) 
-              l = n+1;
-          n++;
-      }
-
-      char *p = strtok(l,".");
-      char buf[1024];
-      snprintf(buf,1024,"%s.ptx",p);
-
-      char *q = strtok(NULL,".");
-      if( q && !strcmp(q,"cu") ) {
-          g_filename = strdup(buf);
-      }
-
-      free( b );
-   }
-
-   g_current_symbol_table = g_global_symbol_table;
-}
-
-extern "C" void *reset_symtab()
-{
-   void *result = g_current_symbol_table;
-   g_current_symbol_table = g_global_symbol_table;
-   return result;
-}
-
-extern "C" void set_symtab(void*symtab)
-{
-   g_current_symbol_table = (symbol_table*)symtab;
-}
-
-extern "C" void add_pragma( const char *str )
-{
-   printf("GPGPU-Sim PTX: Warning -- ignoring pragma '%s'\n", str );
-}
-
 unsigned ptx_kernel_shmem_size( void *kernel_impl )
 {
    function_info *f = (function_info*)kernel_impl;
@@ -1350,7 +691,7 @@ unsigned type_info_key::type_decode( int type, size_t &size, int &basic_type )
    case TEXREF_TYPE: case SAMPLERREF_TYPE: case SURFREF_TYPE:
       size=32; basic_type=3; return 16;
    default: 
-      printf("ERROR ** type_decode() does not know about \"%s\"\n", g_ptx_token_decode[type].c_str() ); 
+      printf("ERROR ** type_decode() does not know about \"%s\"\n", decode_token(type) ); 
       assert(0); 
       return 0xDEADBEEF;
    }
@@ -1698,8 +1039,7 @@ void gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num )
        fprintf(fp,"%s",p);
        fclose(fp);
     }
-    g_filename = strdup(buf);
-    init_parser();
+    init_parser(buf);
     ptx__scan_string(p);
     int errors = ptx_parse ();
     if ( errors ) {
@@ -1716,9 +1056,9 @@ void gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num )
     }
 
     if ( g_debug_execution >= 100 ) 
-       print_ptx_file(p,source_num,g_filename);
+       print_ptx_file(p,source_num,buf);
 
-    printf("GPGPU-Sim PTX: finished parsing EMBEDDED .ptx file %s\n",g_filename);
+    printf("GPGPU-Sim PTX: finished parsing EMBEDDED .ptx file %s\n",buf);
 
     char fname[1024];
     snprintf(fname,1024,"_ptx_XXXXXX");
@@ -1772,7 +1112,6 @@ void gpgpu_ptx_sim_load_ptx_from_string( const char *p, unsigned source_num )
        printf("GPGPU-Sim PTX: ERROR ** while loading PTX (c) %d\n", result);
        exit(1);
     }
-    g_filename = NULL;
 }