ForLoop* ForLoop::copy(SymbolMap* mapRef, bool internal)
{
SymbolMap localMap;
SymbolMap* map = (mapRef != 0) ? mapRef : &localMap;
ForLoop* retval = new ForLoop();
retval->astloc = astloc;
retval->blockTag = blockTag;
retval->mBreakLabel = mBreakLabel;
retval->mContinueLabel = mContinueLabel;
retval->mOrderIndependent = mOrderIndependent;
retval->mIndex = mIndex->copy(map, true),
retval->mIterator = mIterator->copy(map, true);
retval->mZippered = mZippered;
for_alist(expr, body)
retval->insertAtTail(expr->copy(map, true));
if (internal == false)
update_symbols(retval, map);
return retval;
}
BlockStmt* ForLoop::buildForLoop(Expr* indices,
Expr* iteratorExpr,
BlockStmt* body,
bool coforall,
bool zippered)
{
VarSymbol* index = newTemp("_indexOfInterest");
VarSymbol* iterator = newTemp("_iterator");
CallExpr* iterInit = 0;
CallExpr* iterMove = 0;
ForLoop* loop = new ForLoop(index, iterator, body, zippered);
LabelSymbol* continueLabel = new LabelSymbol("_continueLabel");
LabelSymbol* breakLabel = new LabelSymbol("_breakLabel");
BlockStmt* retval = new BlockStmt();
iterator->addFlag(FLAG_EXPR_TEMP);
// Unzippered loop, treat all objects (including tuples) the same
if (zippered == false)
iterInit = new CallExpr(PRIM_MOVE, iterator, new CallExpr("_getIterator", iteratorExpr));
// Expand tuple to a tuple containing appropriate iterators for each value.
else
iterInit = new CallExpr(PRIM_MOVE, iterator, new CallExpr("_getIteratorZip", iteratorExpr));
// try to optimize anonymous range iteration, replaces iterExpr in place
optimizeAnonymousRangeIteration(iteratorExpr, zippered);
index->addFlag(FLAG_INDEX_OF_INTEREST);
iterMove = new CallExpr(PRIM_MOVE, index, new CallExpr("iteratorIndex", iterator));
if (indices == 0)
indices = new UnresolvedSymExpr("chpl__elidedIdx");
checkIndices(indices);
destructureIndices(loop, indices, new SymExpr(index), coforall);
if (coforall)
index->addFlag(FLAG_COFORALL_INDEX_VAR);
loop->mContinueLabel = continueLabel;
loop->mBreakLabel = breakLabel;
loop->insertAtTail(new DefExpr(continueLabel));
retval->insertAtTail(new DefExpr(index));
retval->insertAtTail(new DefExpr(iterator));
retval->insertAtTail(iterInit);
retval->insertAtTail(new BlockStmt(iterMove, BLOCK_TYPE));
retval->insertAtTail(loop);
retval->insertAtTail(new DefExpr(breakLabel));
retval->insertAtTail(new CallExpr("_freeIterator", iterator));
return retval;
}
ForLoop::ForLoop( const ForLoop& l ) :
BasicNode(LOOPHEAD), myLoop(l.get_loop()), myLoopType(UNDEFINED), symbol(l.get_symbol()),
start(l.get_start()), end(l.get_end()), body(NULL), out(NULL), Iter(false)
{
back_edge = new ForLoop(start,end,symbol,myLoop,this,this,LOOPTAIL);
body = back_edge;
}
ForLoop * RoseCloog::unparse_clast_for( struct clast_for * f ) const
{
SgExpression * start = unparse_clast_expr(f->LB);
SgExpression * end = unparse_clast_expr(f->UB);
string sym = charToString(f->iterator);
ForLoop * loop = new ForLoop(start,end,sym);
FlowGraph * tempGraph = unparse_clast(f->body);
tempGraph->is_temp();
loop->set_body( tempGraph );
delete(tempGraph);
return loop;
}
BlockStmt* ForLoop::buildForLoop(Expr* indices,
Expr* iteratorExpr,
BlockStmt* body,
bool coforall,
bool zippered)
{
VarSymbol* index = newTemp("_indexOfInterest");
VarSymbol* iterator = newTemp("_iterator");
CallExpr* iterInit = 0;
CallExpr* iterMove = 0;
ForLoop* loop = new ForLoop(index, iterator, body, zippered);
LabelSymbol* continueLabel = new LabelSymbol("_continueLabel");
LabelSymbol* breakLabel = new LabelSymbol("_breakLabel");
BlockStmt* retval = new BlockStmt();
iterator->addFlag(FLAG_EXPR_TEMP);
// Unzippered loop, treat all objects (including tuples) the same
if (zippered == false) {
iterInit = new CallExpr(PRIM_MOVE, iterator, new CallExpr("_getIterator", iteratorExpr));
// try to optimize anonymous range iteration
tryToReplaceWithDirectRangeIterator(iteratorExpr);
}
// Zippered loop: Expand args to a tuple with an iterator for each element.
else {
CallExpr* zipExpr = toCallExpr(iteratorExpr);
if (zipExpr && zipExpr->isPrimitive(PRIM_ZIP)) {
// The PRIM_ZIP indicates this is a new-style zip() AST.
// Expand arguments to a tuple with appropriate iterators for each value.
//
// Specifically, change:
// zip(a, b, c, ...)
// into the tuple:
// (_getIterator(a), _getIterator(b), _getIterator(c), ...)
//
// (ultimately, we will probably want to make this style of
// rewrite into a utility function for the other get*Zip
// functions as we convert parallel loops over to use PRIM_ZIP).
//
zipExpr->primitive = NULL; // remove the primitive
// If there's just one argument...
if (zipExpr->argList.length == 1) {
Expr* zipArg = zipExpr->argList.only();
CallExpr* zipArgCall = toCallExpr(zipArg);
// ...and it is a tuple expansion '(...t)' then remove the
// tuple expansion primitive and simply pass the tuple itself
// to _getIteratorZip(). This will not require any more
// tuples than the user introduced themselves.
//
if (zipArgCall && zipArgCall->isPrimitive(PRIM_TUPLE_EXPAND)) {
zipExpr->baseExpr = new UnresolvedSymExpr("_getIteratorZip");
Expr* tupleArg = zipArgCall->argList.only();
tupleArg->remove();
zipArgCall->replace(tupleArg);
} else {
// ...otherwise, make the expression into a _getIterator()
// call
zipExpr->baseExpr = new UnresolvedSymExpr("_getIterator");
// try to optimize anonymous range iteration
tryToReplaceWithDirectRangeIterator(zipArg);
}
} else {
//
// Otherwise, if there's more than one argument, build up the
// tuple by applying _getIterator() to each element.
//
zipExpr->baseExpr = new UnresolvedSymExpr("_build_tuple");
Expr* arg = zipExpr->argList.first();
while (arg) {
Expr* next = arg->next;
Expr* argCopy = arg->copy();
arg->replace(new CallExpr("_getIterator", argCopy));
// try to optimize anonymous range iteration
tryToReplaceWithDirectRangeIterator(argCopy);
arg = next;
}
}
iterInit = new CallExpr(PRIM_MOVE, iterator, zipExpr);
assert(zipExpr == iteratorExpr);
} else {
//
// This is an old-style zippered loop so handle it in the old style
//
iterInit = new CallExpr(PRIM_MOVE, iterator,
new CallExpr("_getIteratorZip", iteratorExpr));
// try to optimize anonymous range iteration
if (CallExpr* call = toCallExpr(iteratorExpr))
if (call->isNamed("_build_tuple"))
for_actuals(actual, call)
tryToReplaceWithDirectRangeIterator(actual);
}
}
index->addFlag(FLAG_INDEX_OF_INTEREST);
iterMove = new CallExpr(PRIM_MOVE, index, new CallExpr("iteratorIndex", iterator));
if (indices == 0)
indices = new UnresolvedSymExpr("chpl__elidedIdx");
checkIndices(indices);
destructureIndices(loop, indices, new SymExpr(index), coforall);
if (coforall)
index->addFlag(FLAG_COFORALL_INDEX_VAR);
loop->mContinueLabel = continueLabel;
loop->mBreakLabel = breakLabel;
loop->insertAtTail(new DefExpr(continueLabel));
retval->insertAtTail(new DefExpr(index));
retval->insertAtTail(new DefExpr(iterator));
retval->insertAtTail(iterInit);
retval->insertAtTail(new BlockStmt(iterMove, BLOCK_TYPE));
retval->insertAtTail(loop);
retval->insertAtTail(new DefExpr(breakLabel));
retval->insertAtTail(new CallExpr("_freeIterator", iterator));
return retval;
}
