Polaris: ProgramUnit.h Source File

ProgramUnit.h Go to the documentation of this file. /// #ifndef _PROGRAM_UNIT_H #define _PROGRAM_UNIT_H /// /// \class ProgramUnit /// \brief a class for Fortran program units /// \defgroup Base /// \ingroup Base /// General utility routines /// \see ProgramUnit.h /// \see ProgramUnit.cc /// \see ProgramUnit.h /// /// \endcode /// \section Description Description /// This class represents a Fortran program unit and contains /// all of the major structures of such an object. It also /// contains the statement copying/deleting/insertion /// routines as well as some block listing routines /// such as iterate_loop_body() /// /// \endcode /// \section KNOWN KNOWN/POSSIBLE BUGS/LIMITATIONS /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// #include "ClassNames.h" #include "DataList.h" #include "define.h" #include "EquivalenceDict.h" #include "Expression/Expression.h" #include "FormatDB.h" #include "Collection/List.h" #include "InlineObject.h" #include "Symtab.h" #include "BinRep.h" #include "PredicateRepository.h" #include "Range/RangeDict.h" #include "Statement/Statement.h" #include "StmtList.h" #include "VDL.h" #include "Collection/RefList.h" #include "Collection/Iterator.h" #include "Namelist.h" #include "NamelistDict.h" #include "DefLocMap.h" /// class DDgraph; class TranslateObject; #ifdef PERFORMANCE_EVAL class PerformanceEstimator; #endif ///< Program Unit Types enum PU_TYPE { UNDEFINED_PU_TYPE = 0, BLOCK_DATA_PU_TYPE, PROGRAM_PU_TYPE, SUBROUTINE_PU_TYPE, FUNCTION_PU_TYPE, NUM_PU_TYPES }; class Program; class ProgramUnit : public Definition { friend class Program; protected: PU_TYPE _routine_type; String _original_file; StmtList _statements; Symtab *_symtab; DataList *_data_list; DDgraph *_ddgraph; CommonBlockDict *_common_blocks; NamelistDict *_namelists; EquivalenceDict *_equivalences; FormatDB *_formats; DefLocMap *_gsa_deflocs; TranslateObject *_gsa_names; PredicateRepository _repository; RefSet<ProgramUnit> _calls; ///< ProgramUnits this ProgramUnit calls RefSet<ProgramUnit> _called_by; ///< ProgramUnits which call this ProgramUnit #ifdef PERFORMANCE_EVAL PerformanceEstimator *_perf_estimator; #endif Map<Statement,InlineObject> * _inline_map; RangeDict *_ranges; BinRep *_overflow; int _multithread; ///<_ WorkSpaceStack _work_stack; ///< Stack of WorkSpaces for this program unit. void create_program_unit( const BinRep & bs ); void _propagate_symbol_dimensions(); void _propagate_types(); void _propagate_types(Expression &); public: ProgramUnit(const char *pu_tag, PU_TYPE routine_type); ProgramUnit(const ProgramUnit & p); ProgramUnit(const char *pu_tag, const BinRep & bs); ProgramUnit(const char *pu_tag, const VDL & vdl_bs); ProgramUnit & operator = ( const ProgramUnit & pgm); virtual ProgramUnit *clone() const; ///< Return (and give control of) a new ProgramUnit which has ///< been copied from this one. virtual ~ProgramUnit(); void burst_header( ostream &o ) const; ///< Issue a page break and header information is the switch is ///< enabled. const char *pu_tag_ref() const; ///< Returns the pu_tag of the program unit (not to be confused with ///< the routine_name). The pu_tag has nothing to do with the ///< Fortran source, but is just an identifier useful in ///< has tables, etc. PU_TYPE pu_class() const; ///< Returns the flavor of program unit const char *routine_name_ref() const; ///< Returns the name of this ProgramUnit, if there is such a ///< name (otherwise returns an empty string [""]), collected ///< from the Fortran source. I.e. if this program unit is ///< a SUBROUTINE called "SUB1", then routine_name_ref() returns ///< "SUB1". This information is obtained by grabbing the ///< the first ENTRY statement in the program, if any. const char *original_file_ref() const; ///< Return a character pointer to the file from which this routine ///< was obtained. const StmtList &stmts() const; StmtList &stmts(); ///< The Statement list. const Symtab &symtab() const; Symtab &symtab(); ///< The Symbol table. const DataList &data() const; DataList &data() ; ///< The List of DATA statements. const CommonBlockDict &common_blocks() const; CommonBlockDict &common_blocks(); ///< The List of COMMON blocks. const NamelistDict &namelists() const; NamelistDict &namelists() ; ///< The NAMELIST dictionary. const EquivalenceDict &equivalences() const; EquivalenceDict &equivalences(); ///< The EQIUVALENCE dictionary. const FormatDB &formats() const; FormatDB &formats(); ///< The FORMAT database. PredicateRepository & pred_repos(); ///< Repository for AbstractAccess predicates for this ProgramUnit #ifdef PERFORMANCE_EVAL PerformanceEstimator *perf_estimator(); void set_perf_estimator(PerformanceEstimator *pe); ///< Performance estimation data #endif const WorkSpaceStack &work_stack() const; WorkSpaceStack &work_stack(); ///< The stack of WorkSpaces for the ProgramUnit. BinRep *overflow_ref() const; ///< Any unrecognized interchange objects. DDgraph &ddgraph(); ///< Outmoded. Call ddgraph_guarded() instead. DDgraph &ddgraph_guarded(); ///< Return a reference to the DDgraph associated with the program. Boolean ddgraph_valid(); ///< Return true if the program unit has a ddgraph. void ddgraph(DDgraph *ddg); ///< Set my DDgraph to the given object. const DefLocMap &gsa_deflocs_guarded() const; DefLocMap &gsa_deflocs_guarded(); ///< Return a reference to the DefLocMap associated with the program ///< (which must be in GSA form) const TranslateObject & gsa_names_guarded() const; TranslateObject & gsa_names_guarded(); ///< Return a reference to the TranslateObject associated with the program ///< (which must be in GSA form) bool gsa_valid() const; ///< Is ProgramUnit in gsa form or not? void gsa_deflocs(DefLocMap * new_map); ///< Set my DefLocMap to the given object (or NULL) void gsa_names(TranslateObject * new_names); ///< Set my TranslateObject to the given object (or NULL) Map<Statement,InlineObject> & inline_map_guarded(); ///< Return a reference to the inline_map for this ProgramUnit bool inline_map_valid(); ///< Does the inline_map exist? void inline_map(Map<Statement,InlineObject> *map); ///< Assign inline_map for this ProgramUnit RangeDict & range_dict_guarded(); ///< Give access to the Range Dictionary in the ProgramUnit bool range_dict_valid(); ///< Does the range dictionary exist? void range_dict(RangeDict * rdict); ///< Record the Range Dictionary for this ProgramUnit RefSet<ProgramUnit> & calls(); RefSet<ProgramUnit> & called_by(); void add_call(ProgramUnit & pgm); void add_called_by(ProgramUnit & pgm); void multithread(); void singlethread(); void undefined_thread(); ///<_ Set _multithread flag to True/False/No(initalized value) int is_multithread() const; int is_thread_defined() const; ///<_ If True, this programunit has some doalls in it. ///<_ If False, it has not or may have doalls.(Conservative) Expression *distribution_of(Symbol *sym); ///< Return the corresponding DistributeExpr for sym if it is shared 'ARRAY'. ///< Return 0 either if it is scalar or if it is private array void clean_workspace(unsigned int pass_tag); ///< Delete all WorkSpaces with the given pass tag from the program unit's ///< WorkSpaceStack and all of the WorkSpaceStacks for the ProgramUnit's ///< statements. void clean(); ///< Search through the ProgramUnit and find all symbol uses. Remove ///< any symbols from the Symtab that are not found. BinRep *exchange(); ///< Return a BinRep object which encapsulates the ProgramUnit in a ///< portable format. void display(ostream & o) const; ///< Display the program unit in a form which includes statement tags ///< and other information. To print a program unit in a correct ///< Fortran format, use 'write(...)' instead. void display_debug(ostream & o) const; ///< Display the program unit in a form which includes the ///< symbol table and details of all the other program unit ///< structures, useful for debugging. To print a program in ///< a more readable FORTRAN format, use 'display(...)' or ///< 'write(...)' instead. friend ostream & operator << (ostream & o, const ProgramUnit & pr); virtual void print(ostream & o) const; ///< Satisfies the Definition requirements. Equivalent to display() virtual int structures_OK() const; ///< Check the structure of the data for errors or inconsistency ///< Return 0 and print error message if problems found, otherwise ///< return 1 without message. void write(ostream & o) const; ///< Display the program unit in FORTRAN format virtual Definition *definition_clone() const; ///< Copy and return a Definition void function_to_subroutine(); ///< Convert a program unit of type FUNCTION_PU_TYPE into a program ///< unit of type SUBROUTINE_PU_TYPE. This does NOT make any changes ///< to the structure of the program unit, only to _routine_type. void subroutine_to_function(); ///< Convert a program unit of type SUBROUTINE_PU_TYPE into a program ///< unit of type FUNCTION_PU_TYPE. This does NOT make any changes ///< to the structure of the program unit, only to _routine_type. void program_to_subroutine(); ///< Convert a program unit of type PROGRAM_PU_TYPE into a program ///< unit of type SUBROUTINE_PU_TYPE. This does NOT make any changes ///< to the structure of the program unit, only to _routine_type. }; ///< inline functions inline DDgraph & ProgramUnit::ddgraph() { p_abort("Method ProgramUnit::ddgraph() is no longer supported. Call ddgraph_guarded() instead."); return *_ddgraph; } inline DDgraph & ProgramUnit::ddgraph_guarded() { p_assert(_ddgraph, "ProgramUnit::ddgraph_guarded(): I do not have a valid DDgraph."); return *_ddgraph ; } inline Boolean ProgramUnit::ddgraph_valid() { return (_ddgraph != 0) ; } inline bool ProgramUnit::gsa_valid() const { if (_gsa_deflocs && _gsa_names) return true; p_assert(!_gsa_deflocs && !_gsa_names, "ProgramUnit in invalid GSA state"); return false; } inline const DefLocMap & ProgramUnit::gsa_deflocs_guarded() const { return *_gsa_deflocs; } inline DefLocMap & ProgramUnit::gsa_deflocs_guarded() { return *_gsa_deflocs; } inline const TranslateObject & ProgramUnit::gsa_names_guarded() const { return *_gsa_names; } inline TranslateObject & ProgramUnit::gsa_names_guarded() { return *_gsa_names; } inline RangeDict & ProgramUnit::range_dict_guarded() { return *_ranges; } inline void ProgramUnit::range_dict(RangeDict * rdict) { if (_ranges) { delete _ranges; } _ranges = rdict; } inline bool ProgramUnit::range_dict_valid() { return (_ranges != 0); } inline Map<Statement,InlineObject> & ProgramUnit::inline_map_guarded( ) { return (Map<Statement,InlineObject> &) *_inline_map; } inline void ProgramUnit::inline_map(Map<Statement,InlineObject> * map) { _inline_map = map; } inline bool ProgramUnit::inline_map_valid() { return (_inline_map != 0); } inline const StmtList & ProgramUnit::stmts() const { return (const StmtList &) _statements; } inline StmtList & ProgramUnit::stmts() { return (StmtList &) _statements; } inline const Symtab & ProgramUnit::symtab() const { return (const Symtab &) * _symtab; } inline Symtab & ProgramUnit::symtab() { return (Symtab &) * _symtab; } inline const DataList & ProgramUnit::data() const { return (const DataList &) * _data_list; } inline DataList & ProgramUnit::data() { return (DataList &) * _data_list; } inline const CommonBlockDict & ProgramUnit::common_blocks() const { return (const CommonBlockDict &) * _common_blocks; } inline CommonBlockDict & ProgramUnit::common_blocks() { return (CommonBlockDict &) * _common_blocks; } inline const NamelistDict & ProgramUnit::namelists() const { return (const NamelistDict &) * _namelists; } inline NamelistDict & ProgramUnit::namelists() { return (NamelistDict &) * _namelists; } inline const EquivalenceDict & ProgramUnit::equivalences() const { return (const EquivalenceDict &) * _equivalences; } inline EquivalenceDict & ProgramUnit::equivalences() { return (EquivalenceDict &) * _equivalences; } inline PredicateRepository & ProgramUnit::pred_repos() { return (PredicateRepository &) _repository; } #ifdef PERFORMANCE_EVAL inline PerformanceEstimator *ProgramUnit::perf_estimator() { return _perf_estimator; } inline void ProgramUnit::set_perf_estimator(PerformanceEstimator *pe) { _perf_estimator = pe; } #endif inline const FormatDB & ProgramUnit::formats() const { return (const FormatDB &) * _formats; } inline FormatDB & ProgramUnit::formats() { return (FormatDB &) * _formats; } inline const WorkSpaceStack & ProgramUnit::work_stack() const { return (const WorkSpaceStack &) _work_stack; } inline WorkSpaceStack & ProgramUnit::work_stack() { return (WorkSpaceStack &) _work_stack; } inline BinRep * ProgramUnit::overflow_ref() const { return _overflow; } inline PU_TYPE ProgramUnit::pu_class() const { return _routine_type; } ///<_ inline int ProgramUnit::is_multithread() const { return (_multithread > 0 ? 1 : 0); } inline int ProgramUnit::is_thread_defined() const { return (_multithread < 0 ? 0 : 1); } inline void ProgramUnit::multithread() { _multithread = 1; } inline void ProgramUnit::undefined_thread() { _multithread = -1; } inline void ProgramUnit::singlethread() { _multithread = 0; } inline RefSet<ProgramUnit> & ProgramUnit::calls() { return _calls; } inline RefSet<ProgramUnit> & ProgramUnit::called_by() { return _called_by; } inline void ProgramUnit::add_call(ProgramUnit & pgm) { _calls.ins(pgm); } inline void ProgramUnit::add_called_by(ProgramUnit & pgm) { _called_by.ins(pgm); } ///<_ #endif

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