Polaris: Statement.h Source File

Statement.h Go to the documentation of this file. #ifndef _STATEMENT_H #define _STATEMENT_H /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// /// \endcode /// \section Bugs Bugs /// Statement cloning/copying resets the fields successors, predecessors, /// in_refs, out_refs and act_refs. Currently, it is up to the programmer /// to rebuild these fields as appropriate. /// /// List of Statement types /// enum STMT_TYPE { UNDEFINED_STMT = 0, /// DO_STMT, ENDDO_STMT, WHILE_STMT, /// ASSIGNMENT_STMT, /// IF_STMT, ELSEIF_STMT, IMPLIED_GOTO_STMT, ENDIF_STMT, ELSE_STMT, /// ASSIGN_STMT, /// READ_STMT, WRITE_STMT, PRINT_STMT, OPEN_STMT, CLOSE_STMT, REWIND_STMT, BACKSPACE_STMT, ENDFILE_STMT, INQUIRE_STMT, /// STOP_STMT, PAUSE_STMT, /// FLOW_ENTRY_STMT, FLOW_EXIT_STMT, /// BLOCK_ENTRY_STMT, BLOCK_EXIT_STMT, /// ENTRY_STMT, CALL_STMT, RETURN_STMT, /// LABEL_STMT, GOTO_STMT, ARITHMETIC_IF_STMT, COMPUTED_GOTO_STMT, ASSIGNED_GOTO_STMT, /// ALLOCATE_STMT, DEALLOCATE_STMT, NULLIFY_STMT, /// DIRECTIVE_STMT, /// STMT_PTR }; /// enum ASSIGN_TYPE { INVALID_ASSIGN, EXECUTABLE_ASSIGN, FORMAT_ASSIGN }; /// #include "ClassNames.h" #include <stream.h> #include <strstream.h> /// #include "../AbstractAccess.h" #include "../BinRep.h" #include "../Collection/Iterator.h" #include "../Collection/Mutator.h" #include "../Collection/List.h" #include "../Collection/RefList.h" #include "../Collection/RefSet.h" #include "../debug.h" #include "../define.h" #include "../Dictionary.h" #include "../Directive/AssertionList.h" #include "../Expression/Expression.h" #include "../Relinkable.h" #include "../split_line.h" #include "../String.h" #include "../StringElem.h" #include "../Symbol/Symbol.h" #include "../SymbolAccess.h" #include "../SymbolAccessMap.h" #include "../VoidPtrDef.h" #include "../WorkSpaceStack.h" /// class Symtab; class NamelistDict; class ExprTable; class VDL; #ifdef PERFORMANCE_EVAL class PerformanceEstimator; #endif #define DUMMY_EXPR (*((Expression *)0)) const int ROUTINE_EXPR = 0; const int PARAMETERS = 1; const int ALLOC_PARAMS = 0; const int ARITHIF_EXPR = 0; const int LHS = 0; const int ASSIGNEDGOTO_EXPR = 0; const int RHS = 1; const int COMPUTEDGOTO_EXPR = 0; const int DO_INDEX = 0; const int DO_INIT = 1; const int DO_LIMIT = 2; const int DO_STEP = 3; const int ELSEIF_EXPR = 0; const int IO_LIST = 0; const int IF_EXPR = 0; const int PAUSE_EXPR = 0; const int RETURN_EXPR = 0; const int STOP_EXPR = 0; const int WHILE_EXPR = 0; class Statement; class StmtList; void print_expr_list( ostream& o, const RefSet<Expression> &exprs); void print_expr_list( ostream& o, const RefList<Expression> &exprs); void print_expr_list( ostream& o, const List<Expression> &exprs); void print_string_list(ostream& o, const List<StringElem>& strings); ///< \class s_control_type /// \brief ///< type for IOStmt list template ///< The s_control_type class is a special class used in IOStmt's. Consider ///< the following three Fortran statements: ///< ///< 1) WRITE (*, 100) ///< 2) WRITE (*, 100, END=200) ///< 3) WRITE (*, '(1X)') ///< 4) WRITE (*, *) ///< ///< In all of these examples, a list of s_control_type's is used to ///< specify the options of the WRITE statement. The s_control_type ///< consists of a string keyword, which can be one of "UNIT", "FMT", ///< "ERR", "END"; and an expression, which can be a StringConstExpr, ///< LabelExpr, or FormatExpr. ///< ///< In all of the above examples, the asterisk ('*') is represented by ///< an s_control_type of ["UNIT", <IOStarExpr>] (for the asterisks in ///< 1-3 and the first asterisk in 4) or ["FMT", <IoStarExpr>] (for ///< the second asterisk in 4). ///< ///< In examples 1 and 2, the line label '100' is represented by an ///< s_control_type of ///< ["FMT", <FormatExpr pointing to a Format class representing the ///< format at statement 100>]. ///< ///< In example 2, the 'END=200' is represented by an s_control_type ///< of ["END", <LabelExpr pointing to statement 200>] ///< ///< In example 3, the "'(1X)'" is represented by an s_control_type ///< of ["FMT", <StringConstExpr "'(1X)'">] class s_control_type : public Listable { friend ostream & operator << (ostream & o, const s_control_type & sct); public: String keyword; List<Expression> expr; s_control_type(); s_control_type(String & key, Expression *expr); virtual ~s_control_type(); virtual Listable *listable_clone() const; virtual int structures_OK() const; virtual void print(ostream & o) const; virtual void write(ostream & o) const; }; ///< This a class used for a Hashtable to keep track of ///< \'next\' fields in the statements. It is only used during ///< conversion from BinRep's. class NextEntry : public Definition { protected: String _next; public: virtual void print(ostream & o) const; const char *next_ref() const { return (const char *) _next; } void next(const char *n) { _next = n; } NextEntry(const char *tag, BinRep & bstring) : Definition(tag) { p_assert(bstring.is_string(), "ERROR"); String string_name; bstring.to_string(string_name); ///< cerr << tag << "(next) = " << string_name << ". "; _next = string_name; } ~NextEntry(); virtual int structures_OK() const; virtual Definition *definition_clone() const; }; ///< \note whenever a field is a List<>, there is no method to ///< insert data into it. There is only one method for these ///< fields which returns the list structure. Then the List<> ///< methods can be used to insert and retrieve data. class FormatDB; class CDGNode; class Statement : public Relinkable { friend class StmtList; protected: ///< ---- helper functions for convert --------- void make_overflow(Iterator<BinRep> & iter, const char *exname); void empty_overflow(); int check_common_fields(String &field, BinRep & second, ExprTable & etable, Dictionary<NextEntry> *next_table, char *caller); virtual void _setptrs(Dictionary<VoidPtrDef> &tags, const FormatDB &formats); ///< Copies base values of this into other void copy_base(const Statement & other); ///< These are fields common to all statement types STMT_TYPE _type; ///< Type of statement List<Expression> _exprlist; ///< List of the all the expressions in a statement List<Statement> _successors_list; ///< List for _successors RefSet<Statement> _successors; ///< successors of control flow List<Statement> _predecessors_list; ///< List for _predecessors RefSet<Statement> _predecessors; ///< predecessors of control flow List<Expression> _in_refs_list; ///< List for _in_refs RefSet<Expression> _in_refs; ///< expressions which read memory List<Expression> _out_refs_list; ///< List for _out_refs RefSet<Expression> _out_refs; ///< expressions which write memory List<Expression> _act_refs_list; ///< List for _act_refs RefSet<Expression> _act_refs; ///< all memory expressions? AssertionList _assertion_list; ///< A list of the assertions Statement *_outer; ///< innermost enclosing do loop List<StringElem> _pre_directives; ///< Statement directives List<StringElem> _post_directives; ///< before & after the stmt String _state; String _tag; ///< (ex. S10) ///< xxx _loop_info; int _line; ///< line number WorkSpaceStack _work_stack; ///< Stack of WorkSpace objects BinRep *_overflow; ///< Any overflow information SymbolAccessMap * _access_table; ///< Access Region access description ///< by symbol ///< for statement, or whole block ///< if this is a block-type stmt, ///< like DO. CDGNode* _cdgnode; ///< Control Dependence Graph node. #ifdef PERFORMANCE_EVAL PerformanceEstimator *_perf_estimator; unsigned long _stmtProfile; #endif void _add_act_refs (Expression &expr) ; ///< Given an expression in the statement, add to this statement's _act_refs void _add_act_params (Expression &expr) ; ///< Given an expression which is a parameter list, add to this ///< statement's _act_refs void _add_in_refs (Expression &expr) ; ///< Given an expression in the statement, add to this statement's _in_refs void _add_out_refs (Expression &expr) ; ///< Given an expression in the statement, add to this statement's _out_refs ///< ONLY FINDS THE INDEX VARIABLE OF AN EQUAL_OP: (A(I), I=1,N) void _add_ioread_sets(Expression &expr) ; ///< Given a top-level expression from a READ I/O list, add to the ///< READ's in/out/act _refs. inline RefSet<Statement> &modify_succ(); inline RefSet<Statement> &modify_pred(); ///< Create a modifyable copy of _succ and _pred for internal use. #if 0 ///< The tag is needed to avoid duplication. inline void tag(const char *s) { _tag = s; } #endif ProgramUnit* _program_unit; public: virtual Mutator<Expression> iterate_expressions(); ///< Return an iterator over stmt exprs virtual int iterate_in_exprs_valid() const; ///< Check if there are valid in_ref exprs virtual Mutator<Expression> iterate_in_exprs_guarded(); ///< Return an iterator over in_ref exprs virtual int iterate_out_exprs_valid() const; ///< Check if there are valid out_ref exprs virtual Mutator<Expression> iterate_out_exprs_guarded(); ///< Return an iterator over out_ref exprs virtual int iterate_in_out_exprs_valid() const; ///< Check if there are valid in_out_ref exprs virtual Mutator<Expression> iterate_in_out_exprs_guarded(); ///< Return an iterator over in_out_ref exprs void simplify_expressions(); ///< Simplify all of the expressions in the statement. ///< Statement constructor takes two argument: ///< The statement type and the statement tag Statement(const char *l, STMT_TYPE st); virtual ~Statement(); virtual Listable *listable_clone() const; virtual Statement *clone() const = 0; virtual int structures_OK() const = 0; int in_out_refs_structures_OK() const; virtual void convert(BinRep &stmt, ExprTable &etable, Symtab &symtab, const NamelistDict &namelists, const FormatDB &formats, Dictionary<NextEntry> *next_table); virtual RefSet<Statement> *build_succ(const StmtList &stmts) const; virtual void build_refs(); ///< Build _in_refs, _out_refs, and _act_refs for the given statement ///< methods which will retrieve data from common fields inline STMT_TYPE stmt_class() const { return _type; } inline const RefSet<Statement> &succ() const { return _successors; } inline const RefSet<Statement> &pred() const { return _predecessors;} inline const RefSet<Expression> &in_refs() const { return _in_refs; } inline const RefSet<Expression> &out_refs() const { return _out_refs; } inline const RefSet<Expression> &act_refs() const { return _act_refs; } inline Statement *next_ref() const { return (Statement *) Listable::next_ref(); } inline Statement *prev_ref() const { return (Statement *) Listable::prev_ref(); } inline Statement *outer_ref() const { return _outer; } inline int line() const { return _line; } inline BinRep *overflow() const { return _overflow; } inline const char *tag() const { return (const char *) _tag; } inline int tag_defined() const { return _tag.defined(); } inline const char *state() const { return (const char *) _state; } inline List<StringElem>&pre_directives() const { return (List<StringElem>&) _pre_directives; } inline List<StringElem>&post_directives() const { return (List<StringElem>&) _post_directives; } inline AssertionList & assertions() const { return (AssertionList &) _assertion_list; } ///< methods which insert data into common fields inline void state(const char *s) { _state = s; } inline void line(int l) { _line = l; } virtual void relink_lptrs( ProgramUnit &p ); ///< Change pointers within the Statement expressions to ///< point into the given ProgramUnit. virtual void relink_sptrs( ProgramUnit &p ); ///< Change pointers in special statement fields ///< Return the stack of WorkSpaces associated with the statement inline WorkSpaceStack &work_stack() const { return (WorkSpaceStack &) _work_stack; } #ifdef PERFORMANCE_EVAL inline PerformanceEstimator *perf_estimator(); inline void set_perf_estimator(PerformanceEstimator *pe); ///< Performance estimation data unsigned long profile() { return _stmtProfile; } void set_profile(unsigned long profile) { _stmtProfile = profile; } #endif virtual void access_table( SymbolAccessMap * map ) { if (_access_table) { delete _access_table; } _access_table = map; } ///< Check whether the access_table exists Boolean access_table_exists( ); ///< Return a reference to the access_table (check access_table_exists() first!) SymbolAccessMap & access_table( ); ///< Iterate through all symbols and SymbolAccess objects KeyIterator<Symbol, SymbolAccess> iter_access_table_guarded( ); ///< Add some other statement's access_table to mine void incorporate_access_table ( const SymbolAccessMap & sam ); ///< Check whether any info is entered into access_table for the given Symbol Boolean symbol_access_exists( Symbol & sym ); ///< Once symbol_access_exists indicates that info exists, use one of the ///< following to get an Iterator for looking through the AbstractAccess info. virtual Iterator<AbstractAccess> iter_read_guarded( Symbol & sym ); virtual Iterator<AbstractAccess> iter_write_guarded( Symbol & sym ); virtual Iterator<AbstractAccess> iter_readwrite_guarded( Symbol & sym ); ///< Insert a set of AbstractAccess objects into the SymbolAccessMap table for a statement void ins_access( SymbolAccessMap & map ); ///< Insert a list of AbstractAccess into the access_table void ins_read_access( Symbol & sym, List<AbstractAccess> & readlist); ///< Insert a list of AbstractAccess into the access_table void ins_write_access( Symbol & sym, List<AbstractAccess> & writelist); ///< Insert a list of AbstractAccess into the access_table void ins_readwrite_access( Symbol & sym, List<AbstractAccess> & readwritelist); ///< Insert read AbstractAccess for a given symbol into the access_table void ins_read_access( Symbol & sym, AbstractAccess * ); ///< Insert write AbstractAccess for a given symbol into the access_table void ins_write_access( Symbol & sym, AbstractAccess * ); ///< Insert readwrite AbstractAccess for a given symbol into the access_table void ins_readwrite_access( Symbol & sym, AbstractAccess * ); ///< Update the flow graph information for a particular statement. void fix_flow( StmtList & stmts ); ///< Remove flow links for this statement. void del_flow( StmtList & stmts ); ///< called when an unspecified method is called void error(char *) const; ProgramUnit* program_unit() {return _program_unit;}; void program_unit(ProgramUnit* program_unit) {_program_unit=program_unit;}; Iterator<Expression> iterate_all_expressions(); ///< methods which retrieve statement specific data ///< Will be redefined by sub-classes if field exists virtual const Expression & lhs() const; virtual Expression & lhs(); virtual const Expression & rhs() const; virtual Expression & rhs(); virtual Statement *follow_ref() const; virtual Statement *lead_ref() const; virtual Statement *matching_if_ref() const; virtual Statement *matching_endif_ref() const; virtual const Expression & expr() const; virtual Expression & expr() ; virtual const Expression & index() const; virtual Expression & index(); virtual const Expression & init() const; virtual Expression & init(); virtual const Expression & limit() const; virtual Expression & limit(); virtual const Expression & step() const; virtual Expression & step(); virtual const Expression & expr_guarded() const; virtual Expression & expr_guarded() ; virtual int expr_valid() const; virtual String get_loop_name(); virtual const Statement *target_ref() const; virtual Statement *target_ref() ; virtual ASSIGN_TYPE atype() const; virtual const Format *format_ref() const; virtual Format *format_ref(); virtual const RefList<Statement> &label_list() const; virtual RefList<Statement> &label_list(); virtual const List<s_control_type> &s_control_guarded() const; virtual List<s_control_type> &s_control_guarded(); virtual int s_control_valid() const; virtual Boolean marked_parallel() const; ///< True, if loop has an AS_PARALLEL ///< assertion attached. virtual Boolean marked_serial() const; ///< True, if loop has an AS_SERIAL ///< assertion attached. virtual RefSet<Symbol> *private_vars_ref() const;///< Expressions from PRIVATE assertion virtual const Expression & io_list_guarded() const; virtual Expression & io_list_guarded(); virtual int io_list_valid() const; virtual const Expression & routine_guarded() const; virtual Expression & routine_guarded(); virtual int routine_valid() const; virtual const Expression & parameters_guarded() const; virtual Expression & parameters_guarded(); virtual int parameters_valid() const; virtual int value() const; ///< methods which insert statement specific data ///< will be redefined by sub-classes if field exists virtual void lhs(Expression * e); virtual void rhs(Expression * e); virtual void index(Expression * e); virtual void init(Expression * e); virtual void limit(Expression * e); virtual void step(Expression * e); virtual void expr(Expression * e); virtual void target(Statement * s); virtual void io_list(Expression * e); virtual void routine(Expression * e); virtual void parameters(Expression * e); virtual void value(int i); ///< This one is to satisfy Listable virtual void print(ostream & o) const; virtual void fortran_write(ostream & o, int &indent, char *type = "") const = 0; virtual void print_debug(ostream & o, int debug) const = 0; ///< prints the statement if debug = 0, ///< print only statement-specific debugging if debug = 1 (to be ///< used in conjunction with print_fields). ///< Print was primarily designed to be used by other functions, to ///< better output statements we suggest using the << operator to print ///< with debugging info or the write method to print in FORTRAN form virtual void write(ostream & o, int &indent, char *type = "") const; ///< Write out the SymbolAccessMap void write_access_table( ostream & o ); ///< prints the statement in FORTRAN form with indent void print_fields(ostream & o) const; ///< prints all additional fields (fields defined in the base class) ///< for debugging virtual void exchange_convert( VDL &vdl ); ///< Convert the Statement into the exchange format. CDGNode* cdgnode(); void cdgnode(CDGNode* n); friend ostream & operator << (ostream & o, const Statement & st); }; inline RefSet<Statement> & Statement::modify_succ() { return _successors; } inline RefSet<Statement> & Statement::modify_pred() { return _predecessors; } inline CDGNode* Statement::cdgnode(){ return _cdgnode; } inline void Statement::cdgnode(CDGNode* n){ _cdgnode=n; } #ifdef PERFORMANCE_EVAL inline PerformanceEstimator * Statement::perf_estimator() { return _perf_estimator; } inline void Statement::set_perf_estimator(PerformanceEstimator *pe) { _perf_estimator = pe; } #endif inline Iterator<Expression> Statement::iterate_all_expressions() { return Iterator<Expression>(_exprlist); } void print_target_labels(ostream& o, const RefSet<Statement>& stmts); void print_stmt_list(ostream& o, const RefSet<Statement>& stmts); void print_stmt_tags(ostream& o, const RefSet<Statement>& stmts); void print_target_labels(ostream& o, const RefList<Statement>& stmts); void print_stmt_list(ostream& o, const RefList<Statement>& stmts); void print_stmt_tags(ostream& o, const RefList<Statement>& stmts); void print_target_labels(ostream& o, const List<Statement>& stmts); void print_stmt_list(ostream& o, const List<Statement>& stmts); void print_stmt_tags(ostream& o, const List<Statement>& stmts); ///< There exist two flavors of constructors for the Statement ///< classes. ///< ///< One brand of constructors takes a single argument if the ///< the constructor specifies a specific statement (ex. DO, ///< ASSIGNMENT). That argument is the statement tag. ///< However, if the constructor's class specifies more than ///< one statement (ex. IOStmt) the constructor takes two arguments: ///< the statement type and then the statement tag. ///< ///< The second type of constructor accepts the arguments described ///< above followed by all arguments necessary to FULLY specify ///< the statement. In situations where the statement is defined by ///< a list of some type, there exist constructors which allow ///< the statement to be defined up to some finite list size. #endif

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