Polaris: TranslateObject.cc Source File

TranslateObject.cc Go to the documentation of this file. /// /// #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif /// #include <stdio.h> #include <strstream.h> #include "TranslateObject.h" #include "Expression/expr_funcs.h" #include "Expression/LambdaCallExpr.h" #include "Info.h" #include "ProgramUnit.h" #include "Symbol/VariableSymbol.h" #include "StmtList.h" template class TypedBaseMap<Symbol,TranslateObject::SymRefElem>; template class ProtoMap<Symbol,TranslateObject::SymRefElem>; template class Map<Symbol,TranslateObject::SymRefElem>; template ostream & operator << (ostream &, const Map<Symbol,TranslateObject::SymRefElem> &); template class KeyIterator<Symbol,TranslateObject::SymRefElem>; Listable * TranslateObject::SymRefElem::listable_clone() const { return new SymRefElem(*this); } void TranslateObject::SymRefElem::print(ostream & o) const { o << '<'; if (_symref.valid()) _symref->print(o); if (_privat == PRIVATE) o << ", Private"; else o << ", Non-Private"; if (_precalc == CAND_PRECALC_VAR) o << ", Candidate-Precalc>"; else o << ", Not-Precalc>"; } /// Copy translate object TranslateObject::TranslateObject(const TranslateObject & map) : _pgm_main(map._pgm_main), _permanent_changes(map._permanent_changes), _debug_flag(map._debug_flag), _private_vars(map._private_vars), _precalc_vars(map._precalc_vars), _test_exprs(map._test_exprs) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(TRANSLATE_OBJECT, sizeof(TranslateObject), this); #endif p_assert(_pgm_ref != &_pgm_main, "Invalid attempt to clone TranslateObject"); _pgm_ref = new ProgramUnit(*map._pgm_ref); _pgm_owned = true; /// Translate local program symbols in symbol, array, substring and /// constant maps: main program symbols (including SymRefElems) /// and expressions do not need to be translated for (DictionaryIter<Symbol> symbol_iter = _pgm_ref->symtab().iterator(); symbol_iter.valid(); ++symbol_iter) { if ((symbol_iter.current().sym_class() != VARIABLE_CLASS) || (!symbol_iter.current().formal())) { Symbol *current_symbol_ptr = &symbol_iter.current(); Symbol & current_symbol = *current_symbol_ptr; const char *current_tag = current_symbol.name_ref(); Symbol *map_symbol_ptr = map._pgm_ref->symtab().find_ref(current_tag); p_assert(map_symbol_ptr, "Invalid symbol found in map in TranslateObject constructor"); const SymRefElem *symbol_data_ref = map._symbol_map.find_ref(*map_symbol_ptr); if (symbol_data_ref) { _symbol_map.ins(current_symbol,symbol_data_ref->clone()); const Expression *array_data_ref = map._array_map.find_ref(*map_symbol_ptr); if (array_data_ref) { _array_map.ins(current_symbol, array_data_ref->clone()); } const Expression *substring_data_ref = map._substring_map.find_ref(*map_symbol_ptr); if (substring_data_ref) { _substring_map.ins(current_symbol, substring_data_ref->clone()); } const Expression *alternate_data_ref = map._alternate_map.find_ref(*map_symbol_ptr); if (alternate_data_ref) { _alternate_map.ins(current_symbol, alternate_data_ref->clone()); } continue; } const Expression *constant_data_ref = map._constant_map.find_ref(*map_symbol_ptr); if (constant_data_ref) _constant_map.ins(current_symbol, *constant_data_ref); } } /// Translate format map for (KeyIterator<int,Format> format_iter = _pgm_ref->formats(); format_iter.valid(); ++format_iter) { Format & current_format = format_iter.current_data(); int current_value = current_format.value(); const Format *map_format_ptr = map._pgm_ref->formats().find_ref(current_value); p_assert(map_format_ptr, "Invalid format found in map in TranslateObject constructor"); const Format *main_format_ptr = map._format_map.find_ref(*map_format_ptr); p_assert(main_format_ptr, "Valid format not found in map in TranslateObject constructor"); _format_map.ins(current_format, CASTAWAY (Format &) *main_format_ptr); } } /// Copy translate object TranslateObject::TranslateObject(const TranslateObject & map, const ProgramUnit & new_main_pgm) : _pgm_main(CASTAWAY(ProgramUnit &) new_main_pgm), _pgm_owned(false), _permanent_changes(false), _debug_flag(map._debug_flag), _private_vars(0), _precalc_vars(0) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(TRANSLATE_OBJECT, sizeof(TranslateObject), this); #endif p_assert((map._pgm_ref == &map._pgm_main) && !map._array_map.entries() && !map._constant_map.entries() && !map._substring_map.entries() && !map._alternate_map.entries() && !map._test_exprs.entries() && !map._begin_comment_list.entries() && !map._end_comment_list.entries() && !map._format_map.entries(), "Invalid attempt to clone TranslateObject"); _pgm_ref = &_pgm_main; /// Translate main program symbol references (including SymRefElems) in _symbol_map /// to refer to new_main_pgm for (KeyIterator<Symbol,SymRefElem> symbol_iter = map._symbol_map; symbol_iter.valid(); ++symbol_iter) { const Symbol & curr_key_sym = symbol_iter.current_key(); Symbol * new_key_sym = CASTAWAY(Symbol *) new_main_pgm.symtab().find_ref(curr_key_sym.name_ref()); p_assert(new_key_sym, "Invalid symbol found in TranslateObject to be cloned"); const RefElement<Symbol> & curr_data_sym = symbol_iter.current_data().symref(); if (curr_data_sym.valid()) { Symbol * new_data_sym = CASTAWAY(Symbol *) new_main_pgm.symtab().find_ref(curr_data_sym->name_ref()); p_assert(new_data_sym, "Invalid symbol found in TranslateObject to be cloned"); _symbol_map.ins(*new_key_sym, new SymRefElem(*new_data_sym)); } else /// ... Must be a pseudo function symbol (e.g., BETA) _symbol_map.ins(*new_key_sym, new SymRefElem()); } } TranslateObject::~TranslateObject() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(TRANSLATE_OBJECT, this); #endif /// if (_pgm_owned) /// delete _pgm_ref; /// ... Removed this since it was causing a p_assert about attempting /// ... to delete a live object. Apparently the cloned ProgramUnit gets /// ... put in the Program (or on some kind of ProgramUnit list). } Listable * TranslateObject::listable_clone() const { return new TranslateObject(*this); } void TranslateObject::print(ostream & o) const { if (&_pgm_main != _pgm_ref) { o << "Inlined program:\n\n"; o << *_pgm_ref; } o << "\nSymbol map:\n\n"; o << _symbol_map; o << "\nArray map:\n\n"; o << _array_map; o << "\nConstant map:\n\n"; o << _constant_map << "\n"; o << "\nFormat map:\n\n"; o << _format_map; o << "\nSubstring map:\n\n"; o << _substring_map; o << "\nAlternate expression map:\n\n"; o << _alternate_map; o << "\nSubscript test expressions:\n\n"; o << _test_exprs; } /// Return an initial subscript for the variable pointed to by /// src_name_ptr. Expression * initial_array_ref(Symbol * src_name_ptr) { p_assert(src_name_ptr->sym_class() == VARIABLE_CLASS, "Illegal symbol passed to src_name_ptr"); Expression *returned_ref = comma(); /// Add a clone of lower bound (or 1 if not defined) for each dimension for (Iterator<ArrayBounds> array_iter = src_name_ptr->dim(); array_iter.valid(); ++array_iter) { Expression *lb = array_iter.current().lower_ref(); if (lb) lb = lb->clone(); else lb = constant(1); returned_ref->arg_list().ins_last(lb); } return returned_ref; } VariableSymbol * TranslateObject::translate_symbol ( const Symbol & in_symbol ) const { VariableSymbol * symbol_ptr = 0; const SymRefElem *symbol_ref = _symbol_map.find_ref(in_symbol); if (symbol_ref) symbol_ptr = (VariableSymbol *) &(*symbol_ref->symref()); return symbol_ptr; } /// Find all array references in this expression specified by _array_map /// and replace them with LAMBDA_CALL expressions to the caller's array. /// /// Find all substring references in this expression specified by /// _substring_map and replace them with appropriate substring expressions. /// /// Find all symbol references in this expression specified by _symbol_map /// or _constant_map and replace them. /// /// Find all format references in this expression specified by _format_map /// and replace them. /// /// If an alternate expression exists in _alternate_map for references in /// this expression, attempt to use it instead of the equivalent expression. Expression * TranslateObject::_translate_symbol_refs_expr(Expression * expr, REF_TYPE ref, bool & expr_flag, const Map<Symbol, Expression> *formal_to_actual) const { /// Initially, return original expression Expression *e = expr; /// Nothing transformed here so far bool repl_flag = false; /// Check by type of operator switch (expr->op()) { case SUBSTRING_OP: { List<Expression> & substr_list = expr->arg_list(); /// ... Translate bound expression bool local_expr_flag = false; Assign<Expression> bound_as(substr_list.assign(1)); bound_as = _translate_symbol_refs_expr(substr_list.pull(1), IN_REF_EXPR, local_expr_flag, formal_to_actual); repl_flag |= local_expr_flag; if ((_debug_flag > 19) && (local_expr_flag)) cerr << "Replacement of substring bound detected.\n"; /// ... Translate string expression local_expr_flag = false; Assign<Expression> string_as(substr_list.assign(0)); string_as = _translate_symbol_refs_expr(substr_list.pull(0), IN_REF_EXPR, local_expr_flag, formal_to_actual); repl_flag |= local_expr_flag; if ((_debug_flag > 19) && (local_expr_flag)) cerr << "Replacement of substring string detected.\n"; /// ... If string expression is also a substring, fix up expression if (substr_list[0].op()==SUBSTRING_OP) { /// ... Grab subexpressions Expression * string_ptr = substr_list.grab(0); Expression * bound_ptr = substr_list.grab(1); /// ... Delete empty top-level expression delete expr; /// ... Make string expression top-level expression e = string_ptr; /// ... Point at old bound expressions List<Expression> & old_bound_list = bound_ptr->arg_list(); int old_bound_entries = old_bound_list.entries(); /// ... Adjust new bound expressions accordingly List<Expression> & new_bound_list = e->bound().arg_list(); Expression * le = old_bound_list.grab(0); if (le->op() == OMEGA_OP) delete le; else { Assign<Expression> new_bound_as(new_bound_list.assign(0)); new_bound_as = sub(add(le,new_bound_list.pull(0)), constant(1)); } if (old_bound_entries > 1) { Expression * ue = old_bound_list.grab(0); if (ue->op() != OMEGA_OP) { new_bound_list.del(1); new_bound_list.ins_last(sub(add(ue,le->clone()), constant(1))); } else delete ue; } /// ... Delete empty old bound expression delete bound_ptr; } break; } case ARRAY_REF_OP: { bool local_expr_flag = false; /// ... Take subscript out of original expression Expression * subs_e = expr->grab_right(); /// ... Check subscript for substitution subs_e = _translate_symbol_refs_expr(subs_e, IN_REF_EXPR, local_expr_flag, formal_to_actual); if ((_debug_flag > 19) && (local_expr_flag)) cerr << "Replacement of array subscript detected.\n"; /// ... If something replaced, remember for later repl_flag |= local_expr_flag; /// ... Point at base variable VariableSymbol *name_ptr = (VariableSymbol *) expr->base_variable_ref(); /// ... Look up base variable in symbol, array and substring maps const VariableSymbol *symbol_ptr = translate_symbol( *name_ptr ); /// const SymRefElem *symbol_ref // = _symbol_map.find_ref(*name_ptr); /// if (symbol_ref) // symbol_ptr = (VariableSymbol *) &(*symbol_ref->symref()); const Expression *array_ptr = _array_map.find_ref(*name_ptr); const Expression *substr_ptr = _substring_map.find_ref(*name_ptr); /// ... Eventually, add support for alternate expressions here /// ... (when equivalence variable does not have to be identical /// ... any longer) if (array_ptr) { p_assert(symbol_ptr, "Array map entry but no symbol map " "entry in _translate_symbol_refs_expr"); /// ... We will replace array reference repl_flag = true; /// ... Delete original expression delete expr; /// ... Define new array reference Expression *ref_e = array_reference(id(*symbol_ptr), array_ptr->clone()); /// ... Absorb ref_e and subs_e as subexpressions of ex /// ... Define lambda call expression Expression *ex = new LambdaCallExpr(ref_e->type(), ref_e, subs_e); /// ... If substring, add it around array reference if (substr_ptr) ex = substring(ex, substr_ptr->clone()); if (_debug_flag > 19) cerr << "Replacement of array reference to " << *name_ptr << " detected with pattern " << *ex << "\n"; /// ... Replace whole original expression e = ex; } else if (symbol_ptr) { /// ... We will replace array reference repl_flag = true; /// ... If not translating an in-out-expr, look up base variable /// ... in alternate map const Expression * alternate_ptr = 0; if (ref != IN_OUT_REF_EXPR) alternate_ptr = _alternate_map.find_ref(*name_ptr); /// ... If translating an array reference with a single constant /// ... subscript and an available alternate expression, translate using /// ... the alternate expression with an appropriate intrinsic /// ... function around it (eventually, do more general translation) Expression & subs_ref = subs_e->arg_list()[0]; if (alternate_ptr && (subs_ref.op() == INTEGER_CONSTANT_OP)) { // Copy subscript value int subs_val = subs_ref.value(); // Delete subscript and original expression delete subs_e; delete expr; static String real_str("REAL"); static String aimag_str("AIMAG"); static Type func_type(REAL_TYPE, 0); Expression * func_id_ptr = NULL; switch (subs_val) { case 1: { /// ... Create call to "REAL" function const Symbol * func_ptr = _pgm_main.symtab().find_ref(real_str); if (func_ptr) func_id_ptr = id(*func_ptr); else func_id_ptr = new_intrinsic(real_str, func_type, _pgm_main); break; } case 2: { /// ... Create call to "AIMAG" function const Symbol * func_ptr = _pgm_main.symtab().find_ref(aimag_str); if (func_ptr) func_id_ptr = id(*func_ptr); else func_id_ptr = new_intrinsic(aimag_str, func_type, _pgm_main); break; } default: p_abort("Invalid subscript encountered in alternate " "array in _translate_symbol_refs_expr"); } e = intrinsic_call(func_id_ptr,comma(alternate_ptr->clone())); if (_debug_flag > 19) cerr << "Replacement of array reference to " << *name_ptr << " with alternate reference " << *e << " detected.\n"; } else { // Put subscript back into original expression expr->right(subs_e); // Modify original expression in place expr->array().symbol(*symbol_ptr); // If substring, add it around array reference if (substr_ptr) { e = substring(expr, substr_ptr->clone()); if (_debug_flag > 19) cerr << "Replacement of array reference to " << *name_ptr << " with substring reference " << *e << " detected.\n"; } else if (_debug_flag > 19) cerr << "Replacement of array reference to " << *name_ptr << " with identical reference to " << *symbol_ptr << " detected.\n"; } } else { /// ... Put subscript back into original expression expr->right(subs_e); } break; } case ID_OP: { switch (expr->symbol().sym_class()) { case VARIABLE_CLASS:{ /// ... Point at variable VariableSymbol *name_ptr = (VariableSymbol *) & expr->symbol(); /// ... Look up variable in symbol, array and substring maps VariableSymbol *symbol_ptr = translate_symbol (*name_ptr); // if (! symbol_ptr) { // symbol_ptr = new VariableSymbol(*name_ptr); // symbol_ptr->relink_dptrs(_pgm_main); // } // const SymRefElem *symbol_ref // = _symbol_map.find_ref(*name_ptr); // if (symbol_ref) // symbol_ptr = (VariableSymbol *) &(*symbol_ref->symref()); const Expression *array_ptr = _array_map.find_ref(*name_ptr); const Expression *substr_ptr = _substring_map.find_ref(*name_ptr); if (array_ptr) { p_assert(symbol_ptr, "Array map entry but no symbol " "map entry in _translate_symbol_refs_expr"); if (_debug_flag > 19) cerr << "Replacement of scalar reference to " << *name_ptr << " with array reference to " << *symbol_ptr << " with pattern:\n"; // We will replace ID expression repl_flag = true; // Define new array reference Expression *ref_e = array_reference(id(*symbol_ptr), array_ptr->clone()); if (name_ptr->is_array()) { /// ... Absorb ref_e as subexpression of ex /// ... Define lambda call expression Expression *ex = new LambdaCallExpr(expr->type(), ref_e, initial_array_ref(name_ptr)); /// ... If substring, add it around array reference if (substr_ptr) ex = substring(ex, substr_ptr->clone()); if (_debug_flag > 19) cerr << *ex << "\n"; /// ... Replace whole original expression delete expr; e = ex; } else { /// ... Replace whole original expression delete expr; /// ... If substring, add it around array reference if (substr_ptr) ref_e = substring(ref_e, substr_ptr->clone()); if (_debug_flag > 19) cerr << *ref_e << "\n"; e = ref_e; } } else if (symbol_ptr) { // We will replace ID expression repl_flag = true; // Modify original expression in place expr->symbol(*symbol_ptr); // If substring, add it around ID expression if (substr_ptr) { e = substring(expr, substr_ptr->clone()); if (_debug_flag > 19) cerr << "Replacement of scalar reference to " << *name_ptr << " with substring reference " << *e << " detected.\n"; } else if (_debug_flag > 19) cerr << "Replacement of scalar reference to " << *name_ptr << " with identical reference to " << *symbol_ptr << " detected.\n"; } else { /// ... Check constant map const Expression *constant_ptr = _constant_map.find_ref(*name_ptr); const Expression *actual_ptr = 0; if (formal_to_actual) actual_ptr = formal_to_actual->find_ref(*name_ptr); if (constant_ptr) { /// ... We will replace ID expression repl_flag = true; /// ... Replace whole original expression delete expr; if (_debug_flag > 19) cerr << "Replacement of scalar reference to " << *name_ptr << " with constant " << *constant_ptr << " detected.\n"; e = constant_ptr->clone(); } else if (actual_ptr) { /// ... We will replace ID expression repl_flag = true; /// ... Replace whole original expression delete expr; if (_debug_flag > 19) cerr << "Replacement of scalar reference to " << *name_ptr << " with actual arg " << *actual_ptr << " detected.\n"; e = actual_ptr->clone(); } } break; } case PROGRAM_CLASS: case FUNCTION_CLASS: case SUBROUTINE_CLASS: case SYMBOLIC_CONSTANT_CLASS: case BLOCK_DATA_CLASS: case NAMELIST_CLASS: { VariableSymbol * symbol_ptr = translate_symbol( expr->symbol() ); // const SymRefElem *symbol_ref // = _symbol_map.find_ref(expr->symbol()); if (symbol_ptr) { if (_debug_flag > 19) cerr << "Replacement of symbol reference to " << expr->symbol() << " with reference to " << *symbol_ptr << " detected.\n"; /// ... We will replace ID expression repl_flag = true; /// ... Modify original expression in place expr->symbol(*symbol_ptr); } break; } default: p_abort("Invalid symbol encountered in _translate_symbol_refs_expr"); } break; } case FORMAT_OP: { /// ... Point at format Format & current_format = expr->format(); /// ... Look up format in format map Format *new_format_ptr = CASTAWAY(Format *) _format_map.find_ref(current_format); /// ... If format is mapped, modify old format in place if (new_format_ptr) { if (_debug_flag > 19) cerr << "Replacement of format reference " << current_format << " with identical reference to " << *new_format_ptr << " detected.\n"; expr->format(*new_format_ptr); } break; } case INTRINSIC_CALL_OP: case FUNCTION_CALL_OP: { /// ... Handle the LEN intrinsic function with a character argument if (expr->op() == INTRINSIC_CALL_OP && (strcmp(expr->intrinsic().symbol().tag_ref(),"LEN") == 0) && expr->parameters_valid() && (expr->parameters_guarded().arg_list()[0].type().data_type() == CHARACTER_TYPE)) { /// ... Assert that function should have exactly one argument List<Expression> & parm_list = expr->parameters_guarded().arg_list(); p_assert((parm_list.entries()==1), "Invalid number of arguments to LEN function"); /// ... Translate argument bool local_expr_flag = false; Assign<Expression> parm_as(parm_list.assign(0)); parm_as = _translate_symbol_refs_expr(parm_list.pull(0), IN_REF_EXPR, local_expr_flag, formal_to_actual); repl_flag |= local_expr_flag; /// ... Check if translated argument is a substring expression if (parm_list[0].op() == SUBSTRING_OP) { // Build length expression List<Expression> & bound_list = parm_list[0].bound().arg_list(); int bound_entries = bound_list.entries(); // Check if the size of the base variable is known, or, if not, // that there is an explicit upper bound int base_len = parm_list[0].base_variable_ref()->type().size(); if (base_len || ((bound_entries == 2) && (bound_list[1].op()!=OMEGA_OP))) { /// ... Substring length can be determined at compile time, so fix /// ... up expression Expression * le = bound_list.grab(0); if (le->op() == OMEGA_OP) { delete le; le = constant(1); } Expression * ue; if (bound_entries > 1) { ue = bound_list.grab(0); if (ue->op()==OMEGA_OP) { delete ue; ue = constant(base_len); } } else ue = constant(base_len); /// ... Delete top-level expression delete expr; /// ... Replace expression with calculated expression e = add(sub(ue,le),constant(1)); /// ... Expression was replaced repl_flag = true; } } break; } /// ... If this is an IN_OUT_REF_EXPR, translate argument of pseudo /// ... function in place else if ((ref == IN_OUT_REF_EXPR) && is_pseudo_function(*expr)) { /// ... Indicate that expression was modified repl_flag = true; /// ... Pull out the subexpression to be translated Expression *expr_t = expr->parameters_guarded().arg_list().grab(1); /// ... Delete top-level expression delete expr; /// ... Return translated subexpression bool local_expr_flag = false; e = _translate_symbol_refs_expr(expr_t, IN_OUT_REF_EXPR, local_expr_flag, formal_to_actual); break; } /// ... Traverse expressions and replace any which are relevant /// ... (but do not use an alternate expression to translate any /// ... actual parameter expressions: however, their subexpressions /// ... can be translated using an alternate expression) for (Mutator<Expression> expr_mutr = expr->arg_list(); expr_mutr.valid(); ++expr_mutr) { bool local_expr_flag = false; Assign<Expression> expr_as(expr_mutr.assign()); expr_as = _translate_symbol_refs_expr(expr_mutr.pull(), IN_OUT_REF_EXPR, local_expr_flag, formal_to_actual); repl_flag |= local_expr_flag; } break; } default: { /// ... Traverse expressions and replace any which are relevant for (Mutator<Expression> expr_mutr = expr->arg_list(); expr_mutr.valid(); ++expr_mutr) { bool local_expr_flag = false; Assign<Expression> expr_as(expr_mutr.assign()); expr_as = _translate_symbol_refs_expr(expr_mutr.pull(), IN_REF_EXPR, local_expr_flag, formal_to_actual); repl_flag |= local_expr_flag; } } } /// Set final expr_flag expr_flag |= repl_flag; return e; } /// Translate symbol references for GSA within the range of an Expression /// mutator using the symbol map, returning a count of the number of /// modifications int TranslateObject::_translate_GSA_symbol_refs_mutr(Mutator<Expression> expr_mutr, REF_TYPE ref) const { int modify_counter = 0; for (; expr_mutr.valid(); ++expr_mutr) { /// ... Remove expression from arg list Assign<Expression> ex_as(expr_mutr.assign()); Expression * ex = expr_mutr.pull(); /// ... Substitute expression only once bool local_expr_flag = false; ex = _translate_symbol_refs_expr(ex, ref, local_expr_flag); /// ... If this expression was replaced, signal that it was modified if (local_expr_flag) ++modify_counter; /// ... Put expression back into arg list ex_as = ex; } return modify_counter; } /// Translate symbol references for GSA within a statement's expression /// list using the symbol map void TranslateObject::_translate_GSA_symbol_refs_stmt(Statement & s) const { /// Iterate over all statement expressions bool modify_flag = false; /// Iterate over any expressions in an assertion /// (note: do not keep track of assertion modifications, /// because they do not require any cleanup processing) for (Iterator<Assertion> assert_iter = s.assertions(); assert_iter.valid(); ++assert_iter) { Assertion & current_assert = assert_iter.current(); /// ... AssertionType current_type = current_assert.type(); if (current_assert.arg_list_valid()) _translate_GSA_symbol_refs_mutr(Mutator<Expression>(current_assert.arg_list_guarded()), IN_REF_EXPR); } /// Iterate over any s_control expressions in an I/O statement /// (keep track of modifications) if (s.s_control_valid()) { for (Iterator<s_control_type> s_iter = s.s_control_guarded(); s_iter.valid(); ++s_iter) { if (_translate_GSA_symbol_refs_mutr(Mutator<Expression>(s_iter.current().expr), IN_REF_EXPR)) modify_flag = true; } } /// Iterate over in, out, and in out ref expressions /// (keep track of modifications) if (s.iterate_in_exprs_valid() && _translate_GSA_symbol_refs_mutr(s.iterate_in_exprs_guarded(), IN_REF_EXPR)) { modify_flag = true; } if (s.iterate_out_exprs_valid() && _translate_GSA_symbol_refs_mutr(s.iterate_out_exprs_guarded(), OUT_REF_EXPR)) { modify_flag = true; } if (s.iterate_in_out_exprs_valid() && _translate_GSA_symbol_refs_mutr(s.iterate_in_out_exprs_guarded(), IN_OUT_REF_EXPR)) { modify_flag = true; } if (s.access_table_exists()) s.access_table().translate_GSA_symbols( (TranslateObject *)this ); /// If body of statement was modified, rebuild references if (modify_flag) s.build_refs(); } /// Check to see if an assignment statement is an identity assignment bool TranslateObject::_is_identity_assignment(const Statement &s) const { const Expression & lhs_expr = s.lhs(); const Expression & rhs_expr = s.rhs(); /// See if assignment is one variable to another if (lhs_expr.op()!=ID_OP || rhs_expr.op()!=ID_OP) return false; /// See if symbol on left side is to be translated const Symbol & lhs_sym = s.lhs().symbol(); const VariableSymbol * lhs_symbol = translate_symbol( lhs_sym ); /// const SymRefElem * lhs_data_ref /// = _symbol_map.find_ref(lhs_sym); /// if (!lhs_data_ref) if (lhs_symbol == 0) return false; /// See if symbol on right hand side is to be translated const Symbol & rhs_sym = s.rhs().symbol(); const VariableSymbol * rhs_symbol = translate_symbol( rhs_sym ); /// const SymRefElem * rhs_data_ref /// = _symbol_map.find_ref(rhs_sym); /// if (!rhs_data_ref) if (rhs_symbol == 0) return false; /// See if each symbol translates to the same base symbol return (lhs_symbol == rhs_symbol); } /// Translate contained GSA symbol references using the symbol map /// and remove all GSA symbols from the program void TranslateObject::translate_GSA_symbol_refs() { if (_symbol_map.entries()) { /// ... Create set of statements to delete for GSA translation RefSet<Statement> gsa_set; /// ... Translate each statement for (Iterator<Statement> stmt_iter = _pgm_ref->stmts().iterator(); stmt_iter.valid(); ++stmt_iter) { Statement & s = stmt_iter.current(); switch (s.stmt_class()) { case ASSIGNMENT_STMT: { Expression & rhs = s.rhs(); if (is_pseudo_function(rhs)) { if (rhs.op() == ALPHA_OP) { /// ... Pull out the subexpression to be translated Expression *rhs_t = rhs.parameters_guarded().arg_list().grab(1); /// ... Replace RHS by this subexpression s.rhs(rhs_t); /// ... Fall through to translation code, relying on it /// ... to rebuild statement references (which it should) } // Do not translate, and mark for later deletion else { gsa_set.ins(s); break; } } /// ... Mark identity assignment for later deletion else if (_is_identity_assignment(s)) { gsa_set.ins(s); break; } } default: _translate_GSA_symbol_refs_stmt(s); } } /// ... Delete any pseudo-assignment statements _pgm_ref->stmts().del(gsa_set); /// ... Now, go through symbol map and delete all the GSA symbols, because /// ... they are no longer in use for (KeyIterator<Symbol,SymRefElem> key_iter = _symbol_map; key_iter.valid(); ++key_iter) { if ((key_iter.current_key().sym_class() == VARIABLE_CLASS) && ((VariableSymbol &)(key_iter.current_key())).is_gsa_symbol()) { _pgm_ref->symtab().del(key_iter.current_key().name_ref()); } } /// ... Clear out symbol map now, because it is full of invalid data _symbol_map.clear(); } }

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