Polaris: Program.cc Source File

Program.cc Go to the documentation of this file. /// #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif /// #include <stdio.h> #include <stdlib.h> #include <stream.h> #include <fstream.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include "Collection/KeyIterator.h" #include "EntryPoints.h" #include "Program.h" #include "ProgramTag.h" #include "utilities/lambda_util.h" #include "utilities/loopMark.h" #include "utilities/stmt_util.h" #include "utilities/switches_util.h" #include "VDL.h" #include "version.h" #include "mem_manager.h" #include "p-assert.h" template class TypedCollection<Program>; template class List<Program>; template ostream & operator << (ostream &, const List<Program> &); template class Assign<Program>; Program::Program() { #ifdef CLASS_INSTANCE_REGISTRY register_instance(PROGRAM, sizeof(Program), this); #endif } Program::Program(ProgramUnit *pgm) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(PROGRAM, sizeof(Program), this); #endif absorb( pgm ); } Program::Program(const Program &p) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(PROGRAM, sizeof(Program), this); #endif clear(); Database<String,ProgramUnit>::operator = ( p ); } Program & Program::operator = (const Program & p) { clear(); Database<String,ProgramUnit>::operator = ( p ); return (*this); } Program * Program::clone() const { return new Program( *this ); } Program::~Program() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(PROGRAM, this); #endif } void Program::absorb( ProgramUnit * pgm ) { String tag = pgm->tag_ref(); ins( tag, pgm ); } void Program::absorb(Program * p) { for (KeyIterator<String,ProgramUnit> iter = *p; iter.valid(); ++iter) { ProgramUnit *pgm = p->grab( iter.current_key() ); absorb( pgm ); } delete p; } EntryPoints * Program::entry_points() const { EntryPoints *ep = new EntryPoints; for (KeyIterator<String,ProgramUnit> iter = *this; iter.valid(); ++iter) { Iterator<Statement> entries = iter.current_data().stmts().stmts_of_type(ENTRY_STMT); if (! entries.valid()) { String name = ""; ep->ins( name, iter.current_data() ); } else { for (; entries.valid(); ++entries) { Statement &stmt = entries.current(); if (stmt.routine_valid()) { String name = stmt.routine_guarded().symbol().name_ref(); ep->ins( name, iter.current_data() ); } } } } return ep; } int Program::structures_OK() const { int rc = 1; for (KeyIterator<String,ProgramUnit> iter = *this; iter.valid(); ++iter) { if (! iter.current_data().structures_OK()) { rc = 0; cout << "Error in ProgramUnit"; } } return rc; } void Program::write(ostream & o) const { KeyIterator<String,ProgramUnit> iter = *this; if (switch_value( "burst_page" ) > 0) { o << "*\f" << "Polaris "; o << "v" << polaris_major_version << "." << polaris_minor_version; o << " Switches Database:" << endl; o << endl; dump_switches( o ); o << endl; } if (iter.valid()) { iter.current_data().write( o ); for (++iter; iter.valid(); ++iter) { o << endl; iter.current_data().write( o ); } } } void Program::print(ostream & o) const { KeyIterator<String,ProgramUnit> iter = *this; if (switch_value( "burst_page" ) > 0) { o << "*\f" << "Polaris "; o << "v" << polaris_major_version << "." << polaris_minor_version; o << " Switches Database:" << endl; o << endl; dump_switches( o ); o << endl; } if (iter.valid()) { iter.current_data().print( o ); for (++iter; iter.valid(); ++iter) { o << endl; iter.current_data().print( o ); } } } inline bool is_vdl(const char* fname){ String name=fname; if (name.index(".vdl")==name.len()-4){ return true; } else { return false; } } void Program::read(const char *fname) { BinRep vdl; String cmd; int x; if (switch_value("p_subst_fld") != 0) { set_subst_field_print(); } char *vname=(char*)fname; if (!is_vdl(fname)){ // char *vname = tempnam( "/tmp", "PVDL" ); // char *wname = tempnam( "/tmp", "PVDLW" ); /// ... /// ... previous 2 statement is replaced by following due to complainment from /// ... gcc 2.96 as: // /tmp/cceIAdb5.o(.text+0x17): the use of `tempnam' is dangerous, better use `mkstemp' vname = ( char * )malloc( 100 ); /// ... new char[100]; char *wname = ( char * )malloc( 100 ); /// ... new char[100]; strcpy( vname, "/tmp/PVDLXXXXXX" ); strcpy( wname, "/tmp/PVDLWXXXXXX" ); int vfid = mkstemp( vname ); int wfid = mkstemp( wname ); /// ... Allocate vname and wname using malloc(), these are temporary files /// ... File vname is for the VDL coming from the scanner. /// ... File wname is for any warnings coming from the scanner /// ... p_assert( vname, "can not allocate temporary file name" ); /// ... --> p_assert( vfid > -1, "can not allocate temporary file name" ); if ((x = switch_value("kap_scanner")) != 0) cmd = "p-kap-scanner"; else cmd = "p-scanner3 +vdl"; if ((x = switch_value("comments")) != 0) cmd += " +comment"; if ((x = switch_value("integer_len")) != 0) { change_default_type_size(INTEGER_TYPE, x); cmd += " -i"; char buffer[32]; sprintf( buffer, "%d", x ); cmd += buffer; } if ((x = switch_value("real_len")) != 0) { change_default_type_size(REAL_TYPE, x); cmd += " -r"; char buffer[32]; sprintf( buffer, "%d", x ); cmd += buffer; } if ((x = switch_value("logical_len")) != 0) { change_default_type_size(LOGICAL_TYPE, x); cmd += " -l"; char buffer[32]; sprintf( buffer, "%d", x ); cmd += buffer; } if ((x = switch_value("nolinelenwarn")) != 0) { cmd += " -nowarnlong "; } if ((x = switch_value("double_len")) != 0) { change_default_type_size(DOUBLE_PRECISION_TYPE, x); /// cmd += " -d"; /// cmd += dec( x ); } if ((x = switch_value("complex_len")) != 0) { change_default_type_size(COMPLEX_TYPE, x); /// cmd += " -c"; /// cmd += dec( x ); } cmd += " -o "; cmd += vname; cmd += " "; cmd += fname; cmd += " -e "; cmd += wname; system( cmd ); struct stat buf; stat(wname, &buf); if (buf.st_size == 0) { /// ... If the warnings file is empty, just delete it unlink( wname ); #ifdef CLASS_INSTANCE_REGISTRY pfree( wname ); #else free( wname ); #endif } else { /// ... Copy the warnings to cerr and delete the file ifstream warnings( wname ); char input; while (warnings) { warnings.get(input); cerr << input; } warnings.close(); unlink( wname ); #ifdef CLASS_INSTANCE_REGISTRY pfree( wname ); #else free( wname ); #endif } } /// ... Should be using the wait() call here to return the status of the /// ... system call. ifstream ifs( vname ); /// ... silvius: do not unlink if it was given as input. if (vname!=fname){ unlink( vname ); #ifdef CLASS_INSTANCE_REGISTRY pfree( vname ); #else free( vname ); #endif /// ... Deallocate vname using free(). } while (! ifs.eof()) { vdl.read( ifs ); if (vdl.is_set()) { ProgramTag tag; ProgramUnit *pgm = new ProgramUnit( tag, vdl ); if (pgm && pgm->stmts().entries() > 0) { pgm->stmts()._set_block_structure( pgm->stmts().first_ref(), pgm->stmts().last_ref(), "Program::read" ); pgm->stmts().create_assertions(); mark_loops_with_location(*pgm); remove_all_statement_functions(*pgm); } absorb( pgm ); } } } void Program::clean() { KeyIterator<String,ProgramUnit> iter = *this; for ( ; iter.valid(); ++iter) iter.current_data().clean(); } void Program::compute_call_lists() { RefDatabase<StringElem, ProgramUnit> entrydb; for (KeyIterator<String, ProgramUnit> piter = *this; piter.valid(); ++piter) { ProgramUnit & p = piter.current_data(); /// ... silvius: clear up old calls and called_by lists. p.calls().clear(); p.called_by().clear(); const char * namech = p.routine_name_ref(); StringElem * name = new StringElem(namech); entrydb.ins(*name, p); } for (KeyIterator<String, ProgramUnit> piter = *this; piter.valid(); ++piter) { ProgramUnit & p = piter.current_data(); /// ... silvius: find the ones that are actually called. /// ... The old method was giving wrong results after deadcode /// ... elimination (of routine calls). for(Iterator<Statement> stit=p.stmts().iterator(); stit.valid(); ++stit){ Statement& s=stit.current(); if (s.stmt_class()==CALL_STMT){ ProgramUnit* callee= entrydb.find_ref(s.routine_guarded().symbol().tag_ref()); if (callee) { p.add_call(*callee); callee->add_called_by(p); } } else { if (s.stmt_class()==ASSIGNMENT_STMT){ if (s.rhs().op()==FUNCTION_CALL_OP) { ProgramUnit* callee= entrydb.find_ref(s.rhs().function().symbol().tag_ref()); if (callee) { p.add_call(*callee); callee->add_called_by(p); } } } } } #if 0 for (DictionaryIter<Symbol> dictiter = p.symtab().iterator(); dictiter.valid(); ++dictiter) { Symbol & sym = dictiter.current_data(); /// ... Find the called routines by finding all EXTERNAL symbols mentioned if (((sym.sym_class() == SUBROUTINE_CLASS) || (sym.sym_class() == FUNCTION_CLASS)) && sym.external()) { const StringElem & name(sym.name_ref()); ProgramUnit * callee = entrydb.find_ref(name); if (callee) { p.add_call(*callee); callee->add_called_by(p); } } } #endif } }

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:06:02 2005