Polaris: PropConstMap.h Source File

PropConstMap.h Go to the documentation of this file. /// #ifndef _PROPCONSTMAP_H #define _PROPCONSTMAP_H /// /// /// file PropConstMap.h /// /// \class PropConstMap /// \brief Holds the constant values of program variables /// \defgroup Polaris /// \ingroup Polaris /// Constant /// \see PropConstMap.h /// \see PropConstMap.h /// \see PropConstMap.cc /// /// \endcode /// \section Description Description /// This file declares a PropConstMap object and its subcomponents. A /// PropConstMap object maps a set of variables to their symbolic or /// integer constant values. A PropConstIntMap object maps a set of /// variables to only their integer constant values. A PropConstElem /// object represents the constant value of a single variable, if it is /// constant. A PropConstValue object represents a constant symbolic /// expression. /// /// PropConstValue objects represent the constant symbolic expressions /// that variables may take. These objects not only keep track of /// the symbolic constant values, but also the statement that these /// values originated from. This is necessary for the constant propagator /// to determine which definitions reach each variable used by the /// constant expression. /// /// PropConstElem objects indicate whether a particular variable is /// a symbolic constant or not. They also hold the variable's constant /// value, if it is a symbolic constant. PropConstElem objects also /// include methods for updating or computing the constant status /// of individual variables. /// /// PropConstIntMap objects determine which variables are integer /// constants as well as their constant values. Integer constants /// are constants that can take on only integer values. Logical /// constants are treated as integer constants that can take on only /// the values 0 or 1. Integer constants and symbolic constants are /// kept and computed separately since variables can take on /// an integer constant value but not a symbolic constant value or /// vice versa. For example, for A=<non-const> and B=A, variable B /// takes on the symbolic constant value "A" but has no integer constant /// value. On the other hand, at a join statement where B=1+3 for /// one path and B=2+2 for the other, B takes on the integer constant /// of 4 at this join but has no symbolic constant value since the /// unevaluated expressions differ. /// /// PropConstMap objects determine which variables are symbolic /// constants as well as their constant values. They also contain /// PropConstIntMap objects, so in fact they keep track of both integer /// and symbolic constants. Various methods are provided to update /// the constant values within themselves. /// #include <stream.h> /// #include "../Expression/Expression.h" #include "../Statement/Statement.h" #include "../Symbol/Symbol.h" #include "../Collection/Map.h" #include "../Array.h" #include "../IntElem.h" #include "../IntSet.h" #include "../p-assert.h" /// class PropConstValue : public Listable { public: PropConstValue(const Expression &expr, const Statement &stmt, int stmt_toporder, const Map<Symbol,IntElem> &candidates); PropConstValue(const PropConstValue &other); virtual ~PropConstValue(); inline const Expression &expr() const; ///< Return my constant expression. inline const Statement &stmt() const; ///< Return the statement that defines my constant expression. inline const IntSet &use_set() const; ///< Return the set of variables that my constant expression uses. inline int stmt_toporder() const; inline void stmt_toporder(int val); ///< Return the topolgical ordering of my statement. ///< Used as a tie-breaker for choosing between two equivalent ///< PropConstValue objects. virtual Listable *listable_clone() const; virtual void print(ostream &o) const; virtual int structures_OK() const; ///< Functions required by Listable. private: Expression *_expr; ///< A constant expression. const Statement *_stmt; ///< Statement defining the constant expr IntSet _use_set; ///< Set of variables used in constant expr Boolean _has_integer_val; ///< True if constant is an integer constant int _integer_val; ///< Integer value of constant expr. int _toporder; ///< Reverse topological sort order pf stmt }; enum CONST_STATE { MAY_BE_CONST, ///< Var. may or may not be constant. CONST, ///< Var. is constant. NON_CONST, ///< Var. is not constant. }; class PropConstElem { public: PropConstElem(); ///< Create a PropConstElem object in a MAY_BE_CONST state. PropConstElem(const PropConstElem &); ~PropConstElem(); inline const Statement *last_mod() const; ///< Return the earliest statement in the control flow graph where ///< the current variable would have the same value as it would have ///< at the current statement. const Expression &expr() const; ///< If I am constant, return its value. const IntSet &use_set() const; ///< Return the set of candidate variables used by the constant ///< expression. Only valid when I am a constant. const PropConstValue &const_val() const; ///< If I am constant, return my PropConstValue object. inline CONST_STATE state() const; ///< Return the state. void constant(const PropConstValue &const_val); ///< Become a constant whose value is the right hand side of the ///< given workspace object. ///< Illegal if my state is NON_CONST. void non_const(const Statement &); ///< Make the variable be no longer be a constant. The last ///< modification of the variable would be set to the given ///< statement. void intersect(const PropConstElem &other, const Statement &curr_stmt); ///< Intersect the other constant holder with myself. That is, ///< if the other constant holder is non-constant or is a ///< constant with a different constant value than myself, make ///< myself be non-constant. PropConstElem &operator = (const PropConstElem &); ///< Set my value to the other object's value. int operator == (const PropConstElem &) const; inline int operator != (const PropConstElem &) const; ///< Compare the two objects. Two PropConstElems are equal if and ///< only if their states are equal, their last_mods are equal, ///< and if they are both have constant states, their constant ///< expressions and value numbers are equal. void print(ostream &o) const; friend ostream & operator << (ostream &o, const PropConstElem &pce); ///< Print out the constant value stored within myself int structures_OK(void) const; ///< Return 1 if my structures are in a valid state. Otherwise, ///< print an error and return 0. private: const Statement *_last_mod; ///< Last modification point for variable. const PropConstValue *_const_val; ///< Workspace belonging to const stmt. Boolean _const_equal(const PropConstElem &) const; }; class PropConstIntMap { public: PropConstIntMap(int num_consts, const Array<Symbol *> &tag_to_candidate); PropConstIntMap(const PropConstIntMap &other); virtual ~PropConstIntMap(); inline const Array<Symbol *> &tag_to_candidate() const; ///< Return the map from integer tags to variable candidates. CONST_STATE state(int sym_tag) const; ///< Return the constant state for the variable with the given tag. void constant(int sym_tag, int const_val); ///< Make the variable with the given tag be a constant with the ///< given value. void non_const(int sym_tag); ///< Make the variable with the given tag be non-constant. int int_const_val(int sym_tag) const; ///< Return the integer constant value for the variable with the ///< given symbol tag. Not valid if the variable is not constant. inline int entries() const; ///< Return the number of entries in the constant map void all_non_const(); ///< Make all variables within myself be non-constant. void intersect(const PropConstIntMap &other); ///< Intersect the other constant map with myself. PropConstIntMap &operator = (const PropConstIntMap &other); ///< Set my constant values to the other objects value int operator == (const PropConstIntMap &) const; inline int operator != (const PropConstIntMap &) const; ///< Compare the two maps. void print(ostream &o) const; friend ostream & operator << (ostream &o, const PropConstIntMap &pcm); ///< Print out the constant value stored within myself. void pretty_print(ostream &o) const; ///< Print out the constant values stored within myself in a more ///< lengthy but user readable format. int structures_OK(void) const; ///< Return 1 if my structures are in a valid state. Otherwise, ///< print an error and return 0. private: Array<int> _const_map; ///< Collection of constant values for vars. IntSet _const_elems; ///< Set of constant variables. IntSet _undefined_elems; ///< Set of undefined variables. const Array<Symbol *> *_tag_to_candidate; ///< Maps integers to variable candidates. }; class PropConstMap { public: PropConstMap(int num_consts, const Array<Symbol *> &tag_to_candidate); PropConstMap(const PropConstMap &other); virtual ~PropConstMap(); inline const Array<Symbol *> &tag_to_candidate() const; ///< Return the map from integer tags to variable candidates. inline PropConstElem &operator [] (int sym_tag) const; ///< Return the constant value of the variable with the given symbol ///< tag. inline int entries() const; ///< Return the number of entries in the constant map void all_non_const(const Statement &stmt); ///< Make all variables within myself be non-constant. inline CONST_STATE int_state(int sym_tag) const; ///< Return the integer constant state for the variable with the ///< given tag. inline void int_const(int sym_tag, int const_val); ///< Make the variable with the given tag be an integer constant with ///< the given value. inline void int_non_const(int sym_tag); ///< Make the variable with the given tag be an integer non-constant. inline int int_const_val(int sym_tag) const; ///< Return the integer constant value for the variable with the ///< given symbol tag. Not valid if the variable is not constant. void intersect(const PropConstMap &other, const Statement &stmt); ///< Intersect the other constant map with myself. PropConstMap &operator = (const PropConstMap &other); ///< Set my constant values to the other objects value int operator == (const PropConstMap &) const; inline int operator != (const PropConstMap &) const; ///< Compare the two maps. void print(ostream &o) const; friend ostream & operator << (ostream &o, const PropConstMap &pcm); ///< Print out the constant value stored within myself. void pretty_print(ostream &o) const; ///< Print out the constant values stored within myself in a more ///< lengthy but user readable format. int structures_OK(void) const; ///< Return 1 if my structures are in a valid state. Otherwise, ///< print an error and return 0. private: Array<PropConstElem> _const_map; ///< Collection of symbolic constant values PropConstIntMap _int_const_map; ///< Collection of integer constant values. const Array<Symbol *> *_tag_to_candidate; ///< Maps integers to variable candidates. }; ///< inline implementations inline const Expression & PropConstValue::expr() const { return *_expr; } inline const Statement & PropConstValue::stmt() const { return *_stmt; } inline const IntSet & PropConstValue::use_set() const { return _use_set; } inline int PropConstValue::stmt_toporder() const { return _toporder; } inline void PropConstValue::stmt_toporder(int val) { _toporder = val; } inline const Statement * PropConstElem::last_mod() const { return _last_mod; } inline CONST_STATE PropConstElem::state() const { if (! _last_mod) return MAY_BE_CONST; else if (_const_val) return CONST; else return NON_CONST; } inline int PropConstElem::operator != (const PropConstElem &other) const { return (! (*this == other)); } inline const Array<Symbol *> & PropConstIntMap::tag_to_candidate() const { return *_tag_to_candidate; } inline int PropConstIntMap::entries() const { return _const_map.entries(); } inline int PropConstIntMap::operator != (const PropConstIntMap &other) const { return (! (*this == other)); } inline const Array<Symbol *> & PropConstMap::tag_to_candidate() const { return *_tag_to_candidate; } inline PropConstElem & PropConstMap::operator [] (int sym_tag) const { return CASTAWAY(PropConstElem &) _const_map[sym_tag]; } inline int PropConstMap::entries() const { return _const_map.entries(); } inline CONST_STATE PropConstMap::int_state(int sym_tag) const { return _int_const_map.state(sym_tag); } inline void PropConstMap::int_const(int sym_tag, int const_val) { _int_const_map.constant(sym_tag, const_val); } inline void PropConstMap::int_non_const(int sym_tag) { _int_const_map.non_const(sym_tag); } inline int PropConstMap::int_const_val(int sym_tag) const { return _int_const_map.int_const_val(sym_tag); } inline int PropConstMap::operator != (const PropConstMap &other) const { return (! (*this == other)); } #endif

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