Polaris: IPCPProcData.h Source File

IPCPProcData.h Go to the documentation of this file. /// #ifndef _IPCP_PROC_DATA_H #define _IPCP_PROC_DATA_H /// /// file IPCPProcData.h /// /// \class IPCPProcData /// \brief Various procedural data for InterProcConstProp. /// \defgroup Polaris /// \ingroup Polaris /// Constant /// \see IPCPProcData.h /// \see IPCPProcData.h /// /// \endcode /// \section Overview Overview /// This class contains a variety of data needed by the /// interprocedural constant propagation pass for a single procedure. /// #include "../Listable.h" #include "../Collection/Map.h" #include "../Collection/RefMap.h" #include "../Collection/Set.h" #include "../Collection/RefSet.h" #include "../Collection/RefList.h" #include "../Symbol/Symbol.h" #include "../Expression/Expression.h" #include "../Statement/Statement.h" #include "../Statement/AssignmentStmt.h" #include "../String.h" #include "../Boolean.h" /// #include "IPCPConstants.h" #include "constant.h" /// class ProgramUnit; class InterProcConstProp; class IPCPProcData; class JumpFunction; class ReturnJumpFunction; class IPCPCallData : public Listable { public: IPCPCallData(IPCPProcData *called_pgm_data); IPCPCallData(const IPCPCallData &other); virtual ~IPCPCallData(); inline const IPCPProcData *data_ref() const; inline void data_ref(IPCPProcData *data); ///< Return the IPCPProcData object associated with procedure called ///< at this call site. inline Boolean jump_function_valid() const; inline const JumpFunction &jump_function() const; void jump_function(JumpFunction *jump_func); ///< Return the jump function for this call site. This jump ///< function holds the constant values of all global variables, ///< and call site parameters for the call site. These constant ///< values are symbolic expressions in terms of the global variables ///< and parameters of the calling routine. ///< It is assumed that the method return_jump_function() has ///< been called previously. void add_constant_set(IPCPConstants *constants, const List<Expression> &param_values); ///< Add a constant set to my IPCPProcData object. void compute_rtoporder(int &max_visited_elems); ///< Compute the reverse topological ordering for my ///< IPCPProcData object; virtual Listable *listable_clone() const; virtual void print(ostream &o) const; virtual int structures_OK() const; ///< Functions required by Listable. private: IPCPProcData *_called_pgm_data; JumpFunction *_jump_function; }; class IPCPProcData : public Listable { public: IPCPProcData(ProgramUnit &pgm, InterProcConstProp &ipcp, const Statement &entry, int debug = 0); ///< Create a new IPCPProcData object for the given program unit, ///< entering at the given entry. This constructor will compute ///< the side effects of this program unit. It will also build ///< IPCPProcData objects for its called routines, if they ///< haven't already been built. IPCPProcData(ProgramUnit &cloned_proc, const Statement &clone_entry, IPCPProcData &orig_proc_data); ///< Create a new IPCPProcData object for the given cloned program unit ///< from the IPCPProcData object of the original program unit. ///< The constant sets of the other IPCPProcData object is not ///< copied to this object. virtual ~IPCPProcData(); inline ProgramUnit &pgm(); ///< Return the program unit associated with myself. inline const Statement &entry() const; ///< Return the ENTRY statement associated with myself. const IPCPCallData *call_data(const Statement &call_site) const; ///< Return the interprocedural constant data associated with the ///< the given call site. If the given statement is not a call ///< site or the data structure does not exist, this method ///< returns NULL. inline const RefSet<Symbol> &used_global_vars() const; ///< Return the set of global variables used by this routine and ///< all called subroutines. inline const RefSet<Symbol> &usable_global_vars() const; ///< Return the set of global variables that may be used in a ///< constant expression belonging to this routine or a called ///< subroutine. RefSet<Symbol> *local_vars(const RefSet<Symbol> &vars) const; ///< Return the given set of variables, but renamed to the ///< procedure's local variable names. inline const RefList<Symbol> &param_list() const; ///< Return a list of my procedure's parameters. These variables ///< are all global variables. inline const Symbol *return_var() const; ///< Return the global variable name of my function's return value. ///< If my procedure is not a function, this method returns NULL. inline const Boolean is_called_externally() const; ///< Return true if my program unit may be called by some call site ///< not recorded in some othe IPCPProcData object's call_data ///< field. inline void called_externally(); ///< Mark my program unit as called externally. void create_return_jump_function(Map<Symbol, Expression> *old_const_mods, Map<Symbol, Expression> *new_consts); ///< Create a return jump function for this object, where mod_vars ///< is a mapping from global variables to their new constant ///< expressions. void create_jump_function(const Statement &call_site, Map<Symbol, Expression> *old_const_mods, Map<Symbol, Expression> *new_consts, List<Expression> *actuals); ///< Create a jump function for the given call site, where mod_vars ///< is a mapping from global variables to their new constant ///< expressions. inline const ReturnJumpFunction &return_jump_function() const; ///< Return the return jump function for this procedure. This return ///< jump function captures all the side effects of this procedure. ///< It is assumed that the method create_return_jump_function has ///< been called previously. const RefList<Symbol> *call_formals(const Statement &call_site) const; ///< Return the list of formal parameters for the given call site, ///< if possible. Map<Symbol,Expression> *local_old_const_mods(const Statement &call_site, const ReturnJumpFunction &jump_function) const; ///< Return a map of all the variable modifications (i.e., side-effects) ///< for the given jump function and for the actual parameters in ///< the given call site. This method differs from ///< jump_function->old_const_mods() in that the returned mapping is ///< in terms of local variables rather than global variables. Map<Symbol,Expression> *local_new_consts(const Statement &call_site, const ReturnJumpFunction &jump_function) const; ///< Return a map of all the new constant expressions generated by ///< the given call site. This method differs from ///< jump_function->new_consts() in that the returned mapping is ///< in terms of local variables rather than global variables. void add_constant_set(IPCPConstants *constants, const List<Expression> &param_values); ///< Add the given constant set to my set of constant sets. inline const List<IPCPConstants> &const_sets() const; ///< Return all the sets of constants that hold for my routine. void transfer_const_set(IPCPConstants &constants, IPCPProcData &other); ///< Transfer ownership of the given constant set from the other ///< IPCPProcData object to myself. This method will also rename any ///< calls made to the program unit owning the other IPCPProcData ///< object, which the given constants are passed in, to the ///< program unit owning myself. This method assumes that my ///< program unit is a clone of the other program unit. void add_consts_to_pgm(const IPCPConstants &consts); ///< Add all the constants in the given constant set to my program ///< unit. This is done by inserting assignments to the constant ///< variables at the begining of the program. void add_consts_to_pgm(); ///< Add my single constant set to my program unit. ///< This method will do nothing if I have no constant sets and ///< will 'p-assert' out if I have multiple constant sets. void build_jump_functions(int debug = 0); ///< Compute the side-effects of my program unit. These side ///< effects, called jump functions, are computed for the exit of ///< this program unit as well as for the entry for each call site ///< in my program unit. ///< ///< If there is a a single constant set in my consts_sets field, ///< these constants would be used to compute my side effects. void propagate_constants(PC_UNREACH_BOOL remove_unreachable, int debug = 0); ///< Propagate all local constants through my program, using the ///< interprocedural side-effect information I collected in my ///< constructor. ///< ///< If one also wishes to also propagate interprocedural constants ///< in the program, the method add_consts_to_pgm() should be ///< called beforehand. void expand_all_substituted(); ///< Expand all the constants stored in the substituted() fields ///< by the propagate_constants() method. void make_consts_sets_old(); ///< Make all constant sets be old constant sets. Used by ///< the have_consts_sets_changed() method below. Boolean have_consts_sets_changed() const; ///< Return True of the constant sets differ from the old constant ///< sets. inline int rtoporder() const; ///< Return the reverse topological ordering of my program unit in the ///< program's call graph. void init_rtoporder(); ///< Initialize the rtoporder fields. ///< Should be called before calling compute_rtoporder(); void compute_rtoporder(int &max_visited_elems); ///< Compute the reverse topological ordering for myself and ///< all called program units. void add_maymods(); ///< Add MAYMOD assertions to all call sites within myself which I ///< know the side-effects to. virtual void print(ostream &o, Boolean pretty_print) const; ///< Print out all my fields. If pretty_print=True, then ///< add carriage returns between my fields. virtual Listable *listable_clone() const; virtual void print(ostream &o) const; virtual int structures_OK() const; ///< Functions required by Listable. private: ProgramUnit *_pgm_ref; ///< The ProgramUnit that my data belongs to. InterProcConstProp *_ipcp_ref; ///< Interprocedural constant propagator. const Statement *_entry; ///< The entry statement I am associated_with. Database<String, IPCPCallData> _call_data; ///< Data for each call site in program. RefSet<Symbol> _used_global_vars; ///< Set of all global vars. RefSet<Symbol> _usable_global_vars; ///< Set of all usable global vars. RefMap<Symbol, Symbol> _local_to_global_vars; ///< Map from local to global variable names. RefMap<Symbol, Symbol> _global_to_local_vars; ///< Map from global to local variable names. RefList<Symbol> _param_list; ///< List of global parameter variables. const Symbol *_return_var; ///< Global variable that holds return value. ReturnJumpFunction *_return_jump_function; ///< Side-effects of my program. List<IPCPConstants> _consts_sets; ///< Sets of constant variables. List<IPCPConstants> _old_consts_sets; ///< Sets of old constant variables. int _rtoporder; ///< Reverse topological order of my program. Boolean _called_externally; ///< True if I may be called by some call ///< site not contained in some IPCPProcData ///< object's _call_data field. void _mark_external_func_calls(const Expression &expr); void _init_call_sites(); const Symbol &_convert_local_to_global(const Symbol &local_var, const char *global_namespace); void _init_params(); void _add_params_to_set(RefSet<Symbol> &vars) const; void _init_usable_global_vars(); void _add_refs_to_globals(const RefSet<Expression> &refs); void _init_used_global_vars(); RefSet<Symbol> *_candidates() const; Boolean _contains_local_vars(const Expression &expr) const; Boolean _contains_local_vars(const Expression &expr, const RefList<Symbol> &caller_formals) const; void _filter_out_local_vars(Map<Symbol, Expression> &var_mods) const; void _filter_out_local_vars(Map<Symbol, Expression> &var_mods, const RefList<Symbol> &caller_formals) const; void _rename_locals_to_globals(Expression &expr) const; void _rename_locals_to_globals(Map<Symbol,Expression> &var_mods) const; void _rename_locals_to_globals(List<Expression> &expr_list) const; void _rename_globals_to_locals(Expression &expr) const; void _rename_globals_to_locals(Map<Symbol,Expression> &var_mods) const; Map<Symbol,Expression> *_local_consts(const IPCPConstants &consts) const; void _update_call_site(const char *call_site_tag, IPCPProcData &new_call_proc_data); Expression *_expr_del_global_substituted(Expression *expr); void _del_global_substituted(); }; ///< inline implementations inline const IPCPProcData * IPCPCallData::data_ref() const { return _called_pgm_data; } inline void IPCPCallData::data_ref(IPCPProcData *data) { _called_pgm_data = data; } inline Boolean IPCPCallData::jump_function_valid() const { return _jump_function != 0; } inline const JumpFunction & IPCPCallData::jump_function() const { p_assert(_jump_function, "IPCPCallData::_jump_function(): Jump function was not initialized."); return *_jump_function; } inline ProgramUnit & IPCPProcData::pgm() { return *_pgm_ref; } inline const Statement & IPCPProcData::entry() const { return *_entry; } inline const RefSet<Symbol> & IPCPProcData::used_global_vars() const { return _used_global_vars; } inline const RefSet<Symbol> & IPCPProcData::usable_global_vars() const { return _usable_global_vars; } inline const RefList<Symbol> & IPCPProcData::param_list() const { return _param_list; } inline const Symbol * IPCPProcData::return_var() const { return _return_var; } inline const ReturnJumpFunction & IPCPProcData::return_jump_function() const { p_assert(_return_jump_function, "IPCPProcData::_return_jump_function(): Return jump function was not initialized."); return *_return_jump_function; } inline const List<IPCPConstants> & IPCPProcData::const_sets() const { return _consts_sets; } inline int IPCPProcData::rtoporder() const { return _rtoporder; } inline const Boolean IPCPProcData::is_called_externally() const { return _called_externally; } inline void IPCPProcData::called_externally() { _called_externally = True; } #endif

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