//
// inlines the function called by 'call' at that call site
//
static void
inlineCall(FnSymbol* fn, CallExpr* call, Vec<FnSymbol*>& canRemoveRefTempSet) {
INT_ASSERT(call->isResolved() == fn);
SET_LINENO(call);
Expr* stmt = call->getStmtExpr();
//
// calculate a map from actual symbols to formal symbols
//
SymbolMap map;
for_formals_actuals(formal, actual, call) {
SymExpr* se = toSymExpr(actual);
INT_ASSERT(se);
if ((formal->intent & INTENT_REF) && canRemoveRefTempSet.set_in(fn)) {
if (se->var->hasFlag(FLAG_REF_TEMP)) {
if (CallExpr* move = findRefTempInit(se)) {
SymExpr* origSym = NULL;
if (CallExpr* addrOf = toCallExpr(move->get(2))) {
INT_ASSERT(addrOf->isPrimitive(PRIM_ADDR_OF));
origSym = toSymExpr(addrOf->get(1));
} else {
origSym = toSymExpr(move->get(2));
}
INT_ASSERT(origSym);
map.put(formal, origSym->var);
se->var->defPoint->remove();
move->remove();
continue;
}
}
}
map.put(formal, se->var);
}
static void addDefAndMap(Expr* aInit, SymbolMap& map, ShadowVarSymbol* svar,
VarSymbol* currVar)
{
if (currVar->type == dtNothing) {
INT_ASSERT(currVar->firstSymExpr() == NULL);
return;
}
aInit->insertBefore(new DefExpr(currVar));
map.put(svar, currVar);
}
//
// inlines the function called by 'call' at that call site
//
static void
inlineCall(FnSymbol* fn, CallExpr* call) {
INT_ASSERT(call->isResolved() == fn);
SET_LINENO(call);
Expr* stmt = call->getStmtExpr();
//
// calculate a map from actual symbols to formal symbols
//
SymbolMap map;
for_formals_actuals(formal, actual, call) {
SymExpr* se = toSymExpr(actual);
INT_ASSERT(se);
map.put(formal, se->var);
}
static void
findOuterVars(FnSymbol* fn, SymbolMap& uses) {
std::vector<BaseAST*> asts;
collect_asts(fn, asts);
for_vector(BaseAST, ast, asts) {
if (SymExpr* symExpr = toSymExpr(ast)) {
Symbol* sym = symExpr->symbol();
if (isLcnSymbol(sym)) {
if (!isCorrespCoforallIndex(fn, sym) && isOuterVar(sym, fn))
uses.put(sym, markUnspecified);
}
}
}
}
CallExpr* ParamForLoop::foldForResolve()
{
SymExpr* idxExpr = indexExprGet();
SymExpr* lse = lowExprGet();
SymExpr* hse = highExprGet();
SymExpr* sse = strideExprGet();
if (!lse || !hse || !sse)
USR_FATAL(this, "param for loop must be defined over a bounded param range");
VarSymbol* lvar = toVarSymbol(lse->var);
VarSymbol* hvar = toVarSymbol(hse->var);
VarSymbol* svar = toVarSymbol(sse->var);
CallExpr* noop = new CallExpr(PRIM_NOOP);
if (!lvar || !hvar || !svar)
USR_FATAL(this, "param for loop must be defined over a bounded param range");
if (!lvar->immediate || !hvar->immediate || !svar->immediate)
USR_FATAL(this, "param for loop must be defined over a bounded param range");
Symbol* idxSym = idxExpr->var;
Symbol* continueSym = continueLabelGet();
Type* idxType = indexType();
IF1_int_type idxSize = (get_width(idxType) == 32) ? INT_SIZE_32 : INT_SIZE_64;
// Insert an "insertion marker" for loop unrolling
insertAfter(noop);
if (is_int_type(idxType))
{
int64_t low = lvar->immediate->to_int();
int64_t high = hvar->immediate->to_int();
int64_t stride = svar->immediate->to_int();
if (stride <= 0)
{
for (int64_t i = high; i >= low; i += stride)
{
SymbolMap map;
map.put(idxSym, new_IntSymbol(i, idxSize));
copyBodyHelper(noop, i, &map, this, continueSym);
}
}
else
{
for (int64_t i = low; i <= high; i += stride)
{
SymbolMap map;
map.put(idxSym, new_IntSymbol(i, idxSize));
copyBodyHelper(noop, i, &map, this, continueSym);
}
}
}
else
{
INT_ASSERT(is_uint_type(idxType) || is_bool_type(idxType));
uint64_t low = lvar->immediate->to_uint();
uint64_t high = hvar->immediate->to_uint();
int64_t stride = svar->immediate->to_int();
if (stride <= 0)
{
for (uint64_t i = high; i >= low; i += stride)
{
SymbolMap map;
map.put(idxSym, new_UIntSymbol(i, idxSize));
copyBodyHelper(noop, i, &map, this, continueSym);
}
}
else
{
for (uint64_t i = low; i <= high; i += stride)
{
SymbolMap map;
map.put(idxSym, new_UIntSymbol(i, idxSize));
copyBodyHelper(noop, i, &map, this, continueSym);
}
}
}
// Remove the "insertion marker"
noop->remove();
// Replace the paramLoop with the NO-OP
replace(noop);
return noop;
}