Polaris: program_util.cc Source File

program_util.cc Go to the documentation of this file. /// /// #include <stdio.h> #include <strstream.h> #include "../CommonBlock.h" #include "../Equivalence.h" #include "../Program.h" #include "../ProgramTag.h" #include "../ProgramUnit.h" #include "../Collection/RefSet.h" #include "../Collection/RefList.h" #include "../Expression/Expression.h" #include "../Statement/EntryStmt.h" #include "../Symbol/BlockDataSymbol.h" #include "../Symbol/Symbol.h" #include "../Symbol/VariableSymbol.h" #include "symbol_util.h" #include "program_util.h" /// Mark variables found in DATA statement expressions /// (expr must always be a CommaExpr) void mark_data_variables(Expression & expr, RefSet<Symbol> & var_set, RefSet<Symbol> & overflow_set, RefSet<Symbol> & match_set, Boolean & found_vars) { for (Iterator<Expression> expr_iter = expr.arg_list(); expr_iter.valid(); ++expr_iter) { /// ... See documentation in Data.h for information /// ... about valid expression types Expression & current_expr = expr_iter.current(); switch (current_expr.op()) { case ID_OP: { Symbol & current_symbol = current_expr.symbol(); var_set.ins(current_symbol); if (match_set.member(current_symbol)) found_vars = True; break; } case ARRAY_REF_OP: { Symbol & current_symbol = *current_expr.base_variable_ref(); var_set.ins(current_symbol); if (match_set.member(current_symbol)) found_vars = True; break; } case DO_OP: overflow_set.ins(current_expr.iterator().index_id().symbol()); mark_data_variables(current_expr.iolist(), var_set, overflow_set, match_set, found_vars); default: break; } } } /// Move saved variables from a ProgramUnit into a common block void move_saved_vars(ProgramUnit & pgm, Program & p) { /// ... Static counter of generated common blocks (and possibly block /// ... data program units) static int saved_tag = 0; /// ... Build a set of saved variables for later processing RefSet<Symbol> saved_vars; RefSet<Symbol> saved_init_vars; RefList<Equivalence> equivs_encountered; for (DictionaryIter<Symbol> symbol_iter = pgm.symtab().iterator(); symbol_iter.valid(); ++symbol_iter) { Symbol & sym = symbol_iter.current(); if ((sym.sym_class() == VARIABLE_CLASS) && (sym.saved())) { Equivalence *equiv_class = sym.equivalence_ref(); if (equiv_class) { if (!equivs_encountered.member(*equiv_class)) { /// ... Make a new LOGICAL array of the proper size ArrayDims *dims = new ArrayDims; int size = equiv_class->size(); ArrayBounds *bound = new ArrayBounds(constant(1), constant(size % 4 == 0 ? size/4 : (size/4)+1)); dims->ins_last(bound); VariableSymbol *new_sym = new VariableSymbol("EQUIV", LOGICAL_TYPE, NOT_FORMAL, IS_SAVED, NOT_GLOBAL, dims); /// ... Rename to uniqueness within the symbol table pgm.symtab().rename_and_ins(new_sym); /// ... Insert the new variable into the /// ... equivalence class at byte offset 0 /// ... (automatically updates the symbol's /// ... _equivalence pointer). equiv_class->ins(*new_sym,0); /// ... Put the new variable on the saved_vars list saved_vars.ins(*new_sym); if (sym.initial_value()) saved_init_vars.ins(sym); /// ... Finally, note that we did this by putting the equiv /// ... class on the list of equivalences encountered equivs_encountered.ins_last(*equiv_class); } else { if (sym.initial_value()) saved_init_vars.ins(sym); } } else { saved_vars.ins(sym); if (sym.initial_value()) saved_init_vars.ins(sym); } } } if (saved_vars.any_valid()) { /// ... Create a new, saved common block ostrstream * str_ref = new ostrstream; (*str_ref) << ++saved_tag << '\000'; char * tag_data = str_ref->str(); String string_tag(tag_data); delete [] tag_data; delete str_ref; CommonBlock * saved_cb; { String common_tag = "/CB" + string_tag + "/"; saved_cb = new CommonBlock(common_tag); } saved_cb->saved(1); /// ... Insert new common block into program pgm.common_blocks().ins(saved_cb); /// ... Check to see if there are any initially defined saved /// ... local variables ProgramUnit * saved_pu = 0; if (saved_init_vars.any_valid()) { /// ... Create block data ProgramUnit ProgramTag block_tag; saved_pu = new ProgramUnit(block_tag, BLOCK_DATA_PU_TYPE); BlockDataSymbol * entry_symbol_ptr; { String entry_tag = "BD" + string_tag; entry_symbol_ptr = new BlockDataSymbol(entry_tag); } Symbol & entry_symbol = saved_pu->symtab().ins(entry_symbol_ptr); EntryStmt * entry_stmt = new EntryStmt(saved_pu->stmts().new_tag(), id(entry_symbol), comma()); saved_pu->stmts().ins_after(entry_stmt, saved_pu->stmts().first_ref()); /// ... Check through DATA statements Type int_type = make_type(INTEGER_TYPE); RefSet<Symbol> match_set(saved_init_vars); for (Mutator<Data> data_mutr = pgm.data(); data_mutr.valid(); ++data_mutr) { RefSet<Symbol> local_set; RefSet<Symbol> local_overflow_set; Boolean found_vars = False; mark_data_variables(data_mutr.current().variable_list(), local_set, local_overflow_set, match_set, found_vars); if (found_vars) { /// ... A variable which was initially defined was found /// ... on this DATA statement /// ... remove variables from match_set (if present) for (Mutator<Symbol> set_mutr = local_set; set_mutr.valid(); ++set_mutr) { Symbol & current_symbol = set_mutr.current(); set_mutr.del(); /* If an unsaved variable was initialized on the DATA statement, add it to saved_vars and saved_init_vars so we can copy the whole DATA statement over to BLOCK DATA */ if (!current_symbol.saved()) { saved_vars.ins(current_symbol); saved_init_vars.ins(current_symbol); } match_set.del(current_symbol); } /// ... For now, define integer variables with the same names /// ... as those variable symbols found in overflow set (which /// ... correspond to implied DO indexes under the DATA /// ... statement) into the block data ProgramUnit (eventually, /// ... these variables should go away) for (Mutator<Symbol> overflow_mutr = local_overflow_set; overflow_mutr.valid(); ++overflow_mutr) { Symbol & current_symbol = overflow_mutr.current(); overflow_mutr.del(); const char * current_name = current_symbol.name_ref(); if (!saved_pu->symtab().find_ref(current_name)) { VariableSymbol *var_sym = new VariableSymbol(current_name, int_type, NOT_FORMAL, NOT_SAVED); saved_pu->symtab().ins(var_sym); } } /// ... Grab data statement and put into block data ProgramUnit saved_pu->data().ins_last(data_mutr.grab()); /// ... End containing loop if no more variables to search for if (!match_set.any_valid()) break; } } } /// ... Loop through, processing saved variables for (Iterator<Symbol> saved_iter = saved_vars; saved_iter.valid(); ++saved_iter) { VariableSymbol & current_symbol = (VariableSymbol &)saved_iter.current(); /// ... Clear saved and initial value indicators current_symbol.saved(NOT_SAVED); current_symbol.initial_value(NOT_INITIALIZED); /* Put eight-byte divisible variables first, then four-byte divisible, then two-byte divisible, then all others: within groups, sort in alphabetical order */ int current_size = current_symbol.type().size(); int maxdiv; if ((current_size % 8) == 0) maxdiv = 8; else if ((current_size % 4) == 0) maxdiv = 4; else if ((current_size % 2) == 0) maxdiv = 2; else maxdiv = 1; int cb_index = 0; if (maxdiv != 1) { for (Iterator<Symbol> pos_iter = saved_cb->iterator(); pos_iter.valid(); ++pos_iter) { VariableSymbol & pos_symbol = (VariableSymbol &) pos_iter.current(); int pos_size = pos_symbol.type().size(); if ((((maxdiv == 2) && ((pos_size % 2) == 0)) || ((maxdiv == 4) && ((pos_size % 4) == 0)) || ((pos_size % 8) == 0)) && (strcmp(current_symbol.name_ref(), pos_symbol.name_ref()) > 0)) ++cb_index; else break; } } else cb_index = saved_cb->entries(); /// ... Insert variable into common block at this offset current_symbol.common(*saved_cb, cb_index); /* If there is a block data ProgramUnit, clone the variable (using member function clone_all to copy all pointers) and insert it into the block data ProgramUnit */ if (saved_pu) { saved_pu->symtab().ins(current_symbol.clone_all()); /// ... If the symbol is an array, find all symbolic constants /// ... used to declare it and insert them into the new symbol /// ... table as well. if (current_symbol.is_array()) { RefSet<Symbol> symb_const; collect_symb_const(symb_const, current_symbol.dim()); for (Iterator<Symbol> siter = symb_const; siter.valid(); ++siter) { Symbol & constant = siter.current(); if (!saved_pu->symtab().find_ref(constant.name_ref())) saved_pu->symtab().ins(constant.clone_all()); } } } } if (saved_pu) { for (Iterator<Equivalence> eqiter = equivs_encountered; eqiter.valid(); ++eqiter) { Equivalence & eq = eqiter.current(); saved_pu->equivalences().ins((Equivalence *)(eq.definition_clone())); for (Iterator<EquivalenceMember> eqmiter = eq.iterator(); eqmiter.valid(); ++eqmiter) { Symbol & eqsym = eqmiter.current().symbol(); if (!saved_pu->symtab().find_ref(eqsym.name_ref())) saved_pu->symtab().ins(eqsym.clone_all()); } } /// ... Clone the common block and insert it into the block data /// ... ProgramUnit CommonBlock * saved_cb_clone = new CommonBlock(*saved_cb); saved_pu->common_blocks().ins(saved_cb_clone); /// ... Relink its symbol pointers saved_cb_clone->relink_dptrs(*saved_pu); /// ... Relink all variable pointers saved_pu->symtab().relink_ptrs(*saved_pu); /// ... Relink all data statement pointers saved_pu->data().relink_ptrs(*saved_pu); /// ... Relink all equivalence pointers saved_pu->equivalences().relink_ptrs(*saved_pu); /// ... Absorb block data ProgramUnit into containing program p.absorb(saved_pu); } } } /// Rename variable new_symbol_ptr (to be inserted into new_pgm) and /// corresponding symbol current_symbol (which is in current_pgm) so that /// the two symbols have the same name in each ProgramUnit. /// This routine is used as part of partial ProgramUnit cloning in the /// presence of name conflicts (e.g., when inlining common blocks). Symbol & rename_variable_to_match(ProgramUnit & current_pgm, Symbol & current_symbol, ProgramUnit & new_pgm, Symbol * new_symbol_ptr) { /// Potentially rename into new program new_pgm.symtab().rename_and_ins(new_symbol_ptr); /// Look up symbol with new name in current program Symbol *check_ptr = current_pgm.symtab().find_ref(new_symbol_ptr->name_ref()); /// Handle when symbols do not match if (check_ptr != &current_symbol) { /// ... Grab current symbol from symbol table current_pgm.symtab().grab(current_symbol.name_ref()); /// ... Grab second colliding symbol if need be if (check_ptr) check_ptr = current_pgm.symtab().grab(check_ptr->name_ref()); /// ... Rename current symbol and reinsert it current_symbol.name(new_symbol_ptr->name_ref()); current_pgm.symtab().ins(&current_symbol); /// ... Handle second colliding symbol if (check_ptr) { /// ... Rename and insert colliding symbol into current program. /// ... /// ... There is need for further renaming only if there is a third /// ... collision (with the new program) after renaming and this /// ... third collision involves a variable from an equivalence /// ... block not yet present in the new program... if so, the /// ... variable is yet to be processed (or the collision would not /// ... have occurred) and so it can be handled later. current_pgm.symtab().rename_and_ins(check_ptr); } } /// Return reference to new program symbol return *new_symbol_ptr; } /// Rename equivalence new_equiv_ptr (to be inserted into new_pgm) and /// corresponding equivalence current_equiv (which is in current_pgm) so that /// the two equivalences have the same name in each ProgramUnit. /// This routine is used as part of partial ProgramUnit cloning in the /// presence of name conflicts (e.g., when inlining equivalence blocks). Equivalence & rename_equivalence_to_match(ProgramUnit & current_pgm, Equivalence & current_equiv, ProgramUnit & new_pgm, Equivalence * new_equiv_ptr) { /// Potentially rename into new program new_pgm.equivalences().rename_and_ins(new_equiv_ptr); /// Look up equivalence with new name in contained program Equivalence *check_ptr = current_pgm.equivalences().find_ref(new_equiv_ptr->name_ref()); /// Handle when symbols do not match if (check_ptr != &current_equiv) { /// ... Grab current equivalence from equivalence dictionary current_pgm.equivalences().grab(current_equiv.name_ref()); /// ... Grab second colliding equivalence if need be if (check_ptr) check_ptr = current_pgm.equivalences().grab(check_ptr->name_ref()); /// ... Rename current equivalence and reinsert it current_equiv.rename(new_equiv_ptr->name_ref()); current_pgm.equivalences().ins(&current_equiv); /// ... Handle second colliding equivalence if (check_ptr) { /// ... Rename and insert colliding symbol into current program. /// ... /// ... There is need for further renaming only if there is a third /// ... collision (with the new program) after renaming and this /// ... third collision involves an equivalence block not yet /// ... present in the new program... if so, the equivalence block /// ... is yet to be processed (or the collision would not /// ... have occurred) and so it will be handled later. current_pgm.equivalences().rename_and_ins(check_ptr); } } /// Return reference to new program equivalence return *new_equiv_ptr; } RefSet<Symbol> * interface_vars( ProgramUnit & pgm ) { /// ... Make a RefSet to hold the interface variables for this program unit. RefSet<Symbol> * iface_vars = new RefSet<Symbol>; for (Iterator<Statement> entry_iter = pgm.stmts().iterate_entry_points(); entry_iter.valid(); ++entry_iter) { EntryStmt & entry_stmt = (EntryStmt &) entry_iter.current(); if (entry_stmt.parameters_valid()) { for (Iterator<Expression> param_iter = entry_stmt.parameters_guarded().arg_list(); param_iter.valid(); ++param_iter) { Symbol * formal = param_iter.current().base_variable_ref(); iface_vars->ins( *formal ); } } } for (DictionaryIter<Symbol> sym_iter = pgm.symtab().iterator(); sym_iter.valid(); ++sym_iter) { Symbol & sym = sym_iter.current(); if (sym.common_ref()) { iface_vars->ins( sym ); } } return iface_vars; } /// Renames all occurences of var in pgm to a new symbol with the /// same base name. Used when some variable has the same name as /// an intrinsic function call (ex. DEALSE in OCEAN uses LOC as a /// variable name) void rename_all_occurences(ProgramUnit &pgm, Symbol &var) { Symbol *new_var = var.clone(); new_var = & pgm.symtab().rename_and_ins(new_var); for(Iterator<Statement> siter = pgm.stmts(); siter.valid(); ++siter) for(Mutator<Expression> eiter = siter.current().iterate_expressions(); eiter.valid(); ++eiter) substitute_var(eiter.current(), var, *new_var); pgm.symtab().del(var.name_ref()); }

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