Polaris: range_dict_util.cc Source File

range_dict_util.cc Go to the documentation of this file. /// /// /// \file range_dict_util.cc /// #include <map> #include "ProgramUnit.h" #include "../Collection/Iterator.h" #include "../Symbol/FunctionSymbol.h" #include "../Statement/Statement.h" #include "../Directive/AssertMayMod.h" #include "../Symtab.h" #include "range_dict_util.h" /// sort_sym_list /// Sort the given list of symbols. void sort_sym_list(RefList<Symbol> &sym_list) { RefList<Symbol> sym_queue = sym_list; sym_list.clear(); while (sym_queue.entries()) { Symbol &sym = sym_queue.grab(0); const char *sym_name = sym.name_ref(); Symbol *prev = 0; Iterator<Symbol> sorted_iter = sym_list; for ( ; sorted_iter.valid(); ++sorted_iter) { int name_cmp = strcmp(sym_name, sorted_iter.current().name_ref()); if (name_cmp < 0) break; else prev = &sorted_iter.current(); } sym_list.ins_after(sym, *prev); } } /// remove_min_max_var_conflicts /// Rename any variables named MIN or MAX in the given program so that /// they will not conflict with the symbols for the intrinsics MIN and MAX. static void _fix_intr_var_conflicts(Symtab &symtab, Symbol &var) { if (var.sym_class() != FUNCTION_CLASS || ! var.intrinsic()) { Symbol *var_ptr = symtab.grab(var.name_ref()); Symbol *intr = new FunctionSymbol(var.name_ref(), make_type(INTEGER_TYPE), NOT_EXTERNAL, IS_INTRINSIC, NOT_FORMAL); symtab.ins(intr); symtab.rename_and_ins(var_ptr); } } void remove_min_max_var_conflicts(Symtab &symtab) { Symbol *min_sym = symtab.find_ref("MIN"); if (min_sym) _fix_intr_var_conflicts(symtab, *min_sym); Symbol *max_sym = symtab.find_ref("MAX"); if (max_sym) _fix_intr_var_conflicts(symtab, *max_sym); } /// stmt_maymods /// If the given statement has a MAYMODS assertion, return the set of /// possibly modified variables. Otherwise, return NULL. RefSet<Symbol> * stmt_maymods(const Statement &stmt) { RefSet<Symbol> *maymods = 0; Iterator<Assertion> asrt_iter = stmt.assertions(); for ( ; asrt_iter.valid(); ++asrt_iter) { Assertion &asrt = asrt_iter.current(); if (asrt.type() == AS_MAYMOD) { if (! maymods) maymods = new RefSet<Symbol>; if (asrt.arg_list_valid()) { Iterator<Expression> aexpr_iter = asrt.arg_list_guarded(); for ( ; aexpr_iter.valid(); ++aexpr_iter) { Symbol *var_ref = aexpr_iter.current().base_variable_ref(); if (var_ref) maymods->ins(*var_ref); } } } } return maymods; } static void get_array_refs(Expression& expr, RefList<Expression>& array_refs){ if (expr.op()==ARRAY_REF_OP){ array_refs.ins_last(expr); } for(Iterator<Expression> expit=expr.arg_list(); expit.valid(); ++expit){ get_array_refs(expit.current(), array_refs); } } /// Return the last statement that is within the same block as 'ref'. static Statement* skip_blocks(Statement* ref){ Statement* toret=ref; Statement* next=toret; while(next){ switch(next->stmt_class()){ case ENDDO_STMT: case ENDIF_STMT: case FLOW_EXIT_STMT: /// ... Got to the end of the block. return toret; case DO_STMT: case WHILE_STMT: /// ... Skip this block. toret=next->follow_ref(); break; case IF_STMT: /// ... Skip this block. toret=next->matching_endif_ref(); break; default: toret=next->next_ref(); } next=toret; } return toret; } /// Silvius: force insertion of ranges according to the Fortran 77 /// standard for the following case: /// DIMENSION A(m,n:p,*) /// DO i=1,k /// DO j=h,100 /// A(i,j,...)=... /// In this case, since the access on A must be within bounds we /// will add to the dictionary the following ranges: /// k=[1,m] and h=[n:p]. /// Silvius: since I do not want to get to the guts of the AIRangeDict, /// we will force the insertionof the ranges by inserting some guards in /// the code, such as: /// IF (1.LE.k.AND.k.LE.m) THEN /// DO i=1,k /// Silvius: for now we do not catch all possible ranges, just look at some /// particular cases. void enforce_standard_within_bounds(ProgramUnit& pgm, RefList<Statement>& new_ifs){ /// silvius: not sure this is right return; /// First find DO loops and select "inits" and "limits" Iterator<Statement> loopit=pgm.stmts().stmts_of_type(DO_STMT); for( ; loopit.valid(); ++loopit){ /// ... Go through all the statements in the loop. /// cerr<<"\nAt loop "<<loopit.current(); /// ... Check whether the init or limit are ID_OP. RefList<Expression> base; if (loopit.current().init().op()==ID_OP){ base.ins_last(loopit.current().init()); } if (loopit.current().limit().op()==ID_OP){ base.ins_last(loopit.current().limit()); } if (base.entries()==0){ /// cerr<<"\nNo suitable init/limit found."; continue; } map<Symbol*, pair<Expression*, Expression*> > solutions; for(Statement* stit=loopit.current().next_ref(); stit!=loopit.current().follow_ref(); stit=stit->next_ref()){ /// cerr<<"\nAt statement: "<<*stit; /// ... Go through all the array references in the statement. for(Iterator<Expression> expit=stit->iterate_expressions(); expit.valid(); ++expit){ RefList<Expression> array_refs; get_array_refs(expit.current(), array_refs); for(Iterator<Expression> arit=array_refs; arit.valid(); ++arit){ // Check whether this array reference matches our pattern. Expression& ar=arit.current(); /// cerr<<"\n\tFor array ref "<<ar; Symbol& sym=ar.array().symbol(); // Check all dimensions except for last. ArrayDims& dims=sym.dim(); List<Expression>& subs=ar.subscript().arg_list(); for (int i=0; i<dims.entries()-1; ++i){ Expression& expr=subs[i]; if (expr.op()!=ID_OP){ continue; } if (expr!=loopit.current().index()){ continue; } /// ... If it gets here, it is the loop index. ArrayBounds& ab=dims[i]; Expression* lower=0; Expression* upper=0; if (ab.lower_exists()){ lower=ab.lower_guarded().clone(); } else { lower=constant(1); } if (ab.upper_exists()){ upper=ab.upper_guarded().clone(); } else { upper=constant(1); p_abort("Upper bound not declared in array inner dimension."); } /// ... Report it for now. for(Iterator<Expression> bit=base; bit.valid(); ++bit){ /// ... Insert if not already found. map<Symbol*, pair<Expression*, Expression*> >::iterator found= solutions.find(&bit.current().symbol()); if (found==solutions.end()){ /// cerr<<"\n\t\tInsert relation: " /// <<*lower<<"<="<<bit.current()<<"<="<<*upper; solutions.insert(make_pair(&bit.current().symbol(), make_pair(lower->clone(), upper->clone()))); } } delete lower; delete upper; } } } } /// ... At this point we have all the solutions for this loop. /// ... Let us insert the solutions as pgm guards. for(map<Symbol*, pair<Expression*, Expression*> >::iterator sit=solutions.begin(); sit!=solutions.end(); ++sit){ Expression* guard=simplify(and(le((*sit).second.first, id(*(*sit).first)), le(id(*(*sit).first), (*sit).second.second))); Statement* if_after=pgm.stmts().first_ref()->next_ref(); Statement* endif_after=pgm.stmts().last_ref()->prev_ref(); VariableSymbol& vsym=(VariableSymbol&)*(*sit).first; if (vsym.is_gsa_symbol()){ continue; } pgm.stmts().ins_IF_after(guard, if_after, endif_after); new_ifs.ins_last(*pgm.stmts().first_ref()->next_ref()->next_ref()); } } } /// Clean up after enforce_standard_within_bounds. void clean_after_standard_enforcement(ProgramUnit& pgm, RefList<Statement>& new_ifs){ for(Iterator<Statement> stit=new_ifs; stit.valid(); ++stit){ Statement& ifstmt=stit.current(); Statement& endif=*ifstmt.matching_endif_ref(); Statement& after_if=*ifstmt.next_ref(); Statement& before_implicit_goto= *ifstmt.matching_endif_ref()->prev_ref()->prev_ref(); pgm.stmts().move_block_before(after_if, before_implicit_goto, &ifstmt); pgm.stmts().del(ifstmt, endif); } }

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