Polaris: stmt_util.cc Source File

stmt_util.cc Go to the documentation of this file. /// #include "expression_util.h" #include "stmt_util.h" #include "../Expression/CommaExpr.h" #include "../Expression/DoExpr.h" #include "../Expression/EqualExpr.h" #include "../InlineObject.h" #include "../Program.h" #include "../ProgramUnit.h" #include "../Statement/Statement.h" #include "../Symbol/Symbol.h" #include "../SymbolAccess.h" #include "../Range/AIRangeDict.h" #include "../Range/RangeAccessor.h" #include "../Range/Relation.h" #include "../Statement/AssignmentStmt.h" #include "../Statement/ComputedGotoStmt.h" #include "../Statement/EntryStmt.h" #include "../Symbol/VariableSymbol.h" #include "../Symbol/FunctionSymbol.h" #include "../Traverser.h" #include "../Collection/Iterator.h" #include "../Collection/Mutator.h" #include "../Collection/RefMap.h" #include "../Collection/RefDatabase.h" #include "../Collection/RefSet.h" #include "../Collection/Map.h" #include "../utilities/switches_util.h" #include "../utilities/invariant_util.h" static Boolean is_array_ref (const Expression & expr) { switch (expr.op()) { case ARRAY_REF_OP: return True; default: return False; } } void remove_elseif_stmts( ProgramUnit &pgm ) { for (Iterator<Statement> iter = pgm.stmts().stmts_of_type( ELSEIF_STMT ); iter.valid(); ++iter) { pgm.stmts().split_elseif( iter.current() ); } } /// /// Change the following code: /// ASSIGN 100 TO X /// ASSIGN 200 TO X /// GOTO X /// /// Into the following code: /// ASSIGN 100 TO X /// XAGT = 1 /// ASSIGN 200 TO X /// XAGT = 2 /// GOTO (100,200) XAGT /// /// typedef RefList<Statement> Targets; template class TypedBaseMap<Symbol,Targets>; template class ProtoMap<Symbol,Targets>; template class Map<Symbol,Targets>; template class KeyIterator<Symbol,Targets>; void remove_assigned_goto_stmts( ProgramUnit &pgm ) { RefMap<Symbol,Symbol> assign_map; Map<Symbol,Targets> target_map; Iterator<Statement> iter = pgm.stmts().stmts_of_type( ASSIGN_STMT ); for ( ; iter.valid(); ++iter) { Statement & s = iter.current(); Symbol & sym = s.lhs().symbol(); if (s.atype() == EXECUTABLE_ASSIGN) { if (assign_map.find_ref( sym ) == 0) { String new_name = sym.name_ref(); new_name += "AGOTO"; Symbol *new_sym = new VariableSymbol(new_name, make_type(INTEGER_TYPE), NOT_FORMAL, NOT_SAVED ); pgm.symtab().rename_and_ins( new_sym ); assign_map.ins( sym, *new_sym ); target_map.ins( sym, new Targets ); } Targets & T = target_map[sym]; T.ins_last( *s.target_ref() ); Expression *lhs = id( assign_map[sym] ); Expression *rhs = constant( T.entries() ); Statement *st = new AssignmentStmt(pgm.stmts().new_tag(), lhs, rhs ); pgm.stmts().ins_after( st, &s ); } } iter = pgm.stmts().stmts_of_type( ASSIGNED_GOTO_STMT ); for ( ; iter.valid(); ++iter) { Statement & s = iter.current(); Symbol & sym = s.expr().symbol(); Expression *rhs = id( assign_map[sym] ); Statement *st = new ComputedGotoStmt(pgm.stmts().new_tag(), rhs, target_map[sym] ); pgm.stmts().ins_after( st, &s ); pgm.stmts().del( s ); } } void precalc_stmt( ProgramUnit &pgm, Statement &s, enum PRECALC_COND cond ) { for (Mutator<Expression> muter = s.iterate_expressions(); muter.valid(); ++muter) { Assign<Expression> muter_as(muter.assign()); muter_as = get_precalc( muter.pull(), pgm, s, cond ); } } /// Procedure passed to sub-list iterator to check Assertion /// against a single Assertion type. int check_assertion_type(void *as, void *assert_type) { return (((Assertion *) as)->type() == *((AssertionType *) assert_type)); } Iterator<Assertion> assertions_of_type(Statement &s, AssertionType type) { AssertionType *holdtype = new AssertionType; *holdtype = type; Iterator<Assertion> iter(s.assertions(), (cond_proc) check_assertion_type, holdtype); return iter; } Boolean is_func (const Expression &expr) { if (expr.op() == FUNCTION_CALL_OP) { return True; } else { return False; } } Boolean contains_side_effect_call (Statement &s) { List<Symbol> *funcs = new List<Symbol>; /// ... Look through all the expressions in the statement and /// ... make a list of all the FunctionSymbols representing /// ... routines being called. for (Mutator<Expression> mu_expr = s.iterate_expressions(); mu_expr.valid(); ++mu_expr) { Traverser tr (mu_expr.current(), is_func); for ( ; tr.valid(); ++tr) { funcs->ins_last(tr.current().function().symbol().clone()); } } if (funcs->entries() == 0) return False; /// ... There are no func calls at all /// ... For each function called, check it against the list of /// ... side-effect-free symbols from the assertions List<Symbol> *clean_funcs = new List<Symbol>; Iterator<Assertion> as_iter = assertions_of_type(s, AS_SIDE_EFFECT_FREE); for ( ; as_iter.valid(); ++as_iter) { for (Iterator<Expression> expr_iter = as_iter.current().arg_list_guarded(); expr_iter.valid(); ++expr_iter) { clean_funcs->ins_last(expr_iter.current().symbol().clone()); } } for (Iterator<Symbol> symiter = funcs; symiter.valid(); ++symiter) { Boolean found = False; for (Iterator<Symbol> clean_iter = clean_funcs; clean_iter.valid(); ++clean_iter) { if (strcmp(clean_iter.current().name_ref(), symiter.current().name_ref()) == 0) found = True; /// ... Found - this function won't cause a side-effect } if (!found) return True; } return False; } /// range_stmt /// /// The statement which should be used to best reflect the /// range environment of this statement, /// which is the ENDDO statement of the current loop, /// or the statement itself. Statement * range_stmt (Statement & stmt) { if (stmt.stmt_class() == DO_STMT) { return stmt.follow_ref(); } else { Statement * outer_loop = stmt.outer_ref(); if (outer_loop) { return outer_loop->follow_ref(); } else { return &stmt; } } }

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