Polaris: ProgramUnit.cc Source File

ProgramUnit.cc Go to the documentation of this file. /// /// \file ProgramUnit.cc /// #include "define.h" #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif #include <stdio.h> #include <time.h> #include <sys/time.h> #include "ProgramUnit.h" #include "Relinkable.h" #include "TranslateObject.h" #include "BinRep.h" #include "Collection/Iterator.h" #include "Collection/KeyIterator.h" #include "Collection/RefMap.h" #include "DDgraph.h" #include "ExprTable.h" #include "Statement/EntryStmt.h" #include "Symbol/ProgramSymbol.h" #include "version.h" #include "utilities/switches_util.h" #include "utilities/symbol_util.h" #include "wide_output.h" #include <set> template class RefList<ProgramUnit>; template class RefSet<ProgramUnit>; template class List<RefList<ProgramUnit> >; template class Iterator<ProgramUnit>; template class Iterator<RefList<ProgramUnit> >; template class Map<ProgramUnit,List<Expression> >; template class Map<ProgramUnit,RefList<Symbol> >; template class RefMap<ProgramUnit,ProgramUnit>; template class RefMap<ProgramUnit,Symbol>; template class Assign<RefList<ProgramUnit> >; template class TypedCollection<RefList<ProgramUnit> >; template class TypedBaseMap<ProgramUnit,List<Expression> >; template class TypedBaseMap<ProgramUnit,List<Symbol> >; template class TypedBaseMap<ProgramUnit,RefList<Symbol> >; template class TypedBaseRefMap<ProgramUnit,ProgramUnit>; template class TypedBaseRefMap<ProgramUnit,Symbol>; template class ProtoMap<ProgramUnit,List<Expression> >; template class ProtoMap<ProgramUnit,RefList<Symbol> >; template class ProtoRefMap<ProgramUnit,ProgramUnit>; template class ProtoRefMap<ProgramUnit,Symbol>; template class KeyIterator<ProgramUnit,List<Expression> >; template class KeyIterator<ProgramUnit,ProgramUnit>; template class KeyIterator<ProgramUnit,RefList<Symbol> >; template class KeyIterator<ProgramUnit,Symbol>; template ostream &operator << (ostream &, const List<RefList<ProgramUnit> > &); static const char *routine_type_names[NUM_PU_TYPES] = { "UNDEFINED ROUTINE TYPE", /// ... UNDEFINED_PU_TYPE "BLOCK DATA", /// ... BLOCK_DATA_PU_TYPE "PROGRAM", /// ... PROGRAM_PU_TYPE "SUBROUTINE", /// ... SUBROUTINE_PU_TYPE "FUNCTION" /// ... FUNCTION_PU_TYPE }; ProgramUnit::ProgramUnit(const ProgramUnit &p) : Definition(p._tag) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(PROGRAM_UNIT, sizeof(ProgramUnit), this); #endif _symtab = NULL; _data_list = NULL; _common_blocks = NULL; _namelists = NULL; _equivalences = NULL; _formats = NULL; _overflow = NULL; _ddgraph = NULL; _gsa_deflocs = NULL; _gsa_names = NULL; _ranges = NULL; _inline_map = NULL; #ifdef PERFORMANCE_EVAL _perf_estimator = NULL; #endif *this = p; } ProgramUnit & ProgramUnit::operator = (const ProgramUnit &p) { _routine_type = p._routine_type; _original_file = p._original_file; _work_stack = p._work_stack; delete _symtab; _symtab = p._symtab->clone(); delete _common_blocks; _common_blocks = p._common_blocks->clone(); delete _namelists; _namelists = p._namelists->clone(); delete _equivalences; _equivalences = p._equivalences->clone(); delete _formats; _formats = p._formats->clone(); delete _gsa_deflocs; delete _gsa_names; if (_ranges) { delete _ranges; _ranges = 0; /// ... For now, the RangeDict must be recomputed } if (_inline_map) { delete _inline_map; _inline_map = 0; } _formats->_pgm = this; if (_overflow != NULL) delete _overflow; _overflow = p._overflow->clone(); if (_data_list != NULL) delete _data_list; _data_list = p._data_list->clone(); _data_list->relink_ptrs(*this); _statements = p._statements; _statements._pgm = this; /// ... ORDER DEPENDENCY: Symtab relink requires StmtList to have been copied _symtab->relink_ptrs(*this); relink_all_lptrs((List<Statement> &) _statements, *this); _common_blocks->relink_ptrs(*this); _namelists->relink_ptrs(*this); _equivalences->relink_ptrs(*this); if (p.gsa_valid()) { _gsa_deflocs = new DefLocMap(*p._gsa_deflocs, *this); _gsa_names = new TranslateObject(*p._gsa_names, *this); } _multithread = p._multithread; /// ... _ #ifdef PERFORMANCE_EVAL _perf_estimator = p._perf_estimator; #endif return (*this); } ProgramUnit * ProgramUnit::clone() const { return new ProgramUnit( *this ); } Definition * ProgramUnit::definition_clone() const { return (Definition *) clone(); } ProgramUnit::ProgramUnit(const char *tag, PU_TYPE routine_type) : Definition(tag) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(PROGRAM_UNIT, sizeof(ProgramUnit), this); #endif _routine_type = routine_type; _symtab = new Symtab; _common_blocks = new CommonBlockDict; _namelists = new NamelistDict; _equivalences = new EquivalenceDict; _gsa_deflocs = NULL; _gsa_names = NULL; _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); _data_list = new DataList; _formats = new FormatDB( *this ); _statements._pgm = this; _formats->_pgm = this; _inline_map = NULL; _ddgraph = NULL; _ranges = NULL; #ifdef PERFORMANCE_EVAL _perf_estimator = NULL; #endif } ProgramUnit::ProgramUnit(const char *tag, const VDL & vdl_bs) : Definition(tag) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(PROGRAM_UNIT, sizeof(ProgramUnit), this); #endif _ddgraph = NULL; _ranges = NULL; _gsa_deflocs = NULL; _gsa_names = NULL; _inline_map = NULL; #ifdef PERFORMANCE_EVAL _perf_estimator = NULL; #endif if (vdl_bs.data_ref() != 0) { create_program_unit( *vdl_bs.data_ref() ); _statements._pgm = this; _formats->_pgm = this; } } ProgramUnit::ProgramUnit(const char *tag, const BinRep & bs) : Definition(tag) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(PROGRAM_UNIT, sizeof(ProgramUnit), this); #endif _ddgraph = NULL; _ranges = NULL; _gsa_deflocs = NULL; _gsa_names = NULL; create_program_unit( bs ); _statements._pgm = this; _formats->_pgm = this; _inline_map = NULL; #ifdef PERFORMANCE_EVAL _perf_estimator = NULL; #endif } void ProgramUnit::create_program_unit( const BinRep & bs ) { BinRep & dict = CASTAWAY(BinRep &) bs; Boolean errors = False; /// ... First, check if the BinRep contains a "messages" field which /// ... indicates that there were syntax errors or warnings in the the /// ... Fortran code. If that is the case, print out the errors. { if (dict.find_ref("messages")) { BinRep & messages = dict["messages"]; for (Iterator<BinRep> file_iter = messages.to_set(); file_iter.valid(); ++file_iter) { String curr_file; file_iter.current()[0].to_string(curr_file); cerr << endl; cerr << "In " << curr_file << endl; Iterator<BinRep> line_iter = file_iter.current()[1].to_tuple(); for (; line_iter.valid(); ++line_iter) { String event, msg; line_iter.current()[1].to_string(event); line_iter.current()[2].to_string(msg); cerr << " >>> " << event << " on line "; cerr << (line_iter.current()[0]).to_integer(); cerr << " " << msg << endl; } cerr << endl; } dict.del("messages"); errors = True; } } /// ... Now for the conversions. Most must take place in a fairly determined /// ... order. After each field is converted, it should be deleted from the /// ... dictionary so that what remains afterwards should all go into overflow. /// ... Get the file name. { if (dict.find_ref("file")) { if (dbx_program_debug_level >= 1) cout << "*ProgramUnit: Converting original_file ...."; dict["file"].to_string(_original_file); if (dbx_program_debug_level >= 1) cout << _original_file << endl; dict.del("file"); } } /// ... Get the routine type { if (dbx_program_debug_level >= 1) cout << "*ProgramUnit: Converting routine_type...."; String routine_type; if (! dict.find_ref("routine_type")) { if (errors) cerr << "\nPolaris aborted due to errors.\n\n"; else cerr << "\nPolaris aborted due to missing routine type.\n\n"; p_abort( "Abort."); } dict["routine_type"].to_string(routine_type); if (dbx_program_debug_level >= 1) cout << routine_type << endl; if (routine_type == "BLOCKDATA") _routine_type = BLOCK_DATA_PU_TYPE; else if (routine_type == "PROGRAM") _routine_type = PROGRAM_PU_TYPE; else if (routine_type == "SUBROUTINE") _routine_type = SUBROUTINE_PU_TYPE; else if (routine_type == "FUNCTION") _routine_type = FUNCTION_PU_TYPE; else { cerr << "Error: ProgramUnit: Unrecognized routine type '" << routine_type << "'\n"; } dict.del("routine_type"); } /// ... Do the initial conversion of the symbol table if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: First pass over symbol table.\n"; } _symtab = new Symtab( dict["symtab"] ); /// ... Don't delete the "symtab" field from dict yet--we need another /// ... pass on it first /// ... Create a temporary expression table if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: Gathering expression table....\n"; } ExprTable exprs( dict["expression"], *_symtab); dict.del("expression"); if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: " << "Translating/creating Dictionary<VoidPtrDef> for stmts....\n"; } if (dict.find_ref("final_statement")) { /// ... (No reason to directly translate this) dict.del("final_statement"); } /// ... Read in the formats, if any if (dict.find_ref("formats")) { if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: Converting Formats....\n"; } _formats = new FormatDB( *this, dict["formats"] ); dict.del("formats"); } else { _formats = new FormatDB( *this ); } /// ... Read in the namelists, if any if (dict.find_ref("namelist_blocks")) { if (dbx_program_debug_level >= 1) cout << "*ProgramUnit: Converting Namelists....\n"; _namelists = new NamelistDict( dict["namelist_blocks"], *_symtab); dict.del("namelist_blocks"); } else { _namelists = new NamelistDict; } if (dict.find_ref("initial_statement")) { String init_stmt; dict["initial_statement"].to_string(init_stmt); dict.del("initial_statement"); /// ... Convert the statement list if (dbx_program_debug_level >= 1) cout << "*ProgramUnit: Converting statements....\n"; _statements.convert( dict["statements"], exprs, *_symtab, *_namelists, *_formats, init_stmt); if (dict.find_ref("statements")) dict.del("statements"); } else { /// ... No "initial_statement" field was found. It could only then be /// ... a block data program unit p_assert( _routine_type == BLOCK_DATA_PU_TYPE || _routine_type == PROGRAM_PU_TYPE, "the statement list is empty, not a BLOCKDATA or PROGRAM"); dict.del("statements"); } /// ... Read in the equivalences, if any if (dict.find_ref("equivalences")) { if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: Converting equivalences....\n"; } _equivalences = new EquivalenceDict( dict["equivalences"], *_symtab); dict.del("equivalences"); } else { _equivalences = new EquivalenceDict; } /// ... Read in the common blocks, if any if (dict.find_ref("common_blocks")) { if (dbx_program_debug_level >= 1) cout << "*ProgramUnit: Converting Common Blocks....\n"; _common_blocks = new CommonBlockDict( dict["common_blocks"], *_symtab); dict.del("common_blocks"); } else { _common_blocks = new CommonBlockDict; } /// ... Read in the data statements, if any if (dict.find_ref("data_expr")) { if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: Converting DATA statement info....\n"; } _data_list = new DataList( dict["data_expr"], exprs); dict.del("data_expr"); } else { _data_list = new DataList; } /// ... Prepare VoidPtrDef dictionaries for fillining in the symbol table. Dictionary<VoidPtrDef> equiv_dict, common_dict, namelist_dict; { if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: " << "Preparing Dictionary<VoidPtrDef> of Common Blocks....\n"; } KeyIterator<String,CommonBlock> iter = *_common_blocks; for (; iter.valid(); ++iter) { common_dict.ins(new VoidPtrDef(iter.current_data().name_ref(), &iter.current_data())); } } { if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: " << "Preparing Dictionary<VoidPtrDef> of Namelists....\n"; } KeyIterator<String,Namelist>iter = *_namelists; for (; iter.valid(); ++iter) { namelist_dict.ins(new VoidPtrDef(iter.current_data().name_ref(), &iter.current_data())); } } { if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: " << "Preparing Dictionary<VoidPtrDef> of Equivalences....\n"; } KeyIterator<String,Equivalence> iter = *_equivalences; for ( ; iter.valid(); ++iter) { equiv_dict.ins(new VoidPtrDef(iter.current_data().name_ref(), &iter.current_data())); } } /// ... Fill in the symbol table now that everything else has been /// ... converted. Then delete that field from dict. if (dbx_program_debug_level >= 1) cout << "*ProgramUnit: Filling in the Symbol Table....\n"; _symtab->fill_in( dict["symtab"], exprs, *(stmts()._stmt_tag_dict), common_dict, equiv_dict); dict.del("symtab"); /// ... Stick everything else into overflow _overflow = new BinRep; Set<BinRep> *S = new Set<BinRep>; _overflow->put_set( S ); if (dbx_program_debug_level >= 1) { cout << "*ProgramUnit: " << "Putting anything else into overflow fields....\n"; } { for (Iterator<BinRep> iter = dict.to_set(); iter.valid(); ++iter) { warn_overflow_map("ProgramUnit", iter.current() ); _overflow->ins( iter.current() ); } } /// ... Check whether there is a PROGRAM statement or not /// ... If not, add one! Iterator<Statement> entries = _statements.stmts_of_type(ENTRY_STMT); if ((!entries.valid()) && (pu_class() == PROGRAM_PU_TYPE)) { String new_entry_name = "MAIN"; Symbol *pgm_name = symtab().find_ref(new_entry_name); if (pgm_name) { while (symtab().find_ref(new_entry_name)) { pgm_name->renaming_suggestion(new_entry_name); } } pgm_name = new ProgramSymbol(new_entry_name, 0); Statement *entry_stmt = new EntryStmt(_statements.new_tag(), id(*pgm_name), comma()); pgm_name->entry(entry_stmt); symtab().ins(pgm_name); entry_stmt->routine(id(*pgm_name)); /// ... The following will only find the FLOW_ENTRY_STMT because /// ... we proved above that there are no ENTRY_STMTs in the program unit! Iterator<Statement> flowiter = _statements.iterate_entry_points(); p_assert(flowiter.valid(), "ProgramUnit missing FLOW_ENTRY_STMT"); _statements.ins_after(entry_stmt, &flowiter.current()); } stmts().create_flow_graph(); /// ... Fill in the dimension entry in the 'Type' field of a Symbol _propagate_symbol_dimensions(); /// ... Propagate size and dimension information from Types found in /// ... VariableSymbols to all expressions. _propagate_types(); } /// Propagate dimension information from the symbol table to every /// expression in the ProgramUnit. void ProgramUnit::_propagate_types() { for (Iterator<Statement> stmt_iter = stmts().iterator(); stmt_iter.valid(); ++stmt_iter) { Statement & s = stmt_iter.current(); for (Iterator<Expression> expr_iter = s.iterate_expressions(); expr_iter.valid(); ++expr_iter) { propagate_expr_types(expr_iter.current()); } if (stmt_iter.current().stmt_class() == RETURN_STMT) { /// ... Set Function symbol type to type of return expr? } } } /// Update the Type field of each symbol with specific dimension data void ProgramUnit::_propagate_symbol_dimensions() { for (DictionaryIter<Symbol> sym = symtab().iterator(); sym.valid(); ++sym) { Symbol & s = sym.current_data(); switch (s.sym_class()) { case VARIABLE_CLASS: { Type & sym_type = CASTAWAY(Type &) s.type(); sym_type.rank_known( True ); sym_type.redimension( s.dim().entries() ); } break; default: break; } } } ProgramUnit::~ProgramUnit() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(PROGRAM_UNIT, this); #endif if (_ddgraph) delete _ddgraph; if (_data_list) delete _data_list; if (_ranges) delete _ranges; if (_inline_map) delete _inline_map; delete _common_blocks; delete _namelists; delete _equivalences; delete _formats; delete _overflow; delete _gsa_deflocs; delete _gsa_names; delete _symtab; } const char * ProgramUnit::pu_tag_ref() const { return _tag; } void ProgramUnit::burst_header( ostream &o ) const { static time_t t = 0; if (switch_value( "burst_header" ) > 0) { o << "*\f"; o << " * V" << polaris_major_version << "." << polaris_minor_version; if (t == 0) time( &t ); char *c = ctime( &t ); c[ strlen(c)-1 ] = ' '; o << " * DATE: " << c; if (_original_file.defined()) o << " * FILE: " << _original_file; o << endl; } } void ProgramUnit::display(ostream & o) const { const int space_for_label = 6; if (_original_file.defined()) o << "FILE: " << _original_file << endl; _symtab->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); _common_blocks->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); _equivalences->write(o, space_for_label, FORTRAN_MAX_LINE_LEN, *_symtab); _data_list->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); _namelists->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); /// ... Statement list _statements.display(o); _formats->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); } void ProgramUnit::write(ostream & o) const { const int space_for_label = 0; burst_header( o ); Iterator<Statement> entries = _statements.stmts_of_type(ENTRY_STMT); if (entries.valid()) { int ind = 0; /// ... entries.current() is the first entry statement blank_wide_output( o ); entries.current().write(o, ind, (char *)routine_type_names[pu_class()]); } else if (pu_class() == BLOCK_DATA_PU_TYPE) { blank_wide_output( o ); o << " BLOCK DATA\n"; } _symtab->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); _common_blocks->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); _equivalences->write(o, space_for_label, FORTRAN_MAX_LINE_LEN, *_symtab); _data_list->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); _namelists->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); _statements.write(o); _formats->write(o, space_for_label, FORTRAN_MAX_LINE_LEN); blank_wide_output( o ); o << " END\n"; } void ProgramUnit::display_debug(ostream & o) const { /// ... const int space_for_label = 6; if (_routine_type < 0 || _routine_type >= NUM_PU_TYPES) { cerr << "Error: ProgramUnit: display(): Unknown routine type: " << _routine_type << endl; p_abort( "(see above message)" ); } display(o); /// ... Symbol table o << "\nSymtab:\n" << *_symtab << endl; /// ... Equivalences o << "\nEquivalences:\n" << *_equivalences << endl; /// ... Common Blocks o << "\nCommon Blocks:\n" << *_common_blocks << endl; /// ... Data o << "\nData:\n" << *_data_list << endl; /// ... Namelists o << "\nNamelists:\n" << *_namelists << endl; /// ... Formats o << "\nFormats:\n" << *_formats << endl; /// ... overflow o << "\nOverflow:\n" << *_overflow << endl; } ostream & operator << (ostream & o, const ProgramUnit & pr) { pr.display(o); return o; } void ProgramUnit::print(ostream & o) const { display(o); } int ProgramUnit::structures_OK() const { cout << "Testing ProgramUnit structures....\n"; if ( !_statements.structures_OK() /// ... xxx || ! _symtab->structures_OK() /// ... xxx || ! _data->structures_OK() || !_common_blocks->structures_OK() || !_namelists->structures_OK() || !_equivalences->structures_OK() /// ... xxx || ! _formats->_structures_OK() /// ... xxx || ! (_overflow == 0 || _overflow->_structures_OK()) ) { cerr << "\n\n**** Error found in structure of pgm:" << flush << endl; cerr << *this << endl << endl; return 0; } return 1; } const char * ProgramUnit::routine_name_ref() const { Iterator<Statement> entries = stmts().stmts_of_type(ENTRY_STMT); if (entries.valid()) { /// ... entries.current() is the first entry statement if (entries.current().routine_valid()) return entries.current().routine_guarded().symbol().name_ref(); } /// ... No entry statements found return ""; } const char * ProgramUnit::original_file_ref() const { return ((_original_file.defined()) ? (const char *) _original_file : 0); } void ProgramUnit::clean_workspace(unsigned int pass_tag) { work_stack().pop(pass_tag); Iterator<Statement> iter = stmts().iterator(); for ( ; iter.valid(); ++iter) iter.current().work_stack().pop(pass_tag); } //------------------------------------------------------------------------ typedef set<const Symbol*> SymbolSet; static void collect_all_symbols(const Expression &e, SymbolSet &used ) { if (e.op() != ID_OP) { for (Iterator<Expression> iter = e.arg_list(); iter.valid(); ++iter) collect_all_symbols( iter.current(), used ); } else { const Symbol & sym = e.symbol(); if (used.find( &sym ) == used.end()) { used.insert( &sym); switch (sym.sym_class()) { case VARIABLE_CLASS: if (sym.is_array()) { for (Iterator<ArrayBounds> iter = sym.dim(); iter.valid(); ++iter) { ArrayBounds & ad = iter.current(); if (ad.lower_exists()) collect_all_symbols( ad.lower_guarded(), used ); if (ad.upper_exists()) collect_all_symbols( ad.upper_guarded(), used ); } } break; case SYMBOLIC_CONSTANT_CLASS: if (sym.expr_ref()) collect_all_symbols( *sym.expr_ref(), used ); break; default: break; } } } } void ProgramUnit::clean() { SymbolSet used; SymbolSet assertion_symbols; /// ... Look at all of the statements and the expressions in them and /// ... collect the variables which are used. for (Iterator<Statement> st_iter = this->stmts().iterator(); st_iter.valid(); ++st_iter) { Statement & st = st_iter.current(); for (Iterator<Expression> e_iter = st.iterate_expressions(); e_iter.valid(); ++e_iter) { Expression &e = e_iter.current(); /// ... Find all symbol references in e and add to used. collect_all_symbols( e, used ); } if (st.s_control_valid()) { for (Iterator<s_control_type> sc_iter = st.s_control_guarded(); sc_iter.valid(); ++sc_iter) { for (Iterator<Expression> e_iter = sc_iter.current().expr; e_iter.valid(); ++e_iter) { Expression &e = e_iter.current(); collect_all_symbols( e, used ); } } } for (Iterator<Assertion> a_iter = st.assertions(); a_iter.valid(); ++a_iter) { Assertion & a = a_iter.current(); if (a.arg_list_valid()) { for (Iterator<Expression> e_iter = a.arg_list_guarded(); e_iter.valid(); ++e_iter) { Expression &e = e_iter.current(); collect_all_symbols( e, used ); } } } } /// ... Examine the DATA statements. /// ... assume for now that all DATA is used. { for (Iterator<Data> iter = this->data(); iter.valid(); ++iter) { collect_all_symbols( iter.current().variable_list(), used ); collect_all_symbols( iter.current().value_list(), used ); } } /// ... Examine the COMMON blocks. /// ... assume for now that all COMMON variables are used. { for (DictionaryIter<CommonBlock> iter = this->common_blocks(); iter.valid(); ++iter) { for (Iterator<Symbol> sym_iter = iter.current().iterator(); sym_iter.valid(); ++sym_iter) { Symbol & sym = sym_iter.current(); if (used.find( &sym ) == used.end()) used.insert( &sym ); } } } /// ... Examine the NAMELIST blocks. /// ... assume for now that all NAMELIST variables are used. { for (DictionaryIter<Namelist> iter = this->namelists(); iter.valid(); ++iter) { for (Iterator<Symbol> sym_iter = iter.current().iterator(); sym_iter.valid(); ++sym_iter) { Symbol & sym = sym_iter.current(); if (used.find( &sym ) == used.end() ) used.insert( &sym ); } } } /// ... Examine symbols in the symbol table, gathering symbolic constants /// ... used to declare the dimensions of arrays. { for (DictionaryIter<Symbol> symscn = this->_symtab->iterator(); symscn.valid(); ++symscn) { Symbol &sym = symscn.current(); if (sym.is_array()) { RefSet<Symbol> symb_const; collect_symb_const(symb_const, sym.dim()); for (Iterator<Symbol> siter = symb_const; siter.valid(); ++siter) { Symbol & constant = siter.current(); used.insert(&constant); } } else if (sym.expr_ref()) { /// ... Added this section to make sure symbols of type /// ... SYMBOLIC_CONSTANT_CLASS have been inserted into /// ... the SymTab. Without this section, those variables /// ... that are declared in 'parameter' without being used /// ... in the code body cause "undefined string" in the // generated code. 12/16/99. Vinh collect_all_symbols (*sym.expr_ref (), used); } } } /// ... Now, check to see if there are any symbols whose only /// ... references are in assertions. /// We cannot just remove things from the symbol table which are only /// referenced in assertions - if we did, then the references would /// not print properly. We also must delete the stuff from the assertions. /// The problem is that deleting the symbols from the assertions is /// very difficult, if not impossible. For now, we will just hope it /// does not occur. /// /// for (KeyIterator<Symbol,Assertion> a_iter = sym_to_assert; // a_iter.valid(); // ++a_iter) { /// // Symbol & sym = a_iter.current_key(); // // if (used.find_ref( sym ) == 0) { /// /// ... it is not used outside the assertions, // /// ... so lets remove it from the Symtab. /// // if (sym.common_ref()) // sym.clear_common(); /// /// if (sym.equivalence_ref()) { /// Equivalence *eq = sym.equivalence_ref(); /// sym.clear_equivalence(); /// /// /// ... Rebuild the EQUIVALENCE classes if necessary. /// this->equivalences().clean( *eq ); /// } /// /// this->symtab().del( a_iter.current_key().name_ref() ); // } /// } /// ... Now go through the symbol table and remove anything we have not /// ... already found. for (DictionaryIter<Symbol> iter = this->symtab().iterator(); iter.valid(); ++iter) { Symbol & sym = iter.current_data(); if (used.find( &sym ) == used.end() ) { /// ... it is not used so lets remove it from the Symtab. if (sym.common_ref()) sym.clear_common(); if (sym.equivalence_ref()) { Equivalence *eq = sym.equivalence_ref(); sym.clear_equivalence(); /// ... Rebuild the EQUIVALENCE classes if necessary. this->equivalences().clean( *eq ); } this->symtab().del( iter.current_key() ); } } } BinRep * ProgramUnit::exchange() { VDL vdl; vdl.start_object(); vdl.start_set(); vdl.end_set(); vdl.end_object(); BinRep *b = CASTAWAY(BinRep *) vdl.data_ref(); if (b != 0) { List<BinRep> *L = new List<BinRep>; L->ins_last( new BinRep( "routine_type" ) ); L->ins_last( new BinRep( (char *) routine_type_names[pu_class()] )); b->to_set().ins( new BinRep( L ) ); } if (_original_file.defined()) { List<BinRep> *L = new List<BinRep>; L->ins_last( new BinRep( "file" ) ); L->ins_last( new BinRep( _original_file ) ); b->to_set().ins( new BinRep( L ) ); } { List<BinRep> *L = new List<BinRep>; L->ins_last( new BinRep( "expression" ) ); L->ins_last( new BinRep( new List<BinRep> )); b->to_set().ins( new BinRep( L ) ); } symtab().exchange_convert( vdl ); common_blocks().exchange_convert( vdl ); equivalences().exchange_convert( vdl ); data().exchange_convert( vdl ); formats().exchange_convert( vdl ); namelists().exchange_convert( vdl ); stmts().exchange_convert( vdl ); if (_overflow != 0) { for (Iterator<BinRep> iter = _overflow->to_set(); iter.valid(); ++iter) vdl.data_ref()->to_set().ins( iter.current().clone() ); } return vdl.give_up_data(); } void ProgramUnit::ddgraph(DDgraph *ddg) { if (_ddgraph) delete _ddgraph; _ddgraph = ddg; } void ProgramUnit::gsa_deflocs(DefLocMap * new_map) { delete _gsa_deflocs; _gsa_deflocs = new_map; } void ProgramUnit::gsa_names(TranslateObject * new_names) { delete _gsa_names; _gsa_names = new_names; } void ProgramUnit::function_to_subroutine() { p_assert(_routine_type == FUNCTION_PU_TYPE, "ProgramUnit::function_to_subroutine: isn't a function"); _routine_type = SUBROUTINE_PU_TYPE; } void ProgramUnit::subroutine_to_function() { p_assert(_routine_type == SUBROUTINE_PU_TYPE, "ProgramUnit::subroutine_to_function: isn't a subroutine"); _routine_type = FUNCTION_PU_TYPE; } void ProgramUnit::program_to_subroutine() { p_assert(_routine_type == PROGRAM_PU_TYPE, "ProgramUnit::program_to_subroutine: isn't a program"); _routine_type = SUBROUTINE_PU_TYPE; } //_ Expression * ProgramUnit::distribution_of(Symbol *sym) { if (sym->sym_class() != VARIABLE_CLASS) return 0; Iterator<Assertion> iter = _statements.first().assertions(); for (; iter.valid(); ++iter) if (iter.current().type() == AS_SHARED) break; if (!iter.valid()) /// ... No shared vairables in this PU. return 0; /// ... Search the shared assertion for the matching symbol for (Iterator<Expression> eiter = iter.current().arg_list_guarded(); eiter.valid(); ++eiter) if (eiter.current().op() == DISTRIBUTE_OP && sym == &eiter.current().symbol()) return &eiter.current(); /// ... Found return 0; }

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