Polaris: InlineObject.cc Source File

InlineObject.cc Go to the documentation of this file. /// /// /// Original code written by John Robert Grout, UIUC /// /// Recursive inlining features added by Keith Jackson, Texas A&M University /// (kjackson@tamu.edu) /// #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif /// #include "InlineObject.h" #include <stdio.h> #include <strstream.h> #include "AbstractAccess.h" #include "Collection/KeySet.h" #include "CommonBlock.h" #include "Directive/AssertComment.h" #include "Directive/AssertPrivate.h" #include "Directive/AssertRelation.h" /// added AssertRecursiveInline.h (kjackson) #include "Directive/AssertRecursiveInline.h" #include "Directive/Assertion.h" #include "Equivalence.h" #include "Expression/expr_funcs.h" #include "Expression/ArgNumberExpr.h" #include "Expression/IntConstExpr.h" #include "Expression/LambdaCallExpr.h" #include "Expression/LogicalConstExpr.h" #include "FormatDB.h" #include "Info.h" #include "IntElem.h" #include "LabelDB.h" #include "ProgramUnit.h" #include "Statement/AssignmentStmt.h" #include "Statement/GotoStmt.h" #include "Statement/LabelStmt.h" #include "StmtList.h" #include "Symbol/FunctionSymbol.h" #include "Symbol/VariableSymbol.h" #include "TranslateObject.h" #include "Wildcard/AnyOfType.h" #include "Wildcard/WildcardOr.h" #include "utilities/StmtInfo.h" #include "utilities/access_util.h" #include "utilities/entry_util.h" #include "utilities/intrinsic_util.h" #include "utilities/lambda_util.h" #include "utilities/precalc_util.h" #include "utilities/program_util.h" #include "utilities/removegotos_util.h" #include "utilities/stmt_util.h" #include "utilities/string_util.h" #include "utilities/switches_util.h" #include "utilities/symbol_util.h" #include "Constant/constant.h" #include "Deadcode/deadcode.h" template class TypedBaseMap<ProgramUnit,InlineObject>; template class ProtoMap<ProgramUnit,InlineObject>; template class Map<ProgramUnit,InlineObject>; template ostream & operator << (ostream &, const Map<ProgramUnit,InlineObject> &); template class KeyIterator<ProgramUnit,InlineObject>; template class Assign<InlineWorkSpace>; template class Element<InlineWorkSpace>; template ostream & operator << (ostream &, const Element<InlineWorkSpace> &); template class RefElement<InlineWorkSpace>; template ostream & operator << (ostream &, const RefElement<InlineWorkSpace> &); void InlineWorkSpace::print(ostream & o) const { if (_count_active) { o << "(<" << _exec_lines_input << ", " << _exec_lines_output << ">, <" << _total_lines_input << ", " << _total_lines_output << ">)"; } else o << "(<false>)"; } struct VariableSizes { int size; /// ... size of whole variable int elem_size; /// ... size of element inline VariableSizes(VariableSymbol & var); inline void remap(VariableSymbol & var); }; inline VariableSizes::VariableSizes(VariableSymbol & var) { size = var.size(); elem_size = var.type().size(); } inline void VariableSizes::remap(VariableSymbol & var) { size = var.size(); elem_size = var.type().size(); } enum CONFORM_TYPE { IDENTICAL, TRANSFORMABLE_CONSTANT, TRANSFORMABLE_ARRAY, TRANSFORMABLE_SUBSTRING, TRANSFORMABLE_SUBSTRING_ARRAY, NON_CONFORMABLE }; void InlineObject::print(ostream & o) const { TranslateObject::print(o); if (_ws_ref.valid()) { o << "\nInline workspace:\n\n"; o << *_ws_ref; } } /// Remap and move the formats from contained pgm to main program, renaming /// them as necessary void InlineObject::_remap_and_move_formats() { /// Clone formats from contained pgm and insert them into main pgm */ for (KeyIterator<int,Format> db_iter = _pgm_ref->formats(); db_iter.valid(); ++db_iter) { Format & current_format = db_iter.current_data(); int format_label = current_format.value(); /// ... Iterate to fixed point to find unconflicting number for format in /// ... contained and main program while (1) { int label_save = format_label; format_label = _pgm_main.stmts().new_label(label_save); if (format_label == label_save) break; label_save = format_label; format_label = _pgm_ref->stmts().new_label(label_save); if (format_label == label_save) break; } /// ... Relabel format if necessary if (format_label != current_format.value()) _pgm_ref->formats().relabel(current_format.value(),format_label); /// ... Clone and insert into main program Format * cloned_format = (Format *) current_format.listable_clone(); _pgm_main.formats().ins(cloned_format); /// ... Map from format to cloned format _format_map.ins(current_format, *cloned_format); } } /// Precalculate adjustable array bounds void InlineObject::_precalc_adjustable_array_bounds() { StmtInfo arg_map; arg_map.program_ref = _pgm_ref; /// ... Iterate over entries of program for (Iterator<Statement> entry_iter = _pgm_ref->stmts().iterate_entry_points(); entry_iter.valid(); ++entry_iter) { /// ... Set c to point to current statement Statement *c = &entry_iter.current(); /// ... Iterate over entry's parameters if necessary if ((c->stmt_class() == FLOW_ENTRY_STMT) || (!c->parameters_valid())) continue; /// ... Point to the statement after entry arg_map.stmt_ref = c->next_ref(); { // Iterate over formal parameters // Type int_type = make_type(INTEGER_TYPE); for (Iterator<Expression> parm_iter = c->parameters_guarded().arg_list(); parm_iter.valid(); ++parm_iter) { p_assert(parm_iter.current().op() == ID_OP, "Bad entry parmlist in precalc_adjustable_array_bounds"); Symbol & parm_symbol = parm_iter.current().symbol(); if (parm_symbol.sym_class() == VARIABLE_CLASS) { for (Iterator<ArrayBounds> bound_iter = parm_symbol.dim(); bound_iter.valid(); ++bound_iter) { ArrayBounds & current_bound = bound_iter.current(); if (current_bound.lower_exists()) { Expression & lb = current_bound.lower_guarded(); if (lb.op() != INTEGER_CONSTANT_OP) { Assign<Expression> lb_as ( current_bound.arg_list().assign(lb)); lb_as = get_precalc(current_bound.arg_list().pull(lb), *arg_map.program_ref, *arg_map.stmt_ref, PRECALC_ALWAYS, "PC"); } } if (current_bound.upper_exists()) { Expression & ub = current_bound.upper_guarded(); if (ub.op() != INTEGER_CONSTANT_OP) { Assign<Expression> ub_as ( current_bound.arg_list().assign(ub)); ub_as = get_precalc(current_bound.arg_list().pull(ub), *arg_map.program_ref, *arg_map.stmt_ref, PRECALC_ALWAYS, "PC"); } } } } } } } } /// Expand array names which occur in I/O statements into an implicit /// DO-loop nest over its bounds void InlineObject::_expand_IO_array_names() { /// Iterate over all candidate I/O statements for (Iterator<Statement> IO_iter = _pgm_ref->stmts().stmts_of_type(READ_STMT, WRITE_STMT, PRINT_STMT); IO_iter.valid(); ++IO_iter) { Statement & s = IO_iter.current(); /// ... Iterate over the list of arguments (if any) if (s.io_list_valid()) { for (Mutator<Expression> expr_mutr = s.io_list_guarded().arg_list(); expr_mutr.valid(); ++expr_mutr) { Expression & expr = expr_mutr.current(); IntConstExpr cstone(1); if (expr.op() != ID_OP) continue; Symbol & sym = expr.symbol(); if (sym.sym_class() != VARIABLE_CLASS) continue; if (sym.is_array()) { ArrayDims & dim = sym.dim(); // Expand the expression into an implicit DO-loop nest Type int_type = make_type(INTEGER_TYPE); Expression *array_expr = array_reference(expr.clone(), comma()); Expression *current_expr = array_expr; for (Iterator<ArrayBounds> bound_iter = dim; bound_iter.valid(); ++bound_iter) { ArrayBounds & current_bound = bound_iter.current(); Expression * bound_lb = current_bound.lower_ref(); if (!bound_lb) bound_lb = &cstone; Expression *bound_ub = current_bound.upper_ref(); if (!bound_ub) bound_ub = &cstone; Expression *var_comma_expr = comma(bound_lb->clone(), bound_ub->clone()); /// ... Create new local symbol Symbol *var_sym = new VariableSymbol("PV", int_type, NOT_FORMAL, NOT_SAVED); /// ... Insert into symbol table _pgm_ref->symtab().rename_and_ins(var_sym); /// ... Insert ID for symbol onto end of array /// ... reference array_expr->subscript().arg_list().ins_last(id(*var_sym)); /// ... Create iteration expression Expression *var_eq_expr = equal(id(*var_sym), var_comma_expr); /// ... Create do expression current_expr = do_expression(comma(current_expr), var_eq_expr); } // Insert implicit DO-loop nest in place expr_mutr.modify(current_expr); } } } } } /// Remap and move a specific variable symbol from contained pgm to /// main program such that no conflicts arise with respect to either /// program. void InlineObject::_remap_variable_symbol(Symbol & current_symbol, RefList<Symbol>&rename_list) { /// ... If the variable symbol collides with main program or is the /// ... name of an intrinsic function, process it later. const char *sym_name = current_symbol.name_ref(); if ((int) _pgm_main.symtab().find_ref(sym_name) || (int) lookup_intrinsic(sym_name)) { rename_list.ins_last(current_symbol); } else { /// ... If the current symbol can be left as is, move it into main program /// ... now and save its translation. Symbol *new_symbol_ptr = current_symbol.clone(); _pgm_main.symtab().ins(new_symbol_ptr); /// ... If subprogram variable is not saved, remember that it is /// ... private to this routine PRIVAT_TYPE priv_type = NOT_PRIVATE; if(current_symbol.saved()==NOT_SAVED) { priv_type = PRIVATE; _private_vars++; } /// ... If subprogram variable is an integer scalar whose name /// ... begins with "PC", remember it as a candidate for propagation. PRECALC_TYPE prec_type = NOT_PRECALC_VAR; const Type & current_type = current_symbol.type(); if ((current_type.data_type() == INTEGER_TYPE) && (current_type.is_scalar()) && (strncmp(current_symbol.name_ref(),"PC",2) == 0)) { prec_type = CAND_PRECALC_VAR; _precalc_vars++; } _symbol_map.ins(current_symbol, new SymRefElem(*new_symbol_ptr, priv_type, prec_type)); } } /// Remap a specific symbol with no value from contained pgm to main /// program, renaming any conflicting symbol in the main program. void InlineObject::_remap_unvalued_symbol(Symbol & current_symbol) { Symbol * new_symbol_ptr = NULL; /// Attempt to grab a potentially conflicting main program symbol Symbol *main_symbol_ptr = _pgm_main.symtab().grab(current_symbol.name_ref()); if (!main_symbol_ptr) { /// ... There is no conflicting main program symbol, so clone current_symbol /// ... and insert it into the main program symbol table new_symbol_ptr = current_symbol.clone(); _pgm_main.symtab().ins(new_symbol_ptr); } else { /// ... There is a potentially conflicting main program symbol switch (main_symbol_ptr->sym_class()) { case VARIABLE_CLASS: case SYMBOLIC_CONSTANT_CLASS: { /// ... The main program symbol is a valued symbol /// ... Clone current_symbol and insert it into the main program /// ... symbol table new_symbol_ptr = current_symbol.clone(); _pgm_main.symtab().ins(new_symbol_ptr); /// ... Reinsert conflicting symbol into the main program symbol table /// ... with rename _pgm_main.symtab().rename_and_ins(main_symbol_ptr); break; } case FUNCTION_CLASS: case SUBROUTINE_CLASS: case PROGRAM_CLASS: case BLOCK_DATA_CLASS: case NAMELIST_CLASS: { /// ... The main program symbol is also an unvalued symbol /// ... For the FORTRAN program to be correct, the definitions of /// ... these unvalued symbols must match... so we can translate /// ... references to current_symbol to point at the main program symbol new_symbol_ptr = main_symbol_ptr; /// ... Reinsert the grabbed main program symbol _pgm_main.symtab().ins(main_symbol_ptr); break; } default: break; } } /// ... Save the translation from contained pgm to main program _symbol_map.ins(current_symbol, new SymRefElem(*new_symbol_ptr)); } /// Remap and move a list of symbols with values from contained pgm to main /// program which need renaming such that no conflicts arise with respect /// to either program or against the names of intrinsic functions. void InlineObject::_remap_variable_symbols(RefList<Symbol>&rename_list) { for (Iterator<Symbol> rename_iter = rename_list; rename_iter.valid(); ++rename_iter) { /// ... Clone the symbol from our symbol table and insert /// ... with rename into main program. Symbol & current_symbol = rename_iter.current(); Symbol * new_symbol_ptr = current_symbol.clone(); _pgm_main.symtab().rename_and_ins(new_symbol_ptr); /// ... If subprogram variable is not saved, remember that it is /// ... private to this routine PRIVAT_TYPE priv_type = NOT_PRIVATE; if(current_symbol.saved()==NOT_SAVED) { priv_type = PRIVATE; _private_vars++; } /// ... If subprogram variable is an integer scalar whose name /// ... begins with "PC", remember it as a candidate for propagation. PRECALC_TYPE prec_type = NOT_PRECALC_VAR; const Type & current_type = current_symbol.type(); if ((current_type.data_type() == INTEGER_TYPE) && (current_type.is_scalar()) && (strncmp(current_symbol.name_ref(),"PC",2) == 0)) { prec_type = CAND_PRECALC_VAR; _precalc_vars++; } _symbol_map.ins(current_symbol, new SymRefElem(*new_symbol_ptr, priv_type, prec_type)); } } void InlineObject::_remap_local_variables() { RefList<Symbol> rename_list; RefList<Symbol> symbolic_list; for (DictionaryIter<Symbol> sym_iter = _pgm_ref->symtab().iterator(); sym_iter.valid(); ++sym_iter) { Symbol & current_symbol = sym_iter.current(); switch (current_symbol.sym_class()) { case VARIABLE_CLASS: { if ((!current_symbol.formal()) && (!current_symbol.equivalence_ref()) && (!current_symbol.common_ref())) _remap_variable_symbol(current_symbol, rename_list); break; } case FUNCTION_CLASS: case SUBROUTINE_CLASS: case PROGRAM_CLASS: case BLOCK_DATA_CLASS: case NAMELIST_CLASS: { _remap_unvalued_symbol(current_symbol); break; } case SYMBOLIC_CONSTANT_CLASS: { Symbol & main_symbol = rename_variable_to_match(*_pgm_ref, current_symbol, _pgm_main, current_symbol.clone()); _symbol_map.ins(current_symbol, new SymRefElem(main_symbol)); symbolic_list.ins_last(main_symbol); break; } default: break; } } /// ... If variable symbols to rename, do so if(rename_list.entries()) _remap_variable_symbols(rename_list); /// ... Relink expressions in main program symbolic constants to point /// ... at main program symbols for(Iterator<Symbol> symbolic_iter = symbolic_list; symbolic_iter.valid(); ++ symbolic_iter) { symbolic_iter.current().relink_dptrs(_pgm_main); } } /// Relabel the labels in the contained pgm to avoid conflict with the /// main pgm void InlineObject::_rename_branch_targets() { StmtList & stmts = _pgm_ref->stmts(); StmtList & main_stmts = _pgm_main.stmts(); /// Scan the label database in ascending label order int label_number = stmts.labels().first_ref(); while (label_number) { /// ... Iterate to fixed point to find unconflicting number for label /// ... in contained and main program int old_label_number = label_number; while (1) { int label_save = label_number; label_number = main_stmts.new_label(label_save); if (label_number == label_save) break; label_save = label_number; label_number = stmts.new_label(label_save); if (label_number == label_save) break; } /// ... Relabel label statement if necessary if (label_number != old_label_number) stmts.relabel(old_label_number,label_number); /// ... Find next label in label database (Note: we may see a label /// ... twice, but the second time, it won't conflict) label_number = stmts.labels().successor_ref(old_label_number); } } /// Test and see if a parameter and a main program expression are /// conformable enough to be easily replaced. /// /// IDENTICAL: /// means that they are identical. /// TRANSFORMABLE_CONSTANT: /// means that the calling argument is a non-symbolic constant. /// TRANSFORMABLE_ARRAY: /// means that the calling reference is an array reference which /// is different but conformable. /// TRANSFORMABLE_SUBSTRING: /// means that the calling reference is a substring reference (whose /// associated string has conformability IDENTICAL) /// TRANSFORMABLE_SUBSTRING_ARRAY: /// means that the calling reference is a substring reference (whose /// associated string has conformability TRANSFORMABLE_ARRAY) /// NON_CONFORMABLE: /// means that they are not conformable. /// static CONFORM_TYPE conformable_test(VariableSymbol * name_ptr, Expression & main_expr, bool equivalent_var_generated) { Symbol *main_name_ptr = 0; Expression *main_subs_ptr = 0; Expression *main_bound_ptr = 0; /// ... Perform initialization switch (main_expr.op()) { case INTEGER_CONSTANT_OP: case REAL_CONSTANT_OP: case LOGICAL_CONSTANT_OP: if (main_expr.type() == name_ptr->type()) return TRANSFORMABLE_CONSTANT; else return NON_CONFORMABLE; case ID_OP: { main_name_ptr = main_expr.base_variable_ref(); if (main_name_ptr->sym_class() == SYMBOLIC_CONSTANT_CLASS) { if (main_name_ptr->type() == name_ptr->type()) return IDENTICAL; else return NON_CONFORMABLE; } break; } case ARRAY_REF_OP: { main_name_ptr = main_expr.base_variable_ref(); main_subs_ptr = &main_expr.subscript(); break; } case SUBSTRING_OP: { main_bound_ptr = &main_expr.bound(); Expression & main_string_expr = main_expr.string(); main_name_ptr = main_string_expr.base_variable_ref(); if (main_string_expr.op()==ARRAY_REF_OP) main_subs_ptr = &main_string_expr.subscript(); break; } default: p_abort("Illegal expression detected in conformable_test"); } /// ... Equivalenced common variables are not transformable unless /// ... an equivalent variable (with matching name) has already been /// ... generated bool transformable = ((!name_ptr->common_ref()) || (!name_ptr->equivalence_ref()) || equivalent_var_generated); const Type & name_type = name_ptr->type(); const Type & main_name_type = main_name_ptr->type(); /// ... If name_ptr points to a character dummy, it is conformable with any /// ... main program character variable if ((name_type.data_type() == CHARACTER_TYPE) && (name_type.size() == 0)) { if (main_name_type.data_type() == CHARACTER_TYPE) { if (!main_bound_ptr) return IDENTICAL; else return TRANSFORMABLE_SUBSTRING; } else return NON_CONFORMABLE; } /// ... Otherwise, if the types are different, they are non-conformable if ((name_type.data_type() != main_name_type.data_type()) || (name_type.size() != main_name_type.size())) return NON_CONFORMABLE; /// ... TODO: An array reference with substring operator in calling program /// ... is only conformable to _one_ variable (or, perhaps, an array of single /// ... characters) in the called program /// ... Get the dimension information for each symbol ArrayDims & name_dim = name_ptr->dim(); int name_dims = name_dim.entries(); ArrayDims & main_name_dim = main_name_ptr->dim(); int main_name_dims = main_name_dim.entries(); /// ... If both variables are scalars, they are conformable if ((name_dims == 0) && (main_name_dims == 0)) { if (!main_bound_ptr) return IDENTICAL; else return TRANSFORMABLE_SUBSTRING; } /// ... Set default conformability CONFORM_TYPE conformable; if (!main_bound_ptr) conformable = IDENTICAL; else conformable = TRANSFORMABLE_SUBSTRING; /// ... Perform array-to-array checking if ((name_dims != 0) && (main_name_dims != 0)) { /// ... Perform m to m dimensional array-to-array checking if (name_dims == main_name_dims) { /// ... Iterate over all the dimensions IntConstExpr cstone(1); Iterator<ArrayBounds> name_iter = name_dim; Iterator<ArrayBounds> main_name_iter = main_name_dim; List<Expression> dummy_list; List<Expression> *main_subs_listptr = &dummy_list; if (main_subs_ptr) main_subs_listptr = &main_subs_ptr->arg_list(); Iterator<Expression> main_subs_iter(*main_subs_listptr); for (int i = 0; i<name_dims; ++i) { Expression *name_lb = name_iter.current().lower_ref(); if (!name_lb) name_lb = &cstone; Expression *name_ub = name_iter.current().upper_ref(); if (!name_ub) name_ub = &cstone; Expression *main_name_lb = main_name_iter.current().lower_ref(); if (!main_name_lb) main_name_lb = &cstone; Expression *main_name_ub = main_name_iter.current().upper_ref(); if (!main_name_ub) main_name_ub = &cstone; Expression *main_name_offptr; /// ... Handle case when main_name was subscripted if (main_subs_ptr) { main_name_offptr = simplify(sub(main_subs_iter.current().clone(), main_name_lb->clone())); /// ... If there's a difference in a dimension other than /// ... the last one, variables are non-conformable if ((i != name_dims - 1) && ((main_name_offptr->op() != INTEGER_CONSTANT_OP) || (main_name_offptr->value() != 0))) { delete main_name_offptr; return NON_CONFORMABLE; } delete main_name_offptr; main_name_offptr = main_subs_iter.current().clone(); } else { /// ... If main name not offset, default offset is lower bound main_name_offptr = main_name_lb->clone(); } Expression *offset = simplify(sub(sub(main_name_ub->clone(), main_name_offptr->clone()), sub(name_ub->clone(), name_lb->clone()))); if ((offset->op() != INTEGER_CONSTANT_OP) || (offset->value() != 0)) { delete main_name_offptr; delete offset; if (transformable && (i == main_name_dims - 1)) { if (!main_bound_ptr) return TRANSFORMABLE_ARRAY; else return TRANSFORMABLE_SUBSTRING_ARRAY; } else return NON_CONFORMABLE; } delete offset; /// ... Absorb main_name_offptr as subexpression of offset offset = simplify(sub(main_name_offptr, name_lb->clone())); if ((offset->op() != INTEGER_CONSTANT_OP) || (offset->value() != 0)) { if (!main_bound_ptr) conformable = TRANSFORMABLE_ARRAY; else conformable = TRANSFORMABLE_SUBSTRING_ARRAY; } delete offset; /// ... Increment dimension iterators ++name_iter; ++main_name_iter; if (main_subs_ptr) ++main_subs_iter; } if (transformable) return conformable; else return NON_CONFORMABLE; } else { /// ... Handle one to many case if (transformable && (main_name_dims == 1)) { if (!main_bound_ptr) return TRANSFORMABLE_ARRAY; else return TRANSFORMABLE_SUBSTRING_ARRAY; } } } else { /// ... Handle array to scalar case if (transformable && (name_dims == 0)) { if (!main_bound_ptr) return TRANSFORMABLE_ARRAY; else return TRANSFORMABLE_SUBSTRING_ARRAY; } } return NON_CONFORMABLE; } /// Given an array reference calling parameter pointed to by src_name_ptr /// with subscript pointed to by src_subs_ptr, return a CommaExpr which /// points to a pair of expressions: a subscript to an equivalent /// one-dimensional array pointed to by tgt_name_ptr (which can be in /// either program) and a test expression (possibly symbolic) which will /// be zero iff the equivalent variable is aligned correctly for this /// reference. Expression * InlineObject::_linearize_array_ref(VariableSymbol * src_name_ptr, Expression * src_subs_ptr, VariableSymbol * tgt_name_ptr) { /// ... Get the dimension information for each symbol ArrayDims & src_dim = src_name_ptr->dim(); int src_dims = src_dim.entries(); ArrayDims & tgt_dim = tgt_name_ptr->dim(); /// ... int tgt_dims = tgt_dim.entries(); List<Expression> & src_subs_list = src_subs_ptr->arg_list(); /// ... Calculate initial offset Expression *src_exl; Expression *src_exu; Expression *tgt_exl; Expression *offset; if (src_dims>1) { src_exl = src_dim[src_dims - 1].lower_ref(); if (src_exl) src_exl = src_exl->clone(); else src_exl = constant(1); /// ... Absorb src_exl as subexpression of offset offset = sub(src_subs_list[src_dims - 1].clone(), src_exl); for (int i = src_dims - 2; i>0; --i) { src_exl = src_dim[i].lower_ref(); if (src_exl) src_exl = src_exl->clone(); else src_exl = constant(1); src_exu = src_dim[i].upper_ref(); if (src_exu) src_exu = src_exu->clone(); else src_exu = constant(1); /// ... Absorb src_exl and src_exu as subexpressions of offset offset = add(mul(add(sub(src_exu, src_exl), constant(1)), offset), sub(src_subs_list[i].clone(), src_exl->clone())); } } else { offset = constant(0); } src_exl = src_dim[0].lower_ref(); if (src_exl) src_exl = src_exl->clone(); else src_exl = constant(1); src_exu = src_dim[0].upper_ref(); if (src_exu) src_exu = src_exu->clone(); else src_exu = constant(1); /// ... Absorb src_exl and src_exu as subexpressions of offset offset = add(mul(add(sub(src_exu, src_exl), constant(1)), offset), sub(src_subs_list[0].clone(), src_exl->clone())); /// ... Adjust for size differences between source and target int src_name_size = src_name_ptr->type().size(); int tgt_name_size = tgt_name_ptr->type().size(); Expression * test_expr; if (tgt_name_size > src_name_size) { p_assert(!(tgt_name_size % src_name_size), "Non-conformable sizes encountered in _linearize_array_ref"); /// ... Calculate divisor Expression * divisor = constant(tgt_name_size / src_name_size); /// ... Generate test expression Symbol *mod_sym = _pgm_main.symtab().find_ref("MOD"); if (! mod_sym) { mod_sym = new FunctionSymbol("MOD", make_type(INTEGER_TYPE), NOT_EXTERNAL, IS_INTRINSIC, NOT_FORMAL); _pgm_main.symtab().ins(mod_sym); } test_expr = intrinsic_call(id(*mod_sym), comma(offset->clone(), divisor->clone())); test_expr->type(offset->type()); test_expr = eq(test_expr,constant(0)); /// ... Divide offset to adjust for larger target size offset = div(offset, divisor); } else { if (src_name_size > tgt_name_size) { p_assert(!(src_name_size % tgt_name_size), "Non-conformable sizes encountered in _linearize_array_ref"); /// ... Multiply offset to adjust for smaller target size offset = mul(offset, constant(src_name_size / tgt_name_size)); } test_expr = new LogicalConstExpr(".TRUE."); } tgt_exl = tgt_dim[0].lower_ref(); if (tgt_exl) tgt_exl = tgt_exl->clone(); else tgt_exl = constant(1); /// ... Absorb tgt_exl as subexpression of offset offset = add(offset, tgt_exl); /// ... Return expressions return comma(offset,test_expr); } /// Given a variable pointed to by src_name_ptr with constant array /// bounds, convert the element offset src_offset and return an /// equivalent subscript. static Expression * unlinearize_array_ref(VariableSymbol * src_name_ptr, int src_offset) { int lb_size_array[7]; int src_size_array[7]; int i = 0; int src_size = 1; Iterator<ArrayBounds> array_iter(src_name_ptr->dim()); for ( ; array_iter.valid(); ++array_iter, ++i) { int ub_size; Expression *lb = array_iter.current().lower_ref(); if (lb) lb_size_array[i] = lb->value(); else lb_size_array[i] = 1; Expression *ub = array_iter.current().upper_ref(); if (ub) ub_size = ub->value(); else ub_size = 1; src_size = src_size * (ub_size - lb_size_array[i] + 1); src_size_array[i] = src_size; } /// ... Iterate backward over the dimensions to calculate offsets Expression *returned_ref = comma(); i = src_name_ptr->dim().entries() - 1; for ( ; i > 0; --array_iter, --i ) { int off_value = lb_size_array[i] + (src_offset / src_size_array[i]); returned_ref->arg_list().ins_first(constant(off_value)); src_offset = src_offset % src_size_array[i]; } returned_ref->arg_list().ins_first(constant(lb_size_array[0] + src_offset)); return returned_ref; } /// Given a calling expression main_expr in pgm_main which doesn't /// correspond to the dummy variable pointed to by name_ptr, generate an /// (or use) an equivalent conformable variable in pgm_main (and, if /// calling parameter was an array reference, generate an equivalent array /// reference expression). Return a CommaExpr which points to a pair /// of expressions: a conformable expression, and a test expression (possibly /// symbolic) which will be zero iff the equivalent variable is aligned /// correctly for this reference. Expression * InlineObject::_gen_equivalent_var(VariableSymbol * name_ptr, Expression & main_expr) { p_assert((main_expr.base_variable_ref() && (main_expr.base_variable_ref()->sym_class() == VARIABLE_CLASS)), "Non-conformable non-variable in _gen_equivalent_var"); VariableSymbol *main_name_ptr = (VariableSymbol *) main_expr.base_variable_ref(); Expression *main_subs_ptr = 0; if (main_expr.op() == ARRAY_REF_OP) main_subs_ptr = &main_expr.subscript(); /// Calculate element and array sizes of name and main_name VariableSizes variable_sizes(*name_ptr); VariableSizes main_variable_sizes(*main_name_ptr); int main_name_base; VariableSymbol *equiv_name_ptr = 0; /// Check if main_name is already in an equivalence class Equivalence *main_equiv_ptr = main_name_ptr->equivalence_ref(); if (main_equiv_ptr) { /// ... Check each member for suitability main_name_base = main_equiv_ptr->find_ref(*main_name_ptr)->byte_base(); for (Iterator<EquivalenceMember> equiv_iter = main_equiv_ptr->iterator();equiv_iter.valid(); ++equiv_iter) { equiv_name_ptr = (VariableSymbol *) & equiv_iter.current().symbol(); int equiv_name_base = equiv_iter.current().byte_base(); if ((equiv_name_base == main_name_base) && (equiv_name_ptr->type().data_type()== name_ptr->type().data_type())) { VariableSizes equiv_variable_sizes(*equiv_name_ptr); if ((main_variable_sizes.size == equiv_variable_sizes.size) && (variable_sizes.elem_size == equiv_variable_sizes.elem_size) && ((!name_ptr->is_array()) || (equiv_name_ptr->dim().entries() == 1))) { // Member variable is suitable // If not equivalenced common variable, return to caller // now if ((!name_ptr->common_ref()) || (!name_ptr->equivalence_ref())) { /// ... If array reference, adjust subscript and return to /// ... caller if (main_subs_ptr) { Expression *linearized_ref = simplify(_linearize_array_ref(main_name_ptr, main_subs_ptr, equiv_name_ptr )); Expression * test_expr = linearized_ref->arg_list().grab(1); return comma(array_reference(id(*equiv_name_ptr), linearized_ref), test_expr); } else return comma(id(*equiv_name_ptr), new LogicalConstExpr(".TRUE.")); } // If equivalenced common variable, use this variable as a // template for another variable else break; } else equiv_name_ptr = 0; } else equiv_name_ptr = 0; } } else { /// ... Generate a new equivalence class which follows the existing /// ... conventions char label_buff[10]; int equiv_count = _pgm_main.equivalences().entries(); sprintf(label_buff, "EQ%u", equiv_count+1); main_equiv_ptr = new Equivalence(label_buff); /// ... Insert it into main pgm, renaming if necessary _pgm_main.equivalences().rename_and_ins(main_equiv_ptr); /// ... Insert main_name into it with byte base 0 main_name_base = 0; main_equiv_ptr->ins(*main_name_ptr, main_name_base); /// ... If equivalenced common variable, main program variable /// ... might be suitable as a template, so check it if (name_ptr->common_ref() && name_ptr->equivalence_ref() && (main_name_ptr->type().data_type()== name_ptr->type().data_type()) && (variable_sizes.elem_size == main_variable_sizes.elem_size) && ((!name_ptr->is_array()) || (main_name_ptr->dim().entries() == 1))) equiv_name_ptr = main_name_ptr; } /// If one not found already, generate new equivalence variable if (!equiv_name_ptr) { /// ... Calculate the new variable's bounds Expression *upper_bound; ArrayBounds *new_bounds; if ((variable_sizes.size != 0) || (main_variable_sizes.size != 0)) { if (variable_sizes.size<main_variable_sizes.size) upper_bound = constant(main_variable_sizes.size / variable_sizes.elem_size); else upper_bound = constant(variable_sizes.size / variable_sizes.elem_size); new_bounds = new ArrayBounds(constant(1), upper_bound); } else new_bounds = new ArrayBounds(); equiv_name_ptr = new VariableSymbol(main_name_ptr->name_ref(), name_ptr->type(), main_name_ptr->formal(), main_name_ptr->saved(), new_bounds); /// ... Insert into main program and equivalence _pgm_main.symtab().rename_and_ins(equiv_name_ptr); main_equiv_ptr->ins(*equiv_name_ptr, main_name_base); } /// If not equivalenced common variable, return to caller /// now if ((!name_ptr->common_ref()) || (!name_ptr->equivalence_ref())) { /// ... If array reference, adjust subscript and return to /// ... caller if (main_subs_ptr) { Expression *linearized_ref = simplify(_linearize_array_ref(main_name_ptr, main_subs_ptr, equiv_name_ptr )); Expression * test_expr = linearized_ref->arg_list().grab(1); return comma(array_reference(id(*equiv_name_ptr), linearized_ref), test_expr); } else return comma(id(*equiv_name_ptr), new LogicalConstExpr(".TRUE.")); } /// If equivalenced common variable, clone name_ptr Symbol & main_equiv_name = rename_variable_to_match(*_pgm_ref, *name_ptr, _pgm_main, name_ptr->clone()); /// Change main_equiv_name's formal and saved values to those of main_name_ptr main_equiv_name.formal(main_name_ptr->formal()); main_equiv_name.saved(main_name_ptr->saved()); /// Insert into equivalence at correct byte base if(!main_subs_ptr) main_equiv_ptr->ins(main_equiv_name, main_name_base); else { /// ... Calculate correct byte base Expression *linearized_ref = simplify(_linearize_array_ref(main_name_ptr, main_subs_ptr, equiv_name_ptr)); int array_offset = linearized_ref->arg_list()[0].value(); delete linearized_ref; ArrayBounds & old_bound = equiv_name_ptr->dim()[0]; if (old_bound.lower_exists()) array_offset = array_offset - old_bound.lower_guarded().value(); else --array_offset; main_equiv_ptr->ins(main_equiv_name, main_name_base + array_offset * variable_sizes.elem_size); } /// Return equivalent variable to caller return comma(id(main_equiv_name), new LogicalConstExpr(".TRUE.")); } /// Determine if an alternate expression will be generated bool alternate_expr_valid(VariableSymbol * name_ptr, Expression & main_expr) { bool return_value = false; if (main_expr.op()==ID_OP) { Symbol & main_name = main_expr.symbol(); if (main_name.is_scalar()) { ArrayDims & name_dims = name_ptr->dim(); if ((name_dims.entries()==1)) { ArrayBounds & name_bnds = name_dims[0]; Expression * lower_bnd_ref = 0; if (name_bnds.lower_exists()) lower_bnd_ref = &name_bnds.lower_guarded(); if ((!lower_bnd_ref || ((lower_bnd_ref->op()==INTEGER_CONSTANT_OP) && (lower_bnd_ref->value() == 1))) && name_bnds.upper_exists()) { Expression & upper_bnd = name_bnds.upper_guarded(); if ((upper_bnd.op()==INTEGER_CONSTANT_OP) && (upper_bnd.value() == 2)) return_value = true; } } } } return return_value; } /// If a complex scalar has been passed to a two-element real array /// (with lower and upper bounds 1 and 2), generate an alternate /// expression (an ID expression for the complex scalar) which will /// be used if possible during statement and expression translation. /// /// This routine should eventually be extended to generate alternate /// expressions for complex arrays. /// static Expression * gen_alternate_expr(VariableSymbol * name_ptr, Expression & main_expr) { if (alternate_expr_valid(name_ptr, main_expr)) return id(main_expr.symbol()); else return NULL; } /// Fix up alternate expression static void fix_alternate_expr(Statement & s, ProgramUnit & pgm) { static String real_str("REAL"); static String aimag_str("AIMAG"); static String cmplx_str("CMPLX"); static Type real_type(REAL_TYPE, 0); static Type cmplx_type(COMPLEX_TYPE, 0); Expression * intrinsic_parm_expr = NULL; const char * symbol_name = s.lhs().intrinsic().symbol().tag_ref(); /// Grab lhs alternate expression and make a copy of /// subexpression for lhs (for now, must be IDExpr) Mutator<Expression> out_mutr = s.iterate_out_exprs_guarded(); Expression * rhs_alternate_expr = out_mutr.current().grab_right(); Expression * lhs_alternate_expr = rhs_alternate_expr->arg_list()[0].clone(); /// Replace lhs via mutator (to avoid unnecessary build_refs) out_mutr.modify(lhs_alternate_expr); /// Pull rhs and build intrinsic around it Mutator<Expression> in_mutr = s.iterate_in_exprs_guarded(); Assign<Expression> in_as(in_mutr.assign()); Expression * rhs_expr = in_mutr.pull(); if (aimag_str==symbol_name) { /// ... Create call to "REAL" function Symbol * opposite_ptr = pgm.symtab().find_ref(real_str); Expression * opposite_id_expr; if (opposite_ptr) opposite_id_expr = id(*opposite_ptr); else opposite_id_expr = new_intrinsic(real_str, real_type, pgm); intrinsic_parm_expr = comma(intrinsic_call(opposite_id_expr, rhs_alternate_expr), rhs_expr); } else if (real_str==symbol_name) { /// ... Create call to "AIMAG" function Symbol * opposite_ptr = pgm.symtab().find_ref(aimag_str); Expression * opposite_id_expr; if (opposite_ptr) opposite_id_expr = id(*opposite_ptr); else opposite_id_expr = new_intrinsic(aimag_str, real_type, pgm); intrinsic_parm_expr = comma(rhs_expr, intrinsic_call(opposite_id_expr, rhs_alternate_expr)); } else p_abort("Invalid intrinsic function encountered in fix_alternate_expr"); Expression * intrinsic_id_expr; /// Create call to "COMPLX" function Symbol * intrinsic_ptr = pgm.symtab().find_ref(cmplx_str); if (intrinsic_ptr) intrinsic_id_expr = id(*intrinsic_ptr); else intrinsic_id_expr = new_intrinsic(cmplx_str, cmplx_type, pgm); /// Finally, replace rhs with intrinsic function in_as = intrinsic_call(intrinsic_id_expr, intrinsic_parm_expr); /// Assume that caller will rebuild statement references } /// Make parameter variable and main program expression conformable Expression * InlineObject::make_conformable(VariableSymbol * name_ptr, Expression & main_expr) { Expression *main_expr_ptr = &main_expr; Expression *test_expr = 0; bool non_conformable_flag = false; Expression *debug_output = 0; if (_debug_flag) { debug_output = comma(); debug_output->arg_list().ins_first(id(*name_ptr)); } /// ... Check conformability of variables CONFORM_TYPE conformable = conformable_test(name_ptr, main_expr, non_conformable_flag); if (conformable == NON_CONFORMABLE) { Expression * equivalent_pair = main_expr_ptr = _gen_equivalent_var(name_ptr, main_expr); /// ... If complex passed to real, attempt to generate an alternate /// ... expression which avoids use of the equivalence if ((main_expr.type().data_type() == COMPLEX_TYPE) && (name_ptr->type().data_type() == REAL_TYPE)) { Expression * alt_expr = gen_alternate_expr(name_ptr,main_expr); if (alt_expr) _alternate_map.ins(*name_ptr,alt_expr); } non_conformable_flag = true; main_expr_ptr = equivalent_pair->arg_list().grab(0); test_expr = equivalent_pair->arg_list().grab(0); delete equivalent_pair; conformable = conformable_test(name_ptr, *main_expr_ptr, non_conformable_flag); p_assert(conformable != NON_CONFORMABLE, "Call to _gen_equivalent_var failed in make_conformable"); } /// ... Map non-constant references from name to main_name if (conformable != TRANSFORMABLE_CONSTANT) { Symbol & base_symbol = *main_expr_ptr->base_variable_ref(); _symbol_map.ins(*name_ptr, new SymRefElem(base_symbol)); if (_debug_flag) debug_output->arg_list().ins_last(id(base_symbol)); } /// ... TODO: Handle conformable but different sized character variables /// ... properly /// ... Remap transformable references /// ... VariableSymbol *main_name_ptr = NULL; Expression *main_subs_ptr = NULL; Expression *main_array_ptr = main_expr_ptr; switch (conformable) { case TRANSFORMABLE_CONSTANT: { /// ... Map references from name to a constant _constant_map.ins(*name_ptr, *main_expr_ptr); if (_debug_flag) debug_output->arg_list().ins_last(main_expr_ptr->clone()); break; } case TRANSFORMABLE_SUBSTRING: { // Save substring bounds _substring_map.ins(*name_ptr, main_expr_ptr->bound().clone()); break; } case TRANSFORMABLE_SUBSTRING_ARRAY: { // Save substring bounds _substring_map.ins(*name_ptr, main_expr_ptr->bound().clone()); // Point at the main program array reference main_array_ptr = & main_expr_ptr->string(); // Flow through into TRANFORMABLE_ARRAY code } case TRANSFORMABLE_ARRAY: { /// ... Map references from name to main_name VariableSymbol *main_name_ptr = (VariableSymbol *) main_array_ptr->base_variable_ref(); if (main_array_ptr->op() == ARRAY_REF_OP) main_subs_ptr = &main_array_ptr->subscript(); /// ... Get the dimension information for each symbol ArrayDims & name_dim = name_ptr->dim(); int name_dims = name_dim.entries(); ArrayDims & main_name_dim = main_name_ptr->dim(); int main_name_dims = main_name_dim.entries(); Expression *lambda_ref = comma(); if ((main_name_dims>0) && (name_dims == main_name_dims)) { Iterator<ArrayBounds> name_iter = name_dim; Iterator<ArrayBounds> main_name_iter = main_name_dim; List<Expression> dummy_list; List<Expression> *main_subs_listptr = &dummy_list; if (main_subs_ptr) main_subs_listptr = &main_subs_ptr->arg_list(); Iterator<Expression> main_subs_iter(*main_subs_listptr); for (int i = 1; i <= name_dims; ++i) { Expression *name_lb = name_iter.current().lower_ref(); if (name_lb) name_lb = name_lb->clone(); else name_lb = constant(1); Expression *main_name_lb = main_name_iter.current().lower_ref(); if (main_name_lb) main_name_lb = main_name_lb->clone(); else main_name_lb = constant(1); /// ... Absorb name_lb, main_name_lb as subexpressions of /// ... main_name_offptr Expression *main_name_offptr = sub(main_name_lb, name_lb); /// ... If subscript, adjust main_name_offptr and iterate /// ... subscript iterator if (main_subs_ptr) { main_name_offptr = add(main_name_offptr, sub(main_subs_iter.current().clone(), main_name_lb->clone())); ++main_subs_iter; } Type main_type = make_type(INTEGER_TYPE); main_name_offptr = add(main_name_offptr, new ArgNumberExpr(main_type, i)); /// ... Insert main_name_offptr into lambda ref lambda_ref->arg_list().ins_last(main_name_offptr); /// ... Increment variable iterators ++name_iter; ++main_name_iter; } /// ... Insert lambda call reference into map _array_map.ins(*name_ptr, lambda_ref); if (_debug_flag) debug_output->arg_list().ins_last(lambda_ref->clone()); } else if ((main_name_dims == 1) && (name_dims>0)) { /// ... Build a subscript reference for one to many /// ... dimension case. Expression *subscript_ref = comma(); Type int_type = make_type(INTEGER_TYPE); for (int i = 1; i <= name_dims; ++i) { Expression *arg_number_ptr = new ArgNumberExpr(int_type, i); /// ... Insert into subscript_ref subscript_ref->arg_list().ins_last(arg_number_ptr); } /// ... Linearize subscript reference Expression *linearize_pair = _linearize_array_ref(name_ptr, subscript_ref, main_name_ptr); Expression *offset = linearize_pair->arg_list().grab(0); delete linearize_pair; /// ... If subscript on main_name, adjust lambda_ref if (main_subs_ptr) { Expression *main_name_lb = main_name_ptr->dim()[0].lower_ref(); if (main_name_lb) main_name_lb = main_name_lb->clone(); else main_name_lb = constant(1); /// ... Absorb main_name_lb as subexpresion of offset offset = add(offset, sub(main_subs_ptr->arg_list()[0].clone(), main_name_lb)); } /// ... Insert offset into lambda ref lambda_ref->arg_list().ins_last(offset); /// ... Insert lambda call reference into map _array_map.ins(*name_ptr, lambda_ref); if (_debug_flag) debug_output->arg_list().ins_last(lambda_ref->clone()); } else if (name_dims == 0) { if (main_subs_ptr) lambda_ref = main_subs_ptr->clone(); else lambda_ref = initial_array_ref(main_name_ptr); /// ... Insert lambda call reference into map _array_map.ins(*name_ptr, lambda_ref); if (_debug_flag) debug_output->arg_list().ins_last(lambda_ref->clone()); } } default: break; } /// ... Handle non-conformable case if (non_conformable_flag) { if (test_expr->op()!=LOGICAL_CONSTANT_OP) { /// ... Insert test expression into list for later assertion _test_exprs.ins_last(test_expr); } else { /// ... Test expression is either irrelevantly true or /// ... catastrophically false p_assert(strcmp(test_expr->data_ref(),".TRUE.") == 0, "Illegal subscript alignment detected in make_conformable"); delete test_expr; } /// ... Clean up main expression delete main_expr_ptr; } return debug_output; } /// Map common blocks between contained pgm and main program void InlineObject::_remap_common_blocks() { /// ... Iterate over common blocks for (DictionaryIter<CommonBlock> common_iter = _pgm_ref->common_blocks(); common_iter.valid(); ++common_iter) { /// ... Check for a corresponding common block in the main program CommonBlock &common_local = common_iter.current(); const char *common_main_tag = common_local.name_ref(); CommonBlock *common_main_ptr = _pgm_main.common_blocks().find_ref(common_main_tag); if (!common_main_ptr) { RefList<Symbol> common_relink_list; // Remap individual variables into main program, renaming if // necessary. for (Iterator<Symbol> common_block_iter = common_local.iterator(); common_block_iter.valid(); ++common_block_iter) { VariableSymbol & current_symbol = (VariableSymbol &) common_block_iter.current(); /// ... Rename variable to match Symbol & main_symbol = rename_variable_to_match(*_pgm_ref, current_symbol, _pgm_main, current_symbol.clone_all()); /// ... Map current symbol to main program symbol _symbol_map.ins(current_symbol, new SymRefElem(main_symbol)); /// ... Put symbol on relink list if unequivalenced if (!current_symbol.equivalence_ref()) common_relink_list.ins_last(main_symbol); } // Clone now uncolliding common block and insert it into main // program (but do not propagate meaningless SAVE to PROGRAM_PU) common_main_ptr = new CommonBlock(common_local); if (common_local.saved() && (_pgm_main.pu_class()==PROGRAM_PU_TYPE)) common_main_ptr->saved(0); _pgm_main.common_blocks().ins(common_main_ptr); // Relink pointers in common block common_main_ptr->relink_dptrs(_pgm_main); // Relink pointers in unequivalenced common block variables for (Iterator<Symbol> relink_iter = common_relink_list; relink_iter.valid(); ++relink_iter) relink_iter.current().relink_dptrs(_pgm_main); } else { map_existing_common_block(common_local, common_main_ptr); } } } /// Map the variables from a COMMON in a called routine to a COMMON by /// the same name in a calling routine. /// COMMON in called routine: common_local /// COMMON in calling routine: common_main_ptr /// Calling routine: pgm_main void InlineObject::map_existing_common_block(CommonBlock & common_local, CommonBlock * common_main_ptr) { /// ... There's a similar common block in main pgm, so build /// ... common_map and common_main_map and perform overlapping /// ... common block processing /// ... Propagate SAVE if inlining into another subprogram if (common_local.saved() && (_pgm_main.pu_class()!=PROGRAM_PU_TYPE)) common_main_ptr->saved(1); /// ... Iterate over variables in common blocks int common_offset = 0; int common_main_offset = 0; Iterator<Symbol> common_main_block_iter = common_main_ptr->iterator(); VariableSymbol *name_ptr; VariableSymbol *main_name_ptr = (VariableSymbol *) & common_main_block_iter.current(); VariableSizes common_main_variable_sizes(*main_name_ptr); for (Iterator<Symbol> common_block_iter = common_local.iterator(); common_block_iter.valid(); ++common_block_iter) { /// ... Calculate offset information for contained variable name_ptr = (VariableSymbol *) & common_block_iter.current(); VariableSizes common_variable_sizes(*name_ptr); /// ... If current main pgm variable doesn't overlap the /// ... contained variable, look at the next main pgm variable. while (common_main_block_iter.valid() && ((common_main_offset>common_offset) || (common_main_offset + common_main_variable_sizes.size <= common_offset))) { common_main_offset += common_main_variable_sizes.size; ++common_main_block_iter; if (common_main_block_iter.valid()) { main_name_ptr = (VariableSymbol *) &common_main_block_iter.current(); common_main_variable_sizes.remap(*main_name_ptr); } } /// ... Fall out of the loop if the main pgm common block runs /// ... out; this case will be implemented later. if (!common_main_block_iter.valid()) break; int var_offset = common_offset - common_main_offset; Expression *main_expr_ptr; Expression *main_id_ptr = id(*main_name_ptr); if (var_offset) { if ((var_offset % common_main_variable_sizes.elem_size) == 0) { /// ... Generate subscript expression Expression *main_subs_ptr = unlinearize_array_ref(main_name_ptr, var_offset / common_main_variable_sizes.elem_size); /// ... Absorb ID and subscript expressions into array /// ... reference. main_expr_ptr = array_reference(main_id_ptr, main_subs_ptr); } else { /// ... Generate equivalent variable (eventually, attempt /// ... to generate an alternate expression here for /// ... complex mapped to real) Expression *equivalent_pair = _gen_equivalent_var(name_ptr,*main_id_ptr); Expression *main_equiv_ptr = equivalent_pair->arg_list().grab(0); delete equivalent_pair; /// ... Point at base variable VariableSymbol *equiv_name_ptr = (VariableSymbol *) main_equiv_ptr->base_variable_ref(); /// ... Delete ID expression because it wasn't absorbed delete main_id_ptr; /// ... Generate subscript expression Expression *main_subs_ptr = unlinearize_array_ref(equiv_name_ptr, var_offset / common_variable_sizes.elem_size); /// ... Absorb ID and subscript expressions into array /// ... reference. main_expr_ptr = array_reference(main_equiv_ptr, main_subs_ptr); } } else { main_expr_ptr = main_id_ptr; } /// ... Make the common block variables conform to one another Expression * debug_output = make_conformable(name_ptr, *main_expr_ptr); if (debug_output) delete debug_output; /// ... Delete main program expression delete main_expr_ptr; /// ... Increment common_offset by size of variable common_offset += common_variable_sizes.size; } } /// Map equivalences between contained pgm and main program void InlineObject::_remap_equivalences() { /// ... Iterate over equivalences for (DictionaryIter<Equivalence> equiv_iter = _pgm_ref->equivalences(); equiv_iter.valid(); ++equiv_iter) { Equivalence & current_equiv = equiv_iter.current(); Equivalence * pre_main_equiv_ptr = 0; int pre_main_equiv_bb = 0; int common_bb = 0; PRIVAT_TYPE priv_type = PRIVATE; /// ... Search equivalence for common and saved variables. for (Iterator<EquivalenceMember> scan_iter = current_equiv.iterator(); scan_iter.valid(); ++scan_iter) { EquivalenceMember & scan_em = scan_iter.current(); Symbol & scan_symbol = scan_em.symbol(); if(scan_symbol.saved()!=NOT_SAVED) { priv_type = NOT_PRIVATE; break; } else if(scan_symbol.common_ref()) { priv_type = NOT_PRIVATE; SymRefElem * main_symbol_ref = _symbol_map.find_ref(scan_symbol); Symbol * main_symbol_ptr = _pgm_main.symtab().find_ref(scan_symbol.name_ref()); p_assert(main_symbol_ptr && main_symbol_ref && (&(*main_symbol_ref->symref()) == main_symbol_ptr), "Invalid common symbol in _remap_equivalences"); /// ... If conflicting common block with no equivalence for the /// ... corresponding top level variable, create an equivalence /// ... in top level program and insert corresponding variable /// ... into it at byte base 0 if (!main_symbol_ptr->equivalence_ref()) { char label_buff[10]; int equiv_count = _pgm_main.equivalences().entries(); sprintf(label_buff, "EQ%u", equiv_count+1); Equivalence * main_equiv_ptr = new Equivalence(label_buff); _pgm_main.equivalences().rename_and_ins(main_equiv_ptr); main_equiv_ptr->ins(*main_symbol_ptr, 0); } /// ... Process common variable differently only if it is in a /// ... different equivalence (from a conflicting common block) if (main_symbol_ptr->equivalence_ref() != &current_equiv) { pre_main_equiv_ptr = main_symbol_ptr->equivalence_ref(); common_bb = scan_em.byte_base(); EquivalenceMember * em_ptr = pre_main_equiv_ptr->find_ref(*main_symbol_ptr); p_assert(em_ptr, "Invalid equivalence in _remap_equivalences"); pre_main_equiv_bb = em_ptr->byte_base(); } break; } } if (priv_type == PRIVATE) _private_vars += current_equiv.entries(); if (pre_main_equiv_ptr) { /// ... Insert variables into equivalence generated by conflicting common /// ... block for (Iterator<EquivalenceMember> eb_iter = current_equiv.iterator(); eb_iter.valid(); ++eb_iter) { EquivalenceMember & current_em = eb_iter.current(); Symbol & current_symbol = current_em.symbol(); if (!current_symbol.common_ref()) { int em_bb = current_em.byte_base(); current_equiv.del(current_symbol); Symbol & main_symbol = rename_variable_to_match(*_pgm_ref, current_symbol, _pgm_main, current_symbol.clone()); _symbol_map.ins(current_symbol, new SymRefElem(main_symbol, priv_type)); // Put into pre-existing equivalence class pre_main_equiv_ptr->ins(main_symbol, em_bb - common_bb + pre_main_equiv_bb); } } } else { /// ... Remap non-common variables into main program, renaming if /// ... necessary. for (Iterator<EquivalenceMember> eb_iter = current_equiv.iterator(); eb_iter.valid(); ++eb_iter) { EquivalenceMember & current_em = eb_iter.current(); VariableSymbol & current_symbol = (VariableSymbol &) current_em.symbol(); if (!current_symbol.common_ref()) { Symbol & main_symbol = rename_variable_to_match(*_pgm_ref, current_symbol, _pgm_main, current_symbol.clone_all()); // Map current symbol to main program symbol _symbol_map.ins(current_symbol, new SymRefElem(main_symbol, priv_type)); } } /// ... Clone now uncolliding equivalence block and insert it into main /// ... program Equivalence & equiv_main = rename_equivalence_to_match(*_pgm_ref, current_equiv, _pgm_main, new Equivalence(current_equiv)); /// ... Relink pointers in equivalence block equiv_main.relink_dptrs(_pgm_main); /// ... Relink pointers in equivalence block variables for (Iterator<EquivalenceMember> relink_iter = equiv_main.iterator(); relink_iter.valid(); ++relink_iter) relink_iter.current().symbol().relink_dptrs(_pgm_main); } } } /// Remap and move data statements from contained pgm to main program, /// renaming them void InlineObject::_remap_and_move_data() { /// Insert all data statements into main program for (Iterator<Data> data_iter = _pgm_ref->data(); data_iter.valid(); ++data_iter) { Data *current_data = data_iter.current().clone(); /// ... Rename variables in variable list Expression & var_list = CASTAWAY(Expression &) current_data->variable_list(); for (Mutator<Expression> expr_mutr = var_list.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); } /// ... Insert data statement into main program _pgm_main.data().ins_last(current_data); } } /// At the call site, remap the uses of each argument in the main program /// and return the entry point of the routine Statement & InlineObject::_remap_arg_uses(Statement & s) { Symbol *entry_name_ptr = 0; List<Expression> *actual_ptr = 0; int actual_entries = 0; List<Expression> *formal_ptr = 0; int formal_entries = 0; ostrstream *str_ref; char *data; if (s.stmt_class() == CALL_STMT) { /// ... CALL statement: find the pointer to the actual list in main /// ... pgm and the pointer to the contained entry name symbol if (s.parameters_valid()) actual_ptr = &s.parameters_guarded().arg_list(); entry_name_ptr = _pgm_ref->symtab().find_ref(s.routine_guarded().symbol().name_ref()); } else { /// ... Function call: find the pointer to the actual list in main /// ... pgm, the pointer to the contained entry name sym, and the /// ... pointer to the symbol for the temporary variable to which the /// ... function value is assigned in pgm (cloning it from main pgm) if (s.rhs().parameters_valid()) actual_ptr = &s.rhs().parameters_guarded().arg_list(); entry_name_ptr = _pgm_ref->symtab().find_ref(s.rhs().function().symbol().name_ref()); /// ... Map the entry name symbol to the temporary name in main program _symbol_map.ins(*entry_name_ptr, new SymRefElem(s.lhs().symbol())); } /// ... If debugging is on, make debugging output and create beginning and /// ... ending comments if (_debug_flag) { str_ref = new ostrstream; StringElem * comment_line; const char * rout_tag = entry_name_ptr->tag_ref(); (*str_ref) << " Beginning of call to routine " << rout_tag << '\000'; data = str_ref->str(); comment_line = new StringElem(data); delete [] data; delete str_ref; _begin_comment_list.ins_first(comment_line); str_ref = new ostrstream; (*str_ref) << " End of call to routine " << rout_tag << '\000'; data = str_ref->str(); comment_line = new StringElem(data); delete [] data; delete str_ref; _end_comment_list.ins_first(comment_line); } /// ... Find the entry point and its parameter list Statement *entry_point_ptr = NULL; for (Iterator<Statement> entry_iter = _pgm_ref->stmts().iterate_entry_points(); entry_iter.valid(); ++entry_iter) { /// ... Set c to point to current statement Statement *c = &entry_iter.current(); if ((c->stmt_class() != FLOW_ENTRY_STMT) && (entry_name_ptr == &c->routine_guarded().symbol())) { entry_point_ptr = c; break; } } p_assert(entry_point_ptr, "Entry point not found by _remap_arg_uses"); /// ... Define the default number of actual and formal entries in each list if (actual_ptr) actual_entries = actual_ptr->entries(); if (entry_point_ptr->parameters_valid()) { formal_ptr = &entry_point_ptr->parameters_guarded().arg_list(); formal_entries = formal_ptr->entries(); } /// ... If mismatching numbers of arguments, error p_assert(actual_entries==formal_entries, "Different number of parameters in _remap_arg_uses"); if (actual_entries) { /// ... Build iterators for argument list and parameter list Iterator<Expression> actual_iter = *actual_ptr; Iterator<Expression> formal_iter = *formal_ptr; while (actual_iter.valid() && formal_iter.valid()) { /// ... Point at formal variable and expression in main program VariableSymbol *name_ptr = (VariableSymbol *) formal_iter.current().base_variable_ref(); Expression & main_expr = actual_iter.current(); /// ... Make them conform to one another Expression * debug_output = make_conformable(name_ptr, main_expr); /// ... If debugging on, write comment line about mapping if (_debug_flag) { Iterator<Expression> debug_iter = debug_output->arg_list(); str_ref = new ostrstream; (*str_ref) << " Dummy parm " << debug_iter.current(); ++debug_iter; (*str_ref) << " replaced by actual parm " << debug_iter.current(); ++debug_iter; if (debug_iter.valid()) { (*str_ref) << " (with lambda subexpression " << debug_iter.current() << ')'; } (*str_ref) << '\000'; data = str_ref->str(); StringElem *comment_line = new StringElem(data); delete [] data; delete str_ref; _begin_comment_list.ins_last(comment_line); delete debug_output; } /// ... Increment the iterators ++actual_iter; ++formal_iter; } } return *entry_point_ptr; } /// Insert a mapping from the formal arg names to the actual /// arg names for a particular call statement. /// USED ONLY FOR ACCESS REGION ARGUMENT TRANSLATION. void InlineObject::remap_arg_names(Statement & s) { Symbol *entry_name_ptr = 0; List<Expression> *actual_ptr = 0; int actual_entries = 0; List<Expression> *formal_ptr = 0; int formal_entries = 0; /// ... ostrstream *str_ref; /// ... char *data; int narrays = 0; int nreshaped = 0; if (s.stmt_class() == CALL_STMT) { /// ... CALL statement: find the pointer to the actual list in main /// ... pgm and the pointer to the contained entry name symbol if (s.parameters_valid()) actual_ptr = &s.parameters_guarded().arg_list(); entry_name_ptr = _pgm_ref->symtab().find_ref(s.routine_guarded().symbol().name_ref()); } else { /// ... Function call: find the pointer to the actual list in main /// ... pgm, the pointer to the contained entry name sym, and the /// ... pointer to the symbol for the temporary variable to which the /// ... function value is assigned in pgm (cloning it from main pgm) if (s.rhs().parameters_valid()) actual_ptr = &s.rhs().parameters_guarded().arg_list(); entry_name_ptr = _pgm_ref->symtab().find_ref(s.rhs().function().symbol().name_ref()); /// ... Map the entry name symbol to the temporary name in main program /// _symbol_map.ins(*entry_name_ptr, // new SymRefElem(s.lhs().symbol())); } /// ... Find the entry point and its parameter list Statement *entry_point_ptr = NULL; for (Iterator<Statement> entry_iter = _pgm_ref->stmts().iterate_entry_points(); entry_iter.valid(); ++entry_iter) { /// ... Set c to point to current statement Statement *c = &entry_iter.current(); if ((c->stmt_class() != FLOW_ENTRY_STMT) && (entry_name_ptr == &c->routine_guarded().symbol())) { entry_point_ptr = c; break; } } p_assert(entry_point_ptr, "Entry point not found by _remap_arg_uses"); /// ... Define the default number of actual and formal entries in each list if (actual_ptr) actual_entries = actual_ptr->entries(); if (entry_point_ptr->parameters_valid()) { formal_ptr = &entry_point_ptr->parameters_guarded().arg_list(); formal_entries = formal_ptr->entries(); } /// ... If mismatching numbers of arguments, error p_assert(actual_entries==formal_entries, "Different number of parameters in _remap_arg_uses"); if (actual_entries) { /// ... Build iterators for argument list and parameter list Iterator<Expression> actual_iter = *actual_ptr; Iterator<Expression> formal_iter = *formal_ptr; /// ... Prepare the formal-actual mapping. while (actual_iter.valid() && formal_iter.valid()) { // Point at formal variable and expression in main program VariableSymbol *formal_symbol = (VariableSymbol *) formal_iter.current().base_variable_ref(); Expression & current_expr = actual_iter.current(); // VariableSymbol *actual_symbol // = (VariableSymbol *) current_expr.base_variable_ref(); Expression * actual_expr=0; AbstractAccess * aa; if ((current_expr.op() == FUNCTION_CALL_OP) && (strcmp(current_expr.arg_list()[0].symbol().name_ref(), "<BETA>") == 0)) { /// ... This must be in GSA form! CALL x(<beta>(ALPHA(,input),output), ... ) if (current_expr.arg_list()[1].arg_list()[0].op() == ALPHA_OP) { actual_expr = current_expr.arg_list()[1].arg_list()[0].arg_list()[1].arg_list()[0].clone(); aa = compute_abstract_access(*actual_expr, &s, AR_READWRITE); } else { p_abort("Unexpected form of BETA function"); } } else { actual_expr = current_expr.clone(); aa = compute_abstract_access( *actual_expr, &s, AR_READWRITE ); } _insert_arg_mapping(*formal_symbol, actual_expr, aa); // Add mapping to InlineObject // If the actual_expr is not either an ArrayRefExpr or an IDExpr, // forget it. if ((actual_expr->op() == ARRAY_REF_OP) || (actual_expr->op() == ID_OP)) { _symbol_map.ins(*formal_symbol, new SymRefElem(*(actual_expr->base_variable_ref()))); } // Increment the iterators ++actual_iter; ++formal_iter; } /// ... Check for reshaping, if required if (_ar_reshape) { actual_iter.reset(); formal_iter.reset(); while (actual_iter.valid() && formal_iter.valid()) { /// ... Point at formal variable and expression in main program VariableSymbol *formal_symbol = (VariableSymbol *) formal_iter.current().base_variable_ref(); Expression & current_expr = actual_iter.current(); VariableSymbol *actual_symbol = (VariableSymbol *) current_expr.base_variable_ref(); /// ... If both actual and formal are arrays, then check for reshaping if (_ar_reshape && actual_symbol && formal_symbol->is_array() && actual_symbol->is_array()) { narrays++; /// ... Found both are arrays. for (int i=0; i<formal_symbol->dim().entries()-1; i++) { if (i>actual_symbol->dim().entries()-1) { nreshaped++; if (_ar_reshape == 2) { ostrstream str1; ostrstream str2; str1 << convert_case(formal_symbol->name_ref()); str2 << convert_case(actual_symbol->name_ref()); formal_symbol->dim().print(str1); actual_symbol->dim().print(str2); str1 << '\000'; str2 << '\000'; char *data1 = str1.str(); char *data2 = str2.str(); cout << "RESHAPING: " << data2 << " to " << data1 << endl; } break; } ArrayBounds & actual_bounds = actual_symbol->dim()[i]; ArrayBounds & formal_bounds = formal_symbol->dim()[i]; Expression * act_lo; Expression * form_lo; Expression * act_num_elems; Expression * form_num_elems; if (!(actual_bounds.lower_exists())) { act_lo = constant(1); } else { act_lo = actual_bounds.lower_guarded().clone(); } if (!actual_bounds.upper_exists()) { nreshaped++; ostrstream str1; ostrstream str2; str1 << convert_case(formal_symbol->name_ref()); str2 << convert_case(actual_symbol->name_ref()); formal_symbol->dim().print(str1); actual_symbol->dim().print(str2); str1 << '\000'; str2 << '\000'; char *data1 = str1.str(); char *data2 = str2.str(); cout << "RESHAPING: " << data2 << " to " << data1 << endl; delete act_lo; break; } act_num_elems = simplify(add(sub(actual_bounds.upper_guarded().clone(), act_lo), constant(1))); if (!(formal_bounds.lower_exists())) { form_lo = constant(1); } else { form_lo = formal_bounds.lower_guarded().clone(); } Expression * upper_expr; /// ... If the declared upper bound of the formal is a variable, /// ... which is also a parameter, substitute the actual expression /// ... for the variable. Expression & upper = formal_bounds.upper_guarded(); if ((upper.op() == ID_OP) && (upper.symbol().formal())) { upper_expr = actual_arg(upper.symbol())->clone(); } else { upper_expr = formal_bounds.upper_guarded().clone(); } form_num_elems = simplify(add(sub(upper_expr, form_lo), constant(1))); Expression * diff = simplify(sub(form_num_elems,act_num_elems)); if (!is_integer_zero(*diff)) { nreshaped++; ostrstream str1; ostrstream str2; str1 << convert_case(formal_symbol->name_ref()); str2 << convert_case(actual_symbol->name_ref()); formal_symbol->dim().print(str1); actual_symbol->dim().print(str2); str1 << '\000'; str2 << '\000'; char *data1 = str1.str(); char *data2 = str2.str(); cout << "RESHAPING: " << data2 << " to " << data1 << endl; delete diff; break; } else { delete diff; } } } /// ... Increment the iterators ++actual_iter; ++formal_iter; } } } if (_ar_reshape) { cout << "CALL: " << actual_entries << " params " << narrays << " arrays " << nreshaped << " reshaped" << endl; } } /// At the call site in the main program, precalculate an expression /// if it does not map 1-1 in the subroutine. static Expression * remap_args_precalc_expr(StmtInfo & arg_map, Expression * expr) { switch (expr->op()) { case INTEGER_CONSTANT_OP: case REAL_CONSTANT_OP: case LOGICAL_CONSTANT_OP: case ID_OP: break; case ARRAY_REF_OP: { /// ... Traverse array subscripts for (Mutator<Expression> subs_mutr = expr->subscript().arg_list(); subs_mutr.valid(); ++subs_mutr) { Expression & current_subs = subs_mutr.current(); if (current_subs.op() != INTEGER_CONSTANT_OP) { Assign<Expression> subs_as(subs_mutr.assign()); subs_as = get_precalc(subs_mutr.pull(), *arg_map.program_ref, *arg_map.stmt_ref, PRECALC_ALWAYS, "PC"); } } break; } case SUBSTRING_OP: { /// ... Store bound list List<Expression> & bound_list = expr->bound().arg_list(); int bound_entries = bound_list.entries(); /// ... Remember length of base character expression int base_len = expr->string().base_variable_ref()->type().size(); switch (bound_list[0].op()) { case INTEGER_CONSTANT_OP: break; case OMEGA_OP: { bound_list.del(0); bound_list.ins_first(constant(1)); break; } default: { Assign<Expression> bound_as(bound_list.assign(0)); bound_as = get_precalc(bound_list.pull(0), *arg_map.program_ref, *arg_map.stmt_ref, PRECALC_ALWAYS, "PC"); } } if (bound_entries==2) switch (bound_list[1].op()) { case INTEGER_CONSTANT_OP: break; case OMEGA_OP: { bound_list.del(1); bound_list.ins_last(constant(base_len)); break; } default: { Assign<Expression> bound_as(bound_list.assign(1)); bound_as = get_precalc(bound_list.pull(1), *arg_map.program_ref, *arg_map.stmt_ref, PRECALC_ALWAYS, "PC"); } } else /// ... Increase length of bound_list by adding an explicit upper bound /// ... for the string bound_list.ins_last(constant(base_len)); /// ... Precalculate string part of substring if need be expr->left(remap_args_precalc_expr(arg_map,expr->grab_left())); break; } default: expr = get_precalc(expr, *arg_map.program_ref, *arg_map.stmt_ref, PRECALC_ALWAYS, "PC"); } return expr; } /// At the call site in the main program, precalculate any expressions /// which do not map 1-1 in the subroutine. static Statement * remap_args_precalc(ProgramUnit & pgm_main, Statement & s) { Statement *prev_stmt_ref = s.prev_ref(); Expression *arglist_ptr = 0; /// ... Find the argument list switch (s.stmt_class()) { case CALL_STMT: { if (s.parameters_valid()) arglist_ptr = &s.parameters_guarded(); else return &s; break; } case ASSIGNMENT_STMT: { if ((s.rhs().op() == FUNCTION_CALL_OP) && (s.rhs().parameters_valid())) arglist_ptr = &(s.rhs().parameters_guarded()); else return &s; break; } default: return &s; } /// ... Set up argument map for precalculation StmtInfo arg_map; arg_map.program_ref = &pgm_main; arg_map.stmt_ref = &s; /// ... Iterate over the arguments for (Mutator<Expression> arg_mutr = arglist_ptr->arg_list(); arg_mutr.valid(); ++arg_mutr) { Assign<Expression> expr_as(arg_mutr.assign()); expr_as = remap_args_precalc_expr(arg_map, arg_mutr.pull()); } /// ... Recalculate flow information after possible precalculations s.build_refs(); if (prev_stmt_ref) return prev_stmt_ref->next_ref(); else return pgm_main.stmts().first_ref(); } /// Precalculate function call static Expression * precalc_func_call(Expression * e, ExtraInfo & extra_info) { StmtInfo & arg_map = *((Info<StmtInfo * >&) extra_info).data(); return get_precalc(e->clone(), *arg_map.program_ref, *arg_map.stmt_ref, PRECALC_ALWAYS, "PC"); } /// Precalculate all function calls which are not subexpressions of /// a do expr via a call to replace (to insure postorder precalculation) /// Replace a do expr with itself to prevent further checking of its /// subexpressions static Expression * precalc_non_do_expr(Expression * e, ExtraInfo & extra_info) { static AnyOfType func_call_pattern(FUNCTION_CALL_OP); if (e->op() == FUNCTION_CALL_OP) return replace(e, func_call_pattern, precalc_func_call, extra_info, NON_RECURSIVE_REPLACE, POSTORDER_REPLACE); else return e; } /// Clean up statement static Statement & clean_statement(ProgramUnit & pgm, Statement & s) { /// Static patterns static AnyOfType func_call_pattern(FUNCTION_CALL_OP); static StmtInfo arg_map; Statement *prev_stmt_ref = s.prev_ref(); STMT_TYPE stype = s.stmt_class(); arg_map.program_ref = &pgm; arg_map.stmt_ref = &s; switch (stype) { case ASSIGNMENT_STMT: { /// ... If assignment statement is already in a suitable form (ID_OP on /// ... LHS), look for FUNCTION_CALL_OP only in RHS arguments (if any) if (s.lhs().op() == ID_OP) { for (Mutator<Expression> expr_mutr = s.rhs().arg_list(); expr_mutr.valid(); ++expr_mutr) { Info<StmtInfo *> inf(&arg_map); Assign<Expression> expr_as(expr_mutr.assign()); expr_as = replace(expr_mutr.pull(), func_call_pattern, precalc_func_call, inf, NON_RECURSIVE_REPLACE, POSTORDER_REPLACE); } } /// ... If assignment statement with non ID-OP on LHS, /// ... look for FUNCTION_CALL_OP everywhere else { for (Mutator<Expression> expr_mutr = s.iterate_expressions(); expr_mutr.valid(); ++expr_mutr) { Info<StmtInfo *> inf(&arg_map); Assign<Expression> expr_as(expr_mutr.assign()); expr_as = replace(expr_mutr.pull(), func_call_pattern, precalc_func_call, inf, NON_RECURSIVE_REPLACE, POSTORDER_REPLACE); } } break; } case READ_STMT: case WRITE_STMT: case PRINT_STMT: { /// ... Look for DO_OP and FUNCTION_CALL_OP, and do not search for /// ... FUNCTION_CALL_OP within a DO_OP static WildcardOr * full_pattern = new WildcardOr(new AnyOfType(FUNCTION_CALL_OP), new AnyOfType(DO_OP)); for (Mutator<Expression> expr_mutr = s.iterate_expressions(); expr_mutr.valid(); ++expr_mutr) { Info<StmtInfo *> inf(&arg_map); Assign<Expression> expr_as(expr_mutr.assign()); expr_as = replace(expr_mutr.pull(), *full_pattern, precalc_non_do_expr, inf, NON_RECURSIVE_REPLACE, PREORDER_REPLACE); } break; } default: { /// ... Look for FUNCTION_CALL_OP everywhere for (Mutator<Expression> expr_mutr = s.iterate_expressions(); expr_mutr.valid(); ++expr_mutr) { Info<StmtInfo *> inf(&arg_map); Assign<Expression> expr_as(expr_mutr.assign()); expr_as = replace(expr_mutr.pull(), func_call_pattern, precalc_func_call, inf, NON_RECURSIVE_REPLACE, POSTORDER_REPLACE); } } } /// Point at first statement after function call precalculation Statement *first_stmt_ref; if (prev_stmt_ref) first_stmt_ref = prev_stmt_ref->next_ref(); else first_stmt_ref = &s; RefSet<Statement> processed_stmts; /// Iterate until earliest precalculation statement is known do { processed_stmts.ins(*first_stmt_ref); first_stmt_ref = remap_args_precalc(pgm, *first_stmt_ref); } while (!processed_stmts.member(*first_stmt_ref)); /// Perform more processing if any precalculation statements generated if (first_stmt_ref != &s) { /// ... Iterate until there are no more statements to process Statement * stmt_ref = first_stmt_ref->next_ref(); while (stmt_ref != &s) { while (!processed_stmts.member(*stmt_ref)) { processed_stmts.ins(*stmt_ref); stmt_ref = remap_args_precalc(pgm, *stmt_ref); } stmt_ref = stmt_ref->next_ref(); } /// ... If need be, rebuild references on original statement if (!processed_stmts.member(s)) s.build_refs(); } /// Point to first precalculation statement generated return *first_stmt_ref; } /// Clean up program variables static void clean_variables(ProgramUnit & pgm) { List<StringElem> rename_list; for (DictionaryIter<Symbol> sym_iter = pgm.symtab().iterator(); sym_iter.valid(); ++ sym_iter) { Symbol & current_symbol = sym_iter.current(); switch (current_symbol.sym_class()) { case VARIABLE_CLASS: case SYMBOLIC_CONSTANT_CLASS: { const char *current_tag = current_symbol.name_ref(); if(lookup_intrinsic(current_tag)) rename_list.ins_last(new StringElem(current_tag)); } default: break; } } for (Iterator<StringElem> rename_iter = rename_list; rename_iter.valid(); ++rename_iter) { Symbol * symbol_ptr = pgm.symtab().grab(rename_iter.current()); pgm.symtab().rename_and_ins(symbol_ptr); } } /// Work routine for counting executable statements int count_stmt(Statement & stmt, int stmt_counter) { switch (stmt.stmt_class()) { case UNDEFINED_STMT: case IMPLIED_GOTO_STMT: case FLOW_ENTRY_STMT: case FLOW_EXIT_STMT: case BLOCK_ENTRY_STMT: case BLOCK_EXIT_STMT: case ENTRY_STMT: case LABEL_STMT: case ALLOCATE_STMT: case DEALLOCATE_STMT: case NULLIFY_STMT: case DIRECTIVE_STMT: case STMT_PTR: return stmt_counter; default: break; } return ++stmt_counter; } /// Count executable statements static int count_stmts(Iterator<Statement> stmt_iter) { int executable_stmts = 0; for (; stmt_iter.valid(); ++stmt_iter) executable_stmts = count_stmt(stmt_iter.current(), executable_stmts); return executable_stmts; } /// Clean program for inlining, counting statements and creating a /// workspace for program if requested void clean_program(ProgramUnit & pgm, Element<InlineWorkSpace> & ws_ref) { clean_variables(pgm); int executable_stmts = 0; for (Iterator<Statement> stmt_iter = pgm.stmts().iterator(); stmt_iter.valid(); ++stmt_iter) { Statement & current_stmt = stmt_iter.current(); if (ws_ref->count_active()) executable_stmts = count_stmt(current_stmt, executable_stmts); Statement & first_precalc_stmt = clean_statement(pgm, current_stmt); if (&first_precalc_stmt != &current_stmt) { /// ... Check for assertions to propagate onto other /// ... statements RefList<Assertion> assertlist; for (Iterator<Assertion> assert_iter = current_stmt.assertions(); assert_iter.valid(); ++ assert_iter) { Assertion & current_assert = assert_iter.current(); AssertionType current_type = current_assert.type(); /// ... added AS_RECURSIVEINLINE (kjackson) if ((current_type == AS_INLINE) || (current_type == AS_RECURSIVEINLINE) || (current_type == AS_NOINLINE) || (current_type == AS_SIDE_EFFECT_FREE)) { assertlist.ins_last(current_assert); break; } } int entries = assertlist.entries(); if (entries > 0 || ws_ref->count_active()) { /// ... Go through precalculation statements for (Iterator<Statement> prop_iter = pgm.stmts().iterator(first_precalc_stmt, *current_stmt.prev_ref()); prop_iter.valid(); ++prop_iter) { Statement & prop_stmt = prop_iter.current(); /// ... Count statements if requested if (ws_ref->count_active()) executable_stmts = count_stmt(prop_stmt, executable_stmts); /// ... Propagate assertion onto any precalculated /// ... function calls if (entries > 0) { for (Iterator<Assertion> assertion_iter = assertlist; assertion_iter.valid(); ++assertion_iter) { if ((prop_stmt.stmt_class()==ASSIGNMENT_STMT) && (prop_stmt.rhs().op()==FUNCTION_CALL_OP)) prop_stmt.assertions().ins_last(assertion_iter.current().clone()); } } } /// ... Remove original assertion if it no longer pertains if (entries > 0) { for (Iterator<Assertion> assert_iter = assertlist; assert_iter.valid(); ++assert_iter) { /// ... AssertionType this_type = assert_iter.current().type(); /// ... added AS_RECURSIVEINLINE (kjackson, Hao) if ((assert_iter.current().type() == AS_INLINE) || (assert_iter.current().type() == AS_RECURSIVEINLINE) || (assert_iter.current().type() == AS_NOINLINE)) { STMT_TYPE stype = current_stmt.stmt_class(); if (stype == CALL_STMT) continue; if ((stype != ASSIGNMENT_STMT) || current_stmt.rhs().op() != FUNCTION_CALL_OP) current_stmt.assertions().del(assert_iter.current()); } else { current_stmt.assertions().del(assert_iter.current()); } } } } } } /// Create inline workspace to store line count if requested if (ws_ref->count_active()) { int total_stmts = pgm.stmts().entries(); pgm.work_stack().push(new InlineWorkSpace(*ws_ref, executable_stmts, total_stmts)); const char * routine_name_ref = pgm.routine_name_ref(); const char * null_name_ref = "NULL"; cout << "Routine " << (routine_name_ref ? routine_name_ref : null_name_ref) << ": <" << executable_stmts << ", " << total_stmts << ">\n"; int exec_routine_count = InlineWorkSpace::exec_routine_count() + 1; InlineWorkSpace::exec_routine_count(exec_routine_count); int total_routine_count = InlineWorkSpace::total_routine_count() + 1; InlineWorkSpace::total_routine_count(total_routine_count); int exec_line_count = InlineWorkSpace::exec_line_count() + executable_stmts; InlineWorkSpace::exec_line_count(exec_line_count); int total_line_count = InlineWorkSpace::total_line_count() + total_stmts; InlineWorkSpace::total_line_count(total_line_count); } } /// Clean up program after inlining void cleanup_program(ProgramUnit & pgm) { static String dc_debug_switch("dead_debug"); /// Build list of candidate precalculation variables RefSet<Symbol> candidate_set; for (DictionaryIter<Symbol> symbol_iter = pgm.symtab().iterator(); symbol_iter.valid(); ++symbol_iter) { Symbol & current_symbol = symbol_iter.current(); const Type & current_type = current_symbol.type(); if ((current_type.data_type() == INTEGER_TYPE) && (current_type.is_scalar()) && (strncmp(current_symbol.name_ref(),"PC",2) == 0)) candidate_set.ins(current_symbol); } if (candidate_set.entries()) { /// ... Propagate the candidate variables if possible propagate_constants(pgm, candidate_set, REMOVE_UNREACH_CODE); /// ... Accept small substitutions expand_small_substituted(pgm); /// ... Clear any leftover substitutions clear_substituted(pgm); } /// Deadcode the program eliminate_dead_code(pgm, DONT_DEADCODE_ARRAYS, switch_value(dc_debug_switch)); } /// Simplify the array reference and substring expressions within an /// expression static Expression * simplify_subs_exprs(Expression * expr) { switch (expr->op()) { case ARRAY_REF_OP: case SUBSTRING_OP: /// ... Simplify array reference or substring expressions return simplify(expr); default: /// ... Traverse subexpressions and replace any which are relevant for (Mutator<Expression> expr_mutr = expr->arg_list(); expr_mutr.valid(); ++expr_mutr) { Assign<Expression> expr_as(expr_mutr.assign()); expr_as = simplify_subs_exprs(expr_mutr.pull()); } } return expr; } /// Translate symbol references within the range of an Expression /// mutator using the symbol, array, constant and substring maps, /// returning a count of the number of modifications int InlineObject::_translate_symbol_refs_mutr(Mutator<Expression> expr_mutr, LambdaInfo & lambda, REF_TYPE ref) { int modify_counter = 0; for (; expr_mutr.valid(); ++expr_mutr) { int local_modify_counter = 0; /// ... Remove expression from arg list Assign<Expression> ex_as(expr_mutr.assign()); Expression * ex = expr_mutr.pull(); /// ... Substitute expression until fixed point local_modify_counter = remap_expr( &ex, lambda, ref ); /// ... If it was replaced before, accumulate counter and /// ... simplify the array refs within the expression if (local_modify_counter) { modify_counter += local_modify_counter; ex = simplify_subs_exprs(ex); } /// ... Put expression back into arg list ex_as = ex; } return modify_counter; } /// Take an expression and map the variables in it from the called routine into /// the caller routine. int InlineObject::remap_expr( Expression ** ex, LambdaInfo & lambda, REF_TYPE ref ) const { int local_modify_counter = 0; while (1) { /// ... Nothing replaced so far bool local_expr_flag = false; *ex = _translate_symbol_refs_expr(*ex, ref, local_expr_flag, &(this->_formal_to_actual)); /// ... If this expression was replaced, remove lambda /// ... calls and check the expression again. if (local_expr_flag) { ++local_modify_counter; *ex = remove_lambda_calls(*ex, lambda); } else break; } return local_modify_counter; } /// Translate formal parameter references (doing simple symbol /// replacement) /// /// This member function should only be called when doing equivalence /// normalization for formal parameters void InlineObject::_translate_symbol_refs_entry(LambdaInfo & lambda) { Statement & s = *lambda.stmt_ref; /// Statement * prev_stmt_ref = s.prev_ref(); /// 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_symbol_refs_mutr(Mutator<Expression>(current_assert.arg_list_guarded()), lambda, IN_REF_EXPR); } } /// Iterate over the formal parameters (if any) if (s.parameters_valid()) { bool modify_flag = false; for (Iterator<Expression> expr_iter = s.parameters_guarded().arg_list(); expr_iter.valid(); ++expr_iter) { Expression & expr = expr_iter.current(); p_assert(expr.op() == ID_OP, "Invalid parameter encountered in _translate_symbol_refs_entry_"); SymRefElem *symbol_ref = _symbol_map.find_ref(expr.symbol()); if (symbol_ref) { /// ... Modify original expression in place modify_flag = true; expr.symbol(*symbol_ref->symref()); } } if (modify_flag) s.build_refs(); } return; } /// Translate symbol references within a statement's expression list using /// the symbol, array, constant and substring maps. void InlineObject::_translate_symbol_refs_stmt(LambdaInfo & lambda, TRANS_CLEANUP_TYPE cleanup) { Statement & s = *lambda.stmt_ref; Statement * prev_stmt_ref = s.prev_ref(); /// ... 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_symbol_refs_mutr(Mutator<Expression>(current_assert.arg_list_guarded()), lambda, 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_symbol_refs_mutr(Mutator<Expression>(s_iter.current().expr), lambda, 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_symbol_refs_mutr(s.iterate_in_exprs_guarded(),lambda, IN_REF_EXPR)) modify_flag = true; if (s.iterate_out_exprs_valid()) { Mutator<Expression> out_mutr = s.iterate_out_exprs_guarded(); if (_translate_symbol_refs_mutr(out_mutr,lambda,OUT_REF_EXPR)) { modify_flag = true; if ((s.stmt_class()==ASSIGNMENT_STMT) && (s.lhs().op()==INTRINSIC_CALL_OP)) fix_alternate_expr(s, _pgm_main); } } if (s.iterate_in_out_exprs_valid() && _translate_symbol_refs_mutr(s.iterate_in_out_exprs_guarded(),lambda, IN_OUT_REF_EXPR)) modify_flag = true; /// ... If body of statement was not modified, return to caller if (!modify_flag) return; /// ... If body of statement was modified by a call which needed /// ... no cleanup, rebuild references and return to caller. if (cleanup != CLEANUP_NEEDED) { s.build_refs(); return; } /// ... If body of statement modified by a call which needed cleanup, /// ... do full cleanup processing Statement *first_stmt_ref; /// ... If precalculation statements were generated by lambda_call /// ... processing, begin cleanup there first. p_assert(prev_stmt_ref, "Replacement done for first statement in StmtList"); if (prev_stmt_ref != s.prev_ref()) { Statement *clean_stmt = prev_stmt_ref->next_ref(); /// ... Point at first statement generated by cleanup of lambda call /// ... precalculation (which might, for example, have had nested /// ... function calls in its RHS). first_stmt_ref = &clean_statement(*_pgm_ref, *clean_stmt); /// ... Clean up any other precalculation statements and the original /// ... statement. for (Iterator<Statement> precalc_stmt_iter = _pgm_ref->stmts().iterator(*clean_stmt->next_ref(), s); precalc_stmt_iter.valid(); ++precalc_stmt_iter) { clean_statement(*_pgm_ref, precalc_stmt_iter.current()); } } else { /// ... If no preculation statements were generated by lambda_call /// ... processing, just clean up the original statement. first_stmt_ref = &clean_statement(*_pgm_ref, s); } /// ... Rebuild statement references s.build_refs(); /// ... Handle precalculation statements (if any) if (first_stmt_ref == &s) return; /// ... Now, do rename and translate processing for cleaned up /// ... precalculation statements RefList<Symbol> rename_list; for (Iterator<Statement> precalc_stmt_iter = _pgm_ref->stmts().iterator(*first_stmt_ref, *s.prev_ref()); precalc_stmt_iter.valid(); ++precalc_stmt_iter) { Statement & precalc_stmt = precalc_stmt_iter.current(); p_assert(precalc_stmt.stmt_class() == ASSIGNMENT_STMT, "Non-assignment statement encountered " "in translate_symbol_refs_stmt"); _remap_variable_symbol(precalc_stmt.lhs().symbol(), rename_list); } /// ... Handle any symbols which need renaming. _remap_variable_symbols(rename_list); /// ... Now, translate these assignment statements for the main program LambdaInfo our_lambda(_pgm_ref, 0, INLINE_CALL); for (Iterator<Statement> trans_stmt_iter = _pgm_ref->stmts().iterator(*first_stmt_ref, *s.prev_ref()); trans_stmt_iter.valid(); ++trans_stmt_iter) { our_lambda.stmt_ref = &trans_stmt_iter.current(); _translate_symbol_refs_stmt(our_lambda, cleanup); } /// ... Finally, recursively retranslate original statement for the main /// ... program /// ... Note that cleanup processing is not needed when retranslating /// ... the original statement our_lambda.stmt_ref = &s; _translate_symbol_refs_stmt(our_lambda, NO_CLEANUP_NEEDED); } /// Translate contained symbol references using the symbol, array /// and constant maps void InlineObject::translate_symbol_refs(TRANS_CLEANUP_TYPE cleanup) { static LambdaInfo lambda(0, 0, INLINE_CALL); lambda.program_ref = _pgm_ref; /// If there is no translation to do, return to caller if ((!_symbol_map.entries()) && (!_constant_map.entries()) && (!_format_map.entries())) return; /// Translate each statement for (Iterator<Statement> stmt_iter = _pgm_ref->stmts().iterator(); stmt_iter.valid(); ++stmt_iter) { Statement & s = stmt_iter.current(); if ((s.stmt_class()!=ENTRY_STMT)) { lambda.stmt_ref = &s; _translate_symbol_refs_stmt(lambda, cleanup); } else if (cleanup == NO_CLEANUP_NEEDED) { lambda.stmt_ref = &s; _translate_symbol_refs_entry(lambda); } } } /* Merge the contained pgm, and any precalculation statements introduced before statement s, into the main program at statement s after doing constant propagation and substitution of simple expressions. recursive indicates that the statements substituted will include RECURSIVE_INLINE assertions, to be evaluated after the substitution. */ /// recursive added (kjackson) Statement & InlineObject::_remap_merge_stmts(Statement & entry_statement, Statement & s, bool recursive) { /// Find the FLOW_ENTRY and FLOW_EXIT Statement &flow_entry = _pgm_ref->stmts().first(); Statement &flow_exit = _pgm_ref->stmts().last(); cout<<"The flow exit statement is "<<endl; flow_exit.print(cout); cout<<endl; /// Save a copy of the list of entry statements for later RefSet<Statement> entry_refset = flow_entry.succ(); /* If this entry doesn't follow the FLOW_ENTRY, more processing is needed. */ if (flow_entry.next_ref() != &entry_statement) { Statement * next_stmt_ref = entry_statement.next_ref(); /// ... Determine where the code is for this entry switch (next_stmt_ref->stmt_class()) { case LABEL_STMT: break; case GOTO_STMT: { next_stmt_ref = next_stmt_ref->target_ref(); break; } default: p_abort("Irregular entry point encountered in _remap_merge_stmts"); } /// ... Branch to this code from the FLOW_ENTRY Statement * goto_stmt = new GotoStmt(_pgm_ref->stmts().new_tag(), next_stmt_ref); _pgm_ref->stmts().ins_after(goto_stmt, &flow_entry); } /// Remove the entry statements from the program _pgm_ref->stmts().del(entry_refset); /// Delete the RETURN statement at the end of the program Statement & routine_exit_stmt = *flow_exit.prev_ref(); cout<<"The routine exit statement is "<<endl; routine_exit_stmt.print(cout); cout<<endl; switch (routine_exit_stmt.stmt_class()) { case STOP_STMT: break; case RETURN_STMT: { _pgm_ref->stmts().del(routine_exit_stmt); break; } default: p_abort("Irregular exit point encountered in _remap_merge_stmts"); } /// Remove all unreachable code and trivial gotos from program remove_unreachable_code(*_pgm_ref); remove_trivial_gotos(*_pgm_ref); RefSet<Symbol> candidate_set; /// If there are candidate precalculation variables saved, traverse /// _symbol_map and add them to candidate_set if (_precalc_vars) { for (KeyIterator<Symbol,SymRefElem> precalc_iter = _symbol_map; precalc_iter.valid(); ++precalc_iter) { SymRefElem & current_ref = precalc_iter.current_data(); if (current_ref.precalc()==CAND_PRECALC_VAR) { Symbol & precalc_symbol = *current_ref.symref(); candidate_set.ins(precalc_symbol); } } } /// Create block entry and exit statements around the existing statements Statement * flow_exit_prev = flow_exit.prev_ref(); if (flow_exit_prev == &flow_entry) flow_exit_prev = 0; _pgm_ref->stmts().ins_BLOCK_after(&flow_entry, flow_exit_prev); Statement * block_entry_stmt = flow_entry.next_ref(); Statement * block_exit_stmt = flow_exit.prev_ref(); /// Put a workspace on the block exit statement so inline driver /// knows it was created here block_exit_stmt->work_stack().push(new InlineWorkSpace(*_ws_ref)); /// Move any assertions from the calling statement onto the BLOCK_ENTRY /// statement. Remember an AssertPrivate for later. Assertion * private_assert_ref = 0; for (Mutator<Assertion> assert_mutr = s.assertions(); assert_mutr.valid(); ++assert_mutr) { Assertion * assert_ref = assert_mutr.grab(); if(assert_ref->type()==AS_PRIVATE) private_assert_ref = assert_ref; block_entry_stmt->assertions().ins_last(assert_ref); } /// Move private variable information into a new private assertion on the /// BLOCK_ENTRY statement if (_private_vars) { if (!private_assert_ref) { private_assert_ref = new AssertPrivate; block_entry_stmt->assertions().ins_last(private_assert_ref); } List<Expression> & private_list = private_assert_ref->arg_list_guarded(); /// ... Iterate over symbol map, processing only private variables for (KeyIterator<Symbol,SymRefElem> private_iter = _symbol_map; private_iter.valid(); ++private_iter) { SymRefElem & current_ref = private_iter.current_data(); if (current_ref.privat()==PRIVATE) { Symbol & private_symbol = *current_ref.symref(); if(private_symbol.is_array()) { // For now, build ArrayRefExpr with bound information for private // arrays (eventually, check switch) Expression * private_subscript = comma(); List<Expression> & private_arg_list = private_subscript->arg_list(); for (Iterator<ArrayBounds>private_bound_iter = private_symbol.dim(); private_bound_iter.valid(); ++private_bound_iter) { ArrayBounds & private_bound = private_bound_iter.current(); Expression * lower_ptr; if(private_bound.lower_exists()) lower_ptr = private_bound.lower_guarded().clone(); else lower_ptr = constant(1); Expression * upper_ptr; if(private_bound.upper_exists()) upper_ptr = private_bound.upper_guarded().clone(); else upper_ptr = constant(1); private_arg_list.ins_last(colon(lower_ptr, upper_ptr, NULL)); } private_list.ins_last(array_reference(id(private_symbol), private_subscript)); } else private_list.ins_last(id(private_symbol)); } } } /// Move any test expressions for subscripts into an assertion /// on the BLOCK_ENTRY statement if (_test_exprs.entries()) { AssertRelation * test_exprs_ref = new AssertRelation; List<Expression> & expr_args = test_exprs_ref->arg_list_guarded(); for (Mutator<Expression> test_mutr = _test_exprs; test_mutr.valid(); ++test_mutr) expr_args.ins_last(test_mutr.grab()); block_entry_stmt->assertions().ins_last(test_exprs_ref); } /* Clone InlineWorkSpace from inlined program to the BLOCK_ENTRY statement. (beginning of commented out code) InlineWorkSpace * inline_ws_ptr = 0; if (_ws_ref->count_active()) { InlineWorkSpace & inline_ref = *(InlineWorkSpace *)_pgm_ref->work_stack().top_ref(_ws_ref->pass_tag()); inline_ws_ptr = new InlineWorkSpace(inline_ref); block_entry_stmt->work_stack().push(inline_ws_ptr); } (end of commented out code) */ /// If debugging is on, move in comments around region if (_debug_flag) { AssertComment * begin_comment_ref = new AssertComment; List<StringElem> & begin_args = begin_comment_ref->string_arg_list_guarded(); for (Mutator<StringElem> begin_mutr = _begin_comment_list; begin_mutr.valid(); ++begin_mutr) begin_args.ins_last(begin_mutr.grab()); block_entry_stmt->assertions().ins_last(begin_comment_ref); AssertComment * end_comment_ref = new AssertComment; List<StringElem> & end_args = end_comment_ref->string_arg_list_guarded(); for (Mutator<StringElem> end_mutr = _end_comment_list; end_mutr.valid(); ++end_mutr) end_args.ins_last(end_mutr.grab()); block_exit_stmt->assertions().ins_last(end_comment_ref); } /// Remember statement after s for later insert of inlined code Statement * caller_next_ref = s.next_ref(); /// Check statements preceding s in the main program for /// precalculation variables generated by clean_statement Statement * precalc_ref = s.prev_ref(); Statement * first_precalc_ref = 0; while (precalc_ref && (precalc_ref->stmt_class() == ASSIGNMENT_STMT) && (precalc_ref->lhs().op()==ID_OP) && (strncmp(precalc_ref->lhs().symbol().name_ref(),"PC",2) == 0)) { first_precalc_ref = precalc_ref; Symbol & precalc_symbol = precalc_ref->lhs().symbol(); const Type & precalc_type = precalc_symbol.type(); /// ... If variable is an integer scalar, add it to the candidate list if ((precalc_type.data_type() == INTEGER_TYPE) && (precalc_type.is_scalar())) candidate_set.ins(precalc_symbol); precalc_ref = precalc_ref->prev_ref(); } /// If any precalculation statements were found, grab them and add /// them to the subprogram if (first_precalc_ref) { Statement & first_precalc_stmt = *first_precalc_ref; /// ... Statement * prev_first_precalc_stmt = first_precalc_stmt.prev_ref(); Statement & last_precalc_stmt = *s.prev_ref(); StmtList & main_stmts = _pgm_main.stmts(); List<Statement> * precalc_block = main_stmts.grab(first_precalc_stmt, last_precalc_stmt, DONT_RELABEL); _pgm_ref->stmts().ins_after(precalc_block, &flow_entry); } if (candidate_set.entries()) { /// ... Propagate the candidate variables if possible propagate_constants(*_pgm_ref, candidate_set, REMOVE_UNREACH_CODE); /// ... Accept small substitutions expand_small_substituted(*_pgm_ref); /// ... Clear any leftover substitutions clear_substituted(*_pgm_ref); } /// Remember return statement value Statement *first_stmt_ref = flow_entry.next_ref(); /// Grab the statements between FLOW_ENTRY and FLOW_EXIT (if any) List<Statement> *grabbed_block = _pgm_ref->stmts().grab(*first_stmt_ref, *flow_exit.prev_ref(), DONT_RELABEL); /* Count statements for the inline workspace (beginning of commented out code) if (inline_ws_ptr) { inline_ws_ptr->exec_lines_output(count_stmts(*grabbed_block)); inline_ws_ptr->total_lines_output(grabbed_block->entries()); } (end of commented out code) */ /// Delete original calling statment _pgm_main.stmts().del(s); /// Add to main program _pgm_main.stmts().ins_before(grabbed_block, caller_next_ref); /// BEGIN ADDED SECTION (kjackson) /// ... if this is a RECURSIVE_INLINE instance, search for any call /// ... statements to which this assertion will be added if (recursive) { Iterator<Statement> stmt_iter(_pgm_main.stmts(), block_entry_stmt, block_exit_stmt); for (; stmt_iter.valid(); ++stmt_iter) { Statement & s_here = stmt_iter.current(); STMT_TYPE stype = s_here.stmt_class(); switch (stype) { /// ... Do not process assignment statement if it does not have /// ... a function call expr as its rhs case ASSIGNMENT_STMT: case CALL_STMT: if ((stype != ASSIGNMENT_STMT) || (s_here.rhs().op() == FUNCTION_CALL_OP)) { bool assert_noinline = false; bool no_assertions = true; for (Iterator<Assertion> assert_iter = s_here.assertions(); assert_iter.valid(); ++assert_iter) { AssertionType current_type = assert_iter.current().type(); if (current_type==AS_NOINLINE) { no_assertions = false; assert_noinline = true; } else if ((current_type == AS_INLINE) || (current_type == AS_RECURSIVEINLINE)) { no_assertions = false; } } if (!assert_noinline) { Assertion * s_here_assert = new AssertRecursiveInline; s_here.assertions().ins_last(s_here_assert); } } break; default: break; } } } /// END ADDED SECTION (kjackson) /// Return a reference to the first inlined statement return *first_stmt_ref; } /// Inline expansion of program represented by the InlineObject into the /// main program referred to by the InlineObject at statement s. /// recursive indicates if this is a RECURSIVE_INLINE expansion /// recursive added (kjackson) Statement & InlineObject::inline_expand(Statement & s, bool recursive) { static String debug_switch("inline_debug"); _debug_flag = switch_value(debug_switch); if (_debug_flag > 9) { int i = 0; cerr << "Inliner called to substitute the following statement:\n "; s.write(cerr, i); cerr.flush(); } /// ... If first inlining, make permanent changes if (!_permanent_changes) { float_entry_points(*_pgm_ref); sink_return_points(*_pgm_ref); _remap_local_variables(); _precalc_adjustable_array_bounds(); prepare_routines_for_arg_mapping(); _remap_local_variables(); _remap_and_move_formats(); _permanent_changes = true; } /// ... Allocate work InlineObject from saved one InlineObject proto_work(*this); /// ... Rename branch targets proto_work._rename_branch_targets(); /// ... Remap argument uses Statement & entry_statement = proto_work._remap_arg_uses(s); /// ... Translate symbol references proto_work.translate_symbol_refs(CLEANUP_NEEDED); /// ... Merge pgm_work into main program, adding RECURSIVE_INLINE assertions /// ... to appropriate statements if necessary (kjackson) Statement & t = proto_work._remap_merge_stmts(entry_statement, s, recursive); /// ... substitute any parameters which may have been inlined substitute_parameters(_pgm_main, IGNORE_REALS); /// ... Return insertion point ref to caller return t; } void InlineObject::prepare_routines_for_arg_mapping() { substitute_parameters(*_pgm_ref, IGNORE_REALS); /// _precalc_adjustable_array_bounds(); Moved back to inline_expand() _expand_IO_array_names(); _remap_common_blocks(); _remap_equivalences(); _remap_and_move_data(); } void InlineObject::_insert_arg_mapping( Symbol & formal, Expression * actual, AbstractAccess * aa) { _formal_to_actual.ins(formal, actual); if (aa) { _formal_to_access_region.ins(formal, aa); } } const Expression * InlineObject::actual_arg(const Symbol & formal) const { return _formal_to_actual.find_ref(formal); } const AbstractAccess * InlineObject::access_region( const Symbol & formal) const { return _formal_to_access_region.find_ref(formal); }

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