Polaris: SSAFullRangeDict.cc Source File

SSAFullRangeDict.cc Go to the documentation of this file. /// /// /// \file ControlRangeDict.cc /// #include "Program.h" #include "SSAProgramUnit.h" #include "Statement/Statement.h" #include "Symbol/Symbol.h" #include "Symtab.h" #include "Expression/Expression.h" #include "utilities/expression_util.h" #include "Array.h" #include "IntSet.h" #include "Timer.h" #include "p-assert.h" #include "SSAFullRangeDict.h" #include "SSAFullRangeData.h" #include "RangeExpr.h" #include "range_util.h" #include "range_dict_util.h" #include "stmt_toporder.h" #include "SSAFullRangeData.cc" #define min(x,y) ((x) < (y)) ? (x) : (y) static int _debug_level = 0; /// Template instantiations template class Array<SSAFullRangeData *>; /// SSAFullRangeDict SSAFullRangeDict::SSAFullRangeDict(SSAProgramUnit &pgm, int debug GIV(0)) : RangeDict(pgm.symtab()), _control_ranges(pgm, debug - 20) { if (pgm.stmts().entries() == 0) return; _debug_level = debug; _pgm_ref = &pgm; _num_poisoned_ranges = 0; _timestamp = 0; _stmt_toporder = stmt_toporder(pgm.stmts()); remove_min_max_var_conflicts(pgm.symtab()); } /// Destructor SSAFullRangeDict::~SSAFullRangeDict() { delete _stmt_toporder; } /// touch void SSAFullRangeDict::touch() { data_touch(); Iterator<Statement> stmt_iter = _pgm_ref->stmts().iterator(); for ( ; stmt_iter.valid(); ++stmt_iter) { const Statement &stmt = stmt_iter.current(); const Statement &rep_stmt = _control_ranges.representative_stmt(stmt); if (&stmt == &rep_stmt) { RefSet<Symbol> *vars = _control_ranges.range_vars(stmt); Iterator<Symbol> def_iter = *vars; for ( ; def_iter.valid(); ++def_iter) _get_range_ref(def_iter.current(), stmt); delete vars; } } } /// control_touch void SSAFullRangeDict::control_touch() { _control_ranges.touch(); } /// data_touch void SSAFullRangeDict::data_touch() { KeyIterator<Symbol,Statement> def_iter = _pgm_ref->_def_map; for ( ; def_iter.valid(); ++def_iter) { bool is_poisoned; const Symbol &var = def_iter.current_key(); if (var.type().data_type() == INTEGER_TYPE && ! var.is_array()) _get_data_range_ref(var, is_poisoned); } } /// num_data_ranges int SSAFullRangeDict::num_data_ranges() const { return _data_ranges.entries(); } /// num_poisoned_ranges int SSAFullRangeDict::num_poisoned_ranges() const { return _num_poisoned_ranges; } /// set_range void SSAFullRangeDict::_set_range(const Symbol &var, const Statement &stmt, Expression *range) { p_abort("Ranges cannot be modified in a SSAFullRangeDict object."); } /// del_range void SSAFullRangeDict::_del_range(const Symbol &var, const Statement &stmt) { p_abort("Ranges cannot be modified in a SSAFullRangeDict object."); } /// ins_data_range /// Add a new data range. Also delete the associated poisoned data /// range, if it exists, since it would no longer be needed. const Expression & SSAFullRangeDict::_ins_data_range(const Symbol &var, Expression *range) { if (! range) range = omega(); _data_ranges.ins(var, range); if (_debug_level >= 10) cout << "! Inserted data range: " << var.name_ref() << " = " << *range << endl; return *range; } /// _are_all_id_args /// Return true if the arguments of the given expression is all ID exprs. static bool _are_all_id_args(const Expression &expr) { Iterator<Expression> iter = expr.arg_list(); for ( ; iter.valid(); ++iter) if (iter.current().op() != ID_OP) return false; return true; } /// _init_data_preds /// Initialize the arg_preds field of the given SSAFullRangeData object. static void _init_data_preds(SSAFullRangeData &data) { const Statement *flow_join_stmt = &data.stmt(); while (flow_join_stmt && flow_join_stmt->pred().entries() == 1 && flow_join_stmt->pred().member(*flow_join_stmt->prev_ref())) flow_join_stmt = flow_join_stmt->prev_ref(); p_assert(flow_join_stmt, "Couldn't find the control flow join statement for the given phi-statement."); const List<Expression> &phi_args = data.stmt().rhs().parameters_guarded().arg_list(); /// ... Don't build the arg_preds field for unreachable phi-statements. if (flow_join_stmt->pred().entries() == 0) return; p_assert(flow_join_stmt->pred().entries() == phi_args.entries(), "There number of phi arguments and the number of flow predecessors differ."); RefSet<Symbol> multiple_args; Iterator<Statement> pred_iter = flow_join_stmt->pred(); int arg_num = 0; for ( ; pred_iter.valid(); ++pred_iter, ++arg_num) { const Symbol &arg_var = phi_args[arg_num].symbol(); if (! multiple_args.member(CASTAWAY(Symbol &) arg_var)) if (data.arg_preds.member(CASTAWAY(Symbol &) arg_var)) { /// ... Variable occurs in more than one argument of the phi /// ... function. So, conservatively make it have no predecessors. data.arg_preds.del(CASTAWAY(Symbol &) arg_var); multiple_args.ins(CASTAWAY(Symbol &) arg_var); } else data.arg_preds.ins(arg_var, pred_iter.current()); } } /// _order_args /// Sort the SSAFullRangeData arguments in topological order. void SSAFullRangeDict::_order_args(SSAFullRangeData &data) const { RefList<Symbol> unordered_args = data.args; data.args.clear(); Map<Symbol,IntElem> arg_order; while (unordered_args.entries()) { Symbol &arg = unordered_args.grab(0); const Statement *def = _pgm_ref->_def_map.find_ref(arg); int order = -1; if (def) { const IntElem *order_elem = _stmt_toporder->find_ref(def->tag()); if (order_elem) order = order_elem->value(); } Iterator<Symbol> iter = data.args; for ( ; iter.valid() && order > arg_order[iter.current()]; ++iter); if (iter.valid()) data.args.ins_before(arg, iter.current()); else data.args.ins_last(arg); arg_order.ins(arg, new IntElem(order)); } } /// _create_data /// Create an SSAFullRangeData object for the given statement. /// Return NULL if this creation fails. SSAFullRangeData * SSAFullRangeDict::_create_data(const Statement &stmt, int &df_num, RefList<SSAFullRangeData> &scc_node_stack) { SSAFullRangeData *data = new SSAFullRangeData(stmt, _timestamp, *this, _debug_level); /// ... Speed (vs. accurracy) optimization. data->union_arg_ranges = true; if (data->is_phi_stmt && ! _are_all_id_args(stmt.rhs().parameters_guarded())) { if (_debug_level >= 20) { cout << "! Couldn't create SSAFullRangeData object for definition: "; int zero = 0; stmt.write(cout, zero); } delete data; return 0; } if (data->is_phi_stmt) _init_data_preds(*data); _pending_ranges.ins(stmt.lhs().symbol(), data); ++df_num; data->df_order = df_num; data->low_link = df_num; scc_node_stack.ins_first(*data); /// ... Add links to the ranges or SSAFullRangeData objects /// ... that are needed by my data object to compute my value. Iterator<Expression> use_iter = stmt.in_refs(); for ( ; use_iter.valid(); ++use_iter) { const Symbol *var = use_iter.current().base_variable_ref(); if (! data->args.member(* CASTAWAY(Symbol *) var)) data->args.ins_last(* CASTAWAY(Symbol *) var); SSARangeOrData *link; if (! var || var->is_array() || var->type().data_type() != INTEGER_TYPE) link = new SSARangeOrData(0); else link = new SSARangeOrData(_probe_data_ranges(*var, df_num, scc_node_stack)); data->arg_ranges_or_data.ins(*var, link); if (link->is_data() && link->data().timestamp() == _timestamp) { data->needs_iteration = true; if (scc_node_stack.member(link->data())) if (data->df_order < link->data().df_order) data->low_link = min(data->low_link, link->data().low_link); else data->low_link = min(data->low_link, link->data().df_order); } } if (data->needs_iteration) { if (data->is_phi_stmt) _order_args(*data); /// ... Put myself in the users fields of the SSAFullRangeData objects /// ... I depend upon. RefSet<SSAFullRangeData> *succs = data->succs(); Iterator<SSAFullRangeData> succ_iter = *succs; for ( ; succ_iter.valid(); ++succ_iter) succ_iter.current().users.ins(*data); } return data; } /// _mark_data_as_computed /// Set the computed field to true for all nodes in the graph rooted at /// data. void SSAFullRangeDict::_mark_data_as_computed(SSAFullRangeData &data) { const Symbol &var = data.stmt().lhs().symbol(); if (! data.computed) { p_assert(data.is_poisoned && data.timestamp() != _timestamp, "Non-poisoned data cannot be marked as computed."); data.computed = true; RefSet<SSAFullRangeData> *succs = data.succs(); Iterator<SSAFullRangeData> iter = *succs; for ( ; iter.valid(); ++iter) _mark_data_as_computed(iter.current()); delete succs; } } /// _commit_data /// Commit the range computed by my data object, as well as ranges /// computed by the data objects for my arguments. /// Return NULL if this creation fails. void SSAFullRangeDict::_commit_data(SSAFullRangeData &data) { p_assert(! data.is_poisoned && data.timestamp() == _timestamp, "Poisoned data cannot be committed."); const Symbol &var = data.stmt().lhs().symbol(); if (! _data_ranges.member(var)) { _ins_data_range(var, data.grab_range()); data.computed = true; RefSet<SSAFullRangeData> *succs = data.succs(); Iterator<SSAFullRangeData> iter = *succs; for ( ; iter.valid(); ++iter) _commit_data(iter.current()); delete succs; } } /// _delete_data /// Delete my data object and all data objects belonging to my arguments. void SSAFullRangeDict::_delete_data(SSAFullRangeData &data) { if (data.timestamp() == _timestamp) { Symbol & temp = CASTAWAY(Symbol &) data.stmt().lhs().symbol(); SSAFullRangeData *my_data = _pending_ranges.grab(temp); p_assert(my_data, "Tried to delete an already deleted SSAFullRangeData object."); KeyIterator<Symbol,SSARangeOrData> iter = data.arg_ranges_or_data; for ( ; iter.valid(); ++iter) if (_pending_ranges.member(iter.current_key()) && iter.current_data().is_data()) _delete_data(iter.current_data().data()); delete my_data; } } /// add_leaf_nodes_to_set /// Add all nodes whose ordering is smaller than all of its successors /// to the set. static void _add_leaf_nodes_to_set(const Array<SSAFullRangeData *> &iter_order, IntSet &start_nodes) { for (int i = 0; i < iter_order.entries(); ++i) { const SSAFullRangeData &data = *iter_order[i]; bool smaller_than_args = true; RefSet<SSAFullRangeData> *succs = data.succs(); Iterator<SSAFullRangeData> succ_iter = *succs; for ( ; succ_iter.valid() && smaller_than_args; ++succ_iter) { SSAFullRangeData &succ_data = succ_iter.current(); if (succ_data.needs_iteration && succ_data.toporder < data.toporder) smaller_than_args = false; } delete succs; if (smaller_than_args) start_nodes.ins(data.toporder); } } /// add_phi_nodes_to_set /// Add all nodes for phi-statements to the set. static void _add_phi_nodes_to_set(const Array<SSAFullRangeData *> &iter_order, IntSet &phi_nodes) { for (int i = 0; i < iter_order.entries(); ++i) { const SSAFullRangeData &data = *iter_order[i]; if (data.is_phi_stmt) phi_nodes.ins(data.toporder); } } /// calc_iter_order /// Compute an order to visit the SSAFullRangeDict nodes during an /// iteration. This order is a reverse topological ordering of the /// graph, ignoring back edges. (Reverse topological ordering means /// that if there is an edge (U --> V), then rtoporder(U) >= rtoporder(V).) void SSAFullRangeDict::_calc_iter_order1(SSAFullRangeData &data, RefList<SSAFullRangeData> &iter_order_list) { if (data.toporder < 0) { const IntElem *toporder_elem = _stmt_toporder->find_ref(data.stmt().tag()); p_assert(toporder_elem, "Statement was not assigned a topological ordering value."); int to = toporder_elem->value(); p_assert(to >= 0, "Statement has a negative topological ordering value."); data.toporder = to; /// ... Insert data into iter_order_list, which is sorted by toporder. Iterator<SSAFullRangeData> order_iter = iter_order_list; for ( ; order_iter.valid() && to > order_iter.current().toporder; ++order_iter); p_assert(! order_iter.valid() || to < order_iter.current().toporder, "Internal error: SSAFullRangeData object was inserted twice in iter_order."); if (order_iter.valid()) iter_order_list.ins_before(data, order_iter.current()); else iter_order_list.ins_last(data); /// ... Visit the data object's successors. RefSet<SSAFullRangeData> *succs = data.succs(); Iterator<SSAFullRangeData> succ_iter = *succs; for ( ; succ_iter.valid(); ++succ_iter) _calc_iter_order1(succ_iter.current(), iter_order_list); } } Array<SSAFullRangeData *> * SSAFullRangeDict::_calc_iter_order(SSAFullRangeData &root_node) { RefList<SSAFullRangeData> iter_order_list; _calc_iter_order1(root_node, iter_order_list); Array<SSAFullRangeData *> *iter_order = new Array<SSAFullRangeData *>(iter_order_list.entries()); for (int i = 0; i < iter_order->entries(); ++i) { (*iter_order)[i] = &iter_order_list.grab(0); (*iter_order)[i]->toporder = i; } p_assert(iter_order_list.entries() == 0, "Internal Error: not all SSAFullRangeData objects were places in iter_order."); return iter_order; } /// iterate_to_fixed_point_phase /// Iterate over the pending SSAFullRangeData nodes until a fixed point /// is reached. void SSAFullRangeDict::_iterate_to_fixed_point_phase(const Array<SSAFullRangeData *> &rtoporder_to_stmt, const IntSet &start_stmts, bool widening_phase) { IntSet work_list(start_stmts); /// ... List of statements that need to be updated. /// ... Iterate until there are no more elements on the work list while (work_list.entries() > 0) { for (int data_num = work_list.first(); data_num != -1; data_num = work_list.next(data_num)) { SSAFullRangeData &data = *rtoporder_to_stmt[data_num]; work_list.del(data_num); if (data.update(widening_phase)) { Iterator<SSAFullRangeData> user_iter = data.users; for ( ; user_iter.valid(); ++user_iter) work_list.ins(user_iter.current().toporder); } } } } /// iterate_to_fixed_point /// Iterate on the given range dependence graph, starting at the given /// node, until a fixed point is reached. void SSAFullRangeDict::_iterate_to_fixed_point(SSAFullRangeData &root_node) { /// ... Determine a good order to visit the SSAFullRangeData nodes. Array<SSAFullRangeData *> *iter_order = _calc_iter_order(root_node); /// ... Widening phase: /// ... This phase iterates to a fixed point, applying the widening operator /// ... on all statements with back edges. /// ... The widening operator makes an overly conservative estimate of the /// ... fixed point value, so as to guarrantee convergence. if (_debug_level >= 20) cout << "\nWidening Phase:\n"; IntSet start_nodes(iter_order->entries()); _add_phi_nodes_to_set(*iter_order, start_nodes); /// ... _add_leaf_nodes_to_set(*iter_order, start_nodes); for (int data_num = start_nodes.first(); data_num != -1; data_num = start_nodes.next(data_num)) (* iter_order)[data_num]->needs_widening = true; _iterate_to_fixed_point_phase(*iter_order, start_nodes, true); /// ... Narrowing phase: /// ... This phase iterates to a fixed point, applying the narrowing operator /// ... on all statements with back edges. /// ... The narrowing operator attempts to regain some of the information /// ... lost by the widening operator. if (_debug_level >= 20) cout << "\nNarrowing Phase:\n"; IntSet phi_nodes(iter_order->entries()); _add_phi_nodes_to_set(*iter_order, phi_nodes); _iterate_to_fixed_point_phase(*iter_order, phi_nodes, false); delete iter_order; } /// probe_data_ranges /// Search through the program to collect all phi statements that may /// affect the values of the arguments of the phi statement for the /// given variable. If the dependences between these phi statements are /// acyclic, immediately compute and return the range for the given phi /// statement. Otherwise, return a SSAFullRangeData object representing /// the root node of this cyclic dependency graph. SSARangeOrData SSAFullRangeDict::_probe_data_ranges(const Symbol &var, int &df_num, RefList<SSAFullRangeData> &scc_node_stack) { const Expression *range = _data_ranges.find_ref(var); if (range) { /// ... Range has already been computed. So return it. return SSARangeOrData(range); } else { const Statement *def = _pgm_ref->_def_map.find_ref(var); if (! def || def->stmt_class() != ASSIGNMENT_STMT || def->rhs().type().data_type() != INTEGER_TYPE || contains_func_call(*def)) { /// ... Definition for variable is not a legal assignment statement. /// ... So set its range to NULL. if (_debug_level >= 20) { if (def) { cout << "! Unknown statement type for definition: "; int zero = 0; def->write(cout, zero); } else cout << "! No definition for variable " << var.name_ref() << endl; } return SSARangeOrData(&_ins_data_range(var, 0)); } else { /// ... Definition of variable is an assignment statement. // So build a SSAFullRangeData object to hold/compute /// ... the variable's range. SSAFullRangeData *data = _pending_ranges.find_ref(var); if (data) { /// ... Definition already has a SSAFullRangeData object. /// ... So return it. return SSARangeOrData(*data); } else { /// ... Create and initialize a SSAFullRangeDict object. data = _create_data(*def, df_num, scc_node_stack); if (! data) return SSARangeOrData(&_ins_data_range(var, 0)); else { if (data->needs_iteration) { /// ... My computed range needs iteration to a fixed /// ... point. if (data->df_order != data->low_link) { /// ... Node is an internal node in a strongly- /// ... connected-component (SCC), (Tarjan's algorithm /// ... is used to determine this). So return the /// ... object. return SSARangeOrData(*data); } else { /// ... Node is the root node of a SCC. So, iterate /// ... to a fixed point to compute its value. _iterate_to_fixed_point(*data); while (scc_node_stack.entries() && scc_node_stack[0].df_order >= data->df_order) scc_node_stack.del(0); if (data->is_poisoned) { _mark_data_as_computed(*data); return SSARangeOrData(*data); } else { _commit_data(*data); const Expression *range = _data_ranges.find_ref(var); p_assert(range, "_commit_data() did not commit my range."); _delete_data(*data); return SSARangeOrData(range); } } } else { data->update(); data->computed = true; p_assert(scc_node_stack.entries() > 0 && &scc_node_stack[0] == data, "Some nodes were missed by SCC algorithm."); scc_node_stack.del(0); if (data->is_poisoned) { /// ... My computed range was poisoned, (i.e., may be /// ... inaccurate because it couldn't be completely /// ... computed), so let my caller worry about it. return SSARangeOrData(*data); } else { /// ... I was able to fully compute my range. /// ... So delete my data object and store and return /// ... the computed range. SSARangeOrData result(&_ins_data_range(var, data->grab_range())); Symbol & temp = CASTAWAY(Symbol &)data->stmt().lhs().symbol(); _pending_ranges.del(temp); return result; } } } } } } } /// get_data_range_ref /// Get the range from the set of data ranges. If the range has not /// been computed, compute it now. const Expression * SSAFullRangeDict::_get_data_range_ref(const Symbol &var, bool &is_poisoned) { is_poisoned = false; if (var.is_array() || var.type().data_type() != INTEGER_TYPE) return 0; ++_timestamp; int orig_num_pending_ranges = _pending_ranges.entries(); int df_num = 0; RefList<SSAFullRangeData> scc_node_stack; SSARangeOrData range_or_data = _probe_data_ranges(var, df_num, scc_node_stack); p_assert(scc_node_stack.entries() == 0, "Some nodes were missed by SCC algorithm."); const Expression *range; if (range_or_data.is_range()) range = range_or_data.range_ref(); else { SSAFullRangeData &data = range_or_data.data(); p_assert(data.is_poisoned || data.timestamp() != _timestamp, "Unpoisoned SSAFullRangeData object returned by _probe_data_ranges()."); if (data.range_ref()) { range = &_poisoned_ranges.ins(data.range_ref()->clone()); ++_num_poisoned_ranges; } else range = 0; is_poisoned = true; if (_debug_level >= 20) { cout << "! Computed data range is poisoned: "; cout << var.name_ref() << " = "; if (range) cout << *range; else cout << "NULL"; cout << endl; } p_assert(_timestamp > 1, "A base data range was poisoned."); _delete_data(data); } p_assert(_pending_ranges.entries() == orig_num_pending_ranges, "Method SSAFullRangeDict::_get_data_range_ref() did not discard all of its temporary data structures."); --_timestamp; return range; } /// get_range_ref const Expression * SSAFullRangeDict::_get_range_ref(const Symbol &var, const Statement &stmt) { if (var.is_array() || var.type().data_type() != INTEGER_TYPE) return 0; if (_timestamp == 0) _num_poisoned_ranges = 0; const Statement &rep_stmt = _control_ranges.representative_stmt(stmt); RefMap<Symbol, Expression> *stmt_ranges = _pgm_ranges.find_ref(rep_stmt); const Expression *range; if (stmt_ranges) range = stmt_ranges->find_ref(var); else range = 0; if (! range) { /// ... Range hasn`t been computed yet. So, compute it now. bool is_poisoned = false; const Expression *data_range_ref = _get_data_range_ref(var, is_poisoned); RangeAccessor control_accessor(_control_ranges, rep_stmt); const Expression *control_range_ref = control_accessor.get_range_ref(var); if (data_range_ref && data_range_ref->op() != OMEGA_OP) { if (control_range_ref && control_range_ref->op() != OMEGA_OP) { if (! stmt_ranges) { stmt_ranges = new RefMap<Symbol, Expression>; _pgm_ranges.ins(rep_stmt, stmt_ranges); } stmt_ranges->ins(var, *control_range_ref); RangeAccessor accessor(*this, rep_stmt); Expression *new_range = intersect_ranges(data_range_ref, accessor, control_range_ref, accessor); if (! new_range) new_range = omega(); if (is_poisoned) { range = &_poisoned_ranges.ins(new_range); /// ... ++_num_poisoned_ranges; stmt_ranges->del(CASTAWAY(Symbol &) var); } else { range = &_range_values.ins(new_range); stmt_ranges->ins(var, *range); } } else range = data_range_ref; } else if (control_range_ref && control_range_ref->op() != OMEGA_OP) range = control_range_ref; else range = 0; } if (range && range->op() == OMEGA_OP) range = 0; if (_timestamp == 0) _poisoned_ranges.clear(); return range; } /// clear void SSAFullRangeDict::clear() { _control_ranges.clear(); _data_ranges.clear(); _pgm_ranges.clear(); _pending_ranges.clear(); _range_values.clear(); _poisoned_ranges.clear(); _timestamp = 0; _num_poisoned_ranges = 0; } /// clear void SSAFullRangeDict::clear_ranges() { _control_ranges.clear_ranges(); _data_ranges.clear(); _pgm_ranges.clear(); _pending_ranges.clear(); _range_values.clear(); _poisoned_ranges.clear(); _timestamp = 0; _num_poisoned_ranges = 0; } /// control_range_dict SSAControlRangeDict & SSAFullRangeDict::control_range_dict() { return _control_ranges; } /// print void SSAFullRangeDict::print(ostream & o) const { o << "["; o << "pgm_ranges={"; KeyIterator<Statement, RefMap<Symbol, Expression> > pgm_range_iter = _pgm_ranges; bool first_stmt = true; for ( ; pgm_range_iter.valid(); ++pgm_range_iter) { if (! first_stmt) o << ", "; else first_stmt = false; o << pgm_range_iter.current_key().tag() << ": {"; KeyIterator<Symbol, Expression> stmt_range_iter = pgm_range_iter.current_data(); bool first_symbol = true; for ( ; stmt_range_iter.valid(); ++stmt_range_iter) { if (! first_symbol) o << ", "; else first_symbol = false; o << stmt_range_iter.current_key().name_ref() << ": " << stmt_range_iter.current_data(); } o << "}"; } o << "}"; /// ... o << ", control_ranges=" << _control_ranges; o << ", data_ranges={"; KeyIterator<Symbol, Expression> data_range_iter = _data_ranges; bool first_symbol = true; for ( ; data_range_iter.valid(); ++data_range_iter) { if (! first_symbol) o << ", "; else first_symbol = false; o << data_range_iter.current_key().name_ref() << ": " << data_range_iter.current_data(); } o << "}"; o << ", pending_ranges={"; KeyIterator<Symbol, SSAFullRangeData> pend_iter = _pending_ranges; first_symbol = true; for ( ; pend_iter.valid(); ++pend_iter) { if (! first_symbol) o << ", "; else first_symbol = false; o << pend_iter.current_key().name_ref() << ": " << pend_iter.current_data(); } o << "}"; o << ", timestamp=" << _timestamp; o << "]"; } /// pretty_print void SSAFullRangeDict::pretty_print(ostream & o, const Statement &stmt) const { o << "["; o << "control ranges = "; _control_ranges.pretty_print(o, stmt); o << ", data ranges = {"; RefList<Symbol> sorted_keys; KeyIterator<Symbol,Expression> data_iter = _data_ranges; for ( ; data_iter.valid(); ++data_iter) sorted_keys.ins_last(data_iter.current_key()); sort_sym_list(sorted_keys); Iterator<Symbol> key_iter = sorted_keys; bool first = true; bool need_comma = true; for ( ; key_iter.valid(); ++key_iter) { if (! first && need_comma) o << ", "; else first = false; const Symbol &var = key_iter.current(); const Expression *value = _data_ranges.find_ref(var); if (value->op() != OMEGA_OP || _debug_level >= 30) { pretty_print_range(o, *value, var); need_comma = true; } else need_comma = false; } o << "}"; o << ", merged ranges = {"; const RefMap<Symbol,Expression> *stmt_ranges = _pgm_ranges.find_ref(stmt); if (stmt_ranges) { sorted_keys.clear(); KeyIterator<Symbol,Expression> merged_iter = *stmt_ranges; for ( ; merged_iter.valid(); ++merged_iter) sorted_keys.ins_last(merged_iter.current_key()); sort_sym_list(sorted_keys); first = true; need_comma = true; for (key_iter.reset(); key_iter.valid(); ++key_iter) { if (! first && need_comma) o << ", "; else first = false; const Symbol &var = key_iter.current(); const Expression *value = stmt_ranges->find_ref(var); if (value->op() != OMEGA_OP || _debug_level >= 30) { pretty_print_range(o, *value, var); need_comma = true; } else need_comma = false; } } o << "}"; o << "]"; } /// listable_clone Listable * SSAFullRangeDict::listable_clone(void) const { p_abort("SSAFullRangeDicts cannot be duplicated."); return 0; } /// structures_OK int SSAFullRangeDict::structures_OK() const { return 1; }

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