Polaris: PropConstMap.cc Source File

PropConstMap.cc Go to the documentation of this file. /// /// /// \file PropConstMap.cc /// #include "../macros.h" #include "PropConstMap.h" /// Template instantiations: template class Array<PropConstElem>; void _collect_uses(const Expression &expr, IntSet &use_set, const Map<Symbol, IntElem> &candidates) { if (expr.op() == ID_OP) { const IntElem *elem = candidates.find_ref(expr.symbol()); if (elem) use_set.ins(elem->value()); } else { Iterator<Expression> iter = expr.arg_list(); for ( ; iter.valid(); ++iter) _collect_uses(iter.current(), use_set, candidates); } } PropConstValue::PropConstValue(const Expression &expr, const Statement &stmt, int stmt_toporder, const Map<Symbol,IntElem> &candidates) { _expr = expr.clone(); _stmt = &stmt; _toporder = stmt_toporder; _collect_uses(expr, _use_set, candidates); } PropConstValue::PropConstValue(const PropConstValue &other) { _expr = other.expr().clone(); _stmt = other._stmt; _toporder = other._toporder; _use_set = other._use_set; } PropConstValue::~PropConstValue() { delete _expr; } Listable * PropConstValue::listable_clone() const { return new PropConstValue(*this); } void PropConstValue::print(ostream &o) const { o << "[expr=" << *_expr; o << ", stmt=" << _stmt->tag(); o << ", toporder=" << _toporder; o << ", use_set=" << _use_set; o << "]"; } int PropConstValue::structures_OK() const { return (_expr->structures_OK() && _stmt->structures_OK() && _use_set.structures_OK()); } PropConstElem::PropConstElem() { _last_mod = 0; _const_val = 0; } PropConstElem::PropConstElem(const PropConstElem &other) { *this = other; } PropConstElem::~PropConstElem() { /// ... Nothing to do } const Expression & PropConstElem::expr() const { p_assert(_const_val, "Variable is not constant."); return _const_val->expr(); } const IntSet & PropConstElem::use_set() const { p_assert(_const_val, "Variable is not constant."); return _const_val->use_set(); } const PropConstValue & PropConstElem::const_val() const { p_assert(_const_val, "Variable is not constant."); return *_const_val; } void PropConstElem::constant(const PropConstValue &const_val) { p_assert(state() == MAY_BE_CONST, "Can only change MAY_BE_CONST objects into CONST objects."); _last_mod = &const_val.stmt(); _const_val = &const_val; } void PropConstElem::non_const(const Statement &stmt) { _last_mod = &stmt; _const_val = 0; } void PropConstElem::intersect(const PropConstElem &other, const Statement &curr_stmt) { CONST_STATE my_state = state(); CONST_STATE other_state = other.state(); if (my_state == MAY_BE_CONST) *this = other; else if (other_state == MAY_BE_CONST) ; // Do nothing else if (my_state == NON_CONST || other_state == NON_CONST) non_const(*_last_mod); else if (my_state == CONST && other_state == CONST) { /// ... Check if the two constants conflict if (! _const_equal(other)) non_const(curr_stmt); else if (_const_val->stmt_toporder() > other._const_val->stmt_toporder()) _const_val = other._const_val; } else p_abort("Internal Error: PropConstElem has a bad state."); if (_last_mod != other._last_mod) _last_mod = &curr_stmt; } Boolean PropConstElem::_const_equal(const PropConstElem &other) const { /// ... Return false if the expressions are unequal constants. return (! _const_val || ! other._const_val || _const_val == other._const_val || ((CASTAWAY(Expression &) expr()) == (CASTAWAY(Expression &) other.expr()))); } int PropConstElem::operator == (const PropConstElem &other) const { return (state() == other.state() && _const_equal(other) && _last_mod == other._last_mod); } PropConstElem & PropConstElem::operator = (const PropConstElem &other) { _last_mod = other._last_mod; _const_val = other._const_val; return *this; } ostream & operator << (ostream &o, const PropConstElem &pcc) { pcc.print(o); return o; } void PropConstElem::print(ostream &o) const { o << "<"; switch (state()) { case MAY_BE_CONST: o << "undef"; break; case CONST: o << _last_mod->tag() << ":" << expr(); break; case NON_CONST: o << _last_mod->tag() << ":?"; break; default: o << "error"; break; } o << ">"; } int PropConstElem::structures_OK() const { if (! _last_mod && _const_val) { cerr << "\n\nError: PropConstElem:structures_OK: Is in an invalid state.\n"; return 0; } return 1; } PropConstIntMap::PropConstIntMap(int num_consts, const Array<Symbol *> &tag_to_candidate) : _const_map(num_consts), _const_elems(num_consts), _undefined_elems(num_consts) { _tag_to_candidate = &tag_to_candidate; for (int i = 0; i < num_consts; ++i) { _undefined_elems.ins(i); _const_map[i] = -9999; } } PropConstIntMap::PropConstIntMap(const PropConstIntMap &other) : _const_map(other._const_map), _const_elems(other._const_elems), _undefined_elems(other._undefined_elems) { _tag_to_candidate = other._tag_to_candidate; } PropConstIntMap::~PropConstIntMap() { } CONST_STATE PropConstIntMap::state(int sym_tag) const { if (_const_elems[sym_tag]) return CONST; else if (_undefined_elems[sym_tag]) return MAY_BE_CONST; else return NON_CONST; } void PropConstIntMap::constant(int sym_tag, int const_val) { _const_elems.ins(sym_tag); _undefined_elems.del(sym_tag); _const_map[sym_tag] = const_val; } void PropConstIntMap::non_const(int sym_tag) { _const_elems.del(sym_tag); _undefined_elems.del(sym_tag); _const_map[sym_tag] = -9999; } int PropConstIntMap::int_const_val(int sym_tag) const { p_assert(_const_elems[sym_tag], "Variable is not a constant."); return _const_map[sym_tag]; } void PropConstIntMap::all_non_const() { _const_elems.clear(); _undefined_elems.clear(); for (int i = 0; i < _const_map.entries(); ++i) _const_map[i] = -9999; } void PropConstIntMap::intersect(const PropConstIntMap &other) { for (int sym_tag = 0; sym_tag < _const_map.entries(); ++sym_tag) { if (other._undefined_elems[sym_tag]) ; /// ... Nothing to do else if (_undefined_elems[sym_tag]) { if (other._const_elems[sym_tag]) constant(sym_tag, other._const_map[sym_tag]); else non_const(sym_tag); } else if (! _const_elems[sym_tag]) ; /// ... Nothing to do else if (! other._const_elems[sym_tag] || _const_map[sym_tag] != other._const_map[sym_tag]) non_const(sym_tag); } } PropConstIntMap & PropConstIntMap::operator = (const PropConstIntMap &other) { if (this != &other) { _const_map = other._const_map; _const_elems = other._const_elems; _undefined_elems = other._undefined_elems; _tag_to_candidate = other._tag_to_candidate; } return *this; } int PropConstIntMap::operator == (const PropConstIntMap &other) const { if (_const_map.entries() != other._const_map.entries() || _const_elems != other._const_elems || _undefined_elems != other._undefined_elems) return 0; for (int sym_tag = _const_elems.first(); sym_tag != -1; sym_tag = _const_elems.next(sym_tag)) if (_const_map[sym_tag] != other._const_map[sym_tag]) return 0; return 1; } ostream & operator << (ostream &o, const PropConstIntMap &pcm) { pcm.print(o); return o; } void PropConstIntMap::print(ostream &o) const { o << "[_const_map="; _const_map.print(o); o << ", _const_elems="; _const_elems.print(o); o << ", _undefined_elems="; _undefined_elems.print(o); o << "]"; } void PropConstIntMap::pretty_print(ostream &o) const { const int max_elems = 6; /// ... Max. number of constants per line int elems_on_line = max_elems; for (int sym_tag = 0; sym_tag < _const_map.entries(); sym_tag++) { if (++elems_on_line >= max_elems) { o << "\n "; elems_on_line = 0; } o << (*_tag_to_candidate)[sym_tag]->name_ref() << ":"; switch (state(sym_tag)) { case MAY_BE_CONST: o << "undef"; break; case CONST: o << _const_map[sym_tag]; break; case NON_CONST: o << "?"; break; default: o << "error"; break; } o << ", "; } } int PropConstIntMap::structures_OK() const { if (! _const_map.structures_OK() || ! _const_elems.structures_OK() || ! _undefined_elems.structures_OK()) return 0; IntSet inter_elems = _const_elems & _undefined_elems; if (inter_elems.entries()) { cerr << "PropConstIntMap::structures_OK() found a variable marked as\n"; cerr << "constant and undefined."; return 0; } return 1; } PropConstMap::PropConstMap(int num_consts, const Array<Symbol *> &tag_to_candidate) : _const_map(num_consts), _int_const_map(num_consts, tag_to_candidate) { _tag_to_candidate = &tag_to_candidate; } PropConstMap::PropConstMap(const PropConstMap &other) : _const_map(other._const_map), _int_const_map(other._int_const_map) { _tag_to_candidate = other._tag_to_candidate; } PropConstMap::~PropConstMap() { /// ... Nothing to do } void PropConstMap::all_non_const(const Statement &stmt) { _int_const_map.all_non_const(); for (int sym_tag = 0; sym_tag < _const_map.entries(); ++sym_tag) _const_map[sym_tag].non_const(stmt); } void PropConstMap::intersect(const PropConstMap &other, const Statement &stmt) { _int_const_map.intersect(other._int_const_map); for (int sym_tag = 0; sym_tag < _const_map.entries(); ++sym_tag) _const_map[sym_tag].intersect(other._const_map[sym_tag], stmt); } PropConstMap & PropConstMap::operator = (const PropConstMap &other) { if (this != &other) { _int_const_map = other._int_const_map; _const_map = other._const_map; _tag_to_candidate = other._tag_to_candidate; } return *this; } int PropConstMap::operator == (const PropConstMap &other) const { if (_int_const_map != other._int_const_map) return 0; if (_const_map.entries() != other._const_map.entries()) return 0; for (int sym_tag = 0; sym_tag < _const_map.entries(); ++sym_tag) if (_const_map[sym_tag] != other._const_map[sym_tag]) return 0; return 1; } ostream & operator << (ostream &o, const PropConstMap &pcm) { pcm.print(o); return o; } void PropConstMap::print(ostream &o) const { o << "[int_const_map="; _int_const_map.print(o); o << ", const_map="; _const_map.print(o); o << "]"; } void PropConstMap::pretty_print(ostream &o) const { _int_const_map.pretty_print(o); const int max_elems = 4; /// ... Max. number of constants per line int elems_on_line = max_elems; for (int sym_tag = 0; sym_tag < _const_map.entries(); sym_tag++) { if (++elems_on_line >= max_elems) { o << "\n "; elems_on_line = 0; } o << (*_tag_to_candidate)[sym_tag]->name_ref() << ":" << _const_map[sym_tag] << ", "; } } int PropConstMap::structures_OK() const { if (! _int_const_map.structures_OK() || ! _const_map.structures_OK()) return 0; for (int sym_tag = 0; sym_tag < _const_map.entries(); sym_tag++) if (! _const_map[sym_tag].structures_OK()) return 0; return 1; }

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