// Note: This function is currently not recursive
static bool inferConst(Symbol* sym) {
INT_ASSERT(!sym->isRef());
const bool wasConstVal = sym->qualType().getQual() == QUAL_CONST_VAL;
ConstInfo* info = infoMap[sym];
// 'info' may be null if the argument is never used. In that case we can
// consider 'sym' to be a const-ref. By letting the rest of the function
// proceed, we'll fix up the qualifier for such symbols at the end.
if (info == NULL) {
return true;
} else if (info->finalizedConstness || wasConstVal) {
return wasConstVal;
}
bool isConstVal = true;
int numDefs = 0;
while (info->hasMore() && isConstVal) {
SymExpr* use = info->next();
CallExpr* call = toCallExpr(use->parentExpr);
if (call == NULL) {
// Could be a DefExpr, or the condition for a while loop.
// BHARSH: I'm not sure of all the possibilities
continue;
}
CallExpr* parent = toCallExpr(call->parentExpr);
if (call->isResolved()) {
ArgSymbol* form = actual_to_formal(use);
//
// If 'sym' is constructed through a _retArg, we can consider that to
// be a single 'def'.
//
if (form->hasFlag(FLAG_RETARG)) {
numDefs += 1;
}
else if (form->isRef()) {
if (!inferConstRef(form)) {
isConstVal = false;
}
}
}
else if (parent && isMoveOrAssign(parent)) {
if (call->isPrimitive(PRIM_ADDR_OF) ||
call->isPrimitive(PRIM_SET_REFERENCE)) {
Symbol* LHS = toSymExpr(parent->get(1))->symbol();
INT_ASSERT(LHS->isRef());
if (onlyUsedForRetarg(LHS, parent)) {
numDefs += 1;
}
else if (!inferConstRef(LHS)) {
isConstVal = false;
}
}
}
else if (isMoveOrAssign(call)) {
if (use == call->get(1)) {
numDefs += 1;
}
} else {
// To be safe, exit the loop with 'false' if we're unsure of how to
// handle a primitive.
isConstVal = false;
}
if (numDefs > 1) {
isConstVal = false;
}
}
if (isConstVal && !info->finalizedConstness) {
if (ArgSymbol* arg = toArgSymbol(sym)) {
INT_ASSERT(arg->intent & INTENT_FLAG_IN);
arg->intent = INTENT_CONST_IN;
} else {
INT_ASSERT(isVarSymbol(sym));
sym->qual = QUAL_CONST_VAL;
}
}
info->reset();
info->finalizedConstness = true;
return isConstVal;
}
//
// Returns 'true' if 'sym' is (or should be) a const-ref.
// If 'sym' can be a const-ref, but is not, this function will change either
// the intent or qual of the Symbol to const-ref.
//
static bool inferConstRef(Symbol* sym) {
INT_ASSERT(sym->isRef());
bool wasConstRef = sym->qualType().getQual() == QUAL_CONST_REF;
if (sym->defPoint->parentSymbol->hasFlag(FLAG_EXTERN)) {
return wasConstRef;
}
ConstInfo* info = infoMap[sym];
// 'info' may be null if the argument is never used. In that case we can
// consider 'sym' to be a const-ref. By letting the rest of the function
// proceed, we'll fix up the qualifier for such symbols at the end.
if (info == NULL) {
return true;
} else if (info->finalizedConstness || wasConstRef) {
return wasConstRef;
}
bool isFirstCall = false;
if (info->alreadyCalled == false) {
isFirstCall = true;
info->alreadyCalled = true;
}
bool isConstRef = true;
while (info->hasMore() && isConstRef) {
SymExpr* use = info->next();
CallExpr* call = toCallExpr(use->parentExpr);
INT_ASSERT(call);
CallExpr* parent = toCallExpr(call->parentExpr);
if (call->isResolved()) {
ArgSymbol* form = actual_to_formal(use);
if (form->isRef() && !inferConstRef(form)) {
isConstRef = false;
}
}
else if (parent && isMoveOrAssign(parent)) {
if (!canRHSBeConstRef(parent, use)) {
isConstRef = false;
}
}
else if (call->isPrimitive(PRIM_MOVE)) {
//
// Handles three cases:
// 1) MOVE use value - writing to a reference, so 'use' cannot be const
// 2) MOVE ref use - if the LHS is not const, use cannot be const either
// 3) MOVE value use - a dereference of 'use'
//
if (use == call->get(1)) {
// CASE 1
if (!call->get(2)->isRef()) {
isConstRef = false;
}
} else {
// 'use' is the RHS of a MOVE
if (call->get(1)->isRef()) {
// CASE 2
SymExpr* se = toSymExpr(call->get(1));
INT_ASSERT(se);
if (!inferConstRef(se->symbol())) {
isConstRef = false;
}
}
// else CASE 3: do nothing because isConstRef is already true
}
}
else if (call->isPrimitive(PRIM_ASSIGN)) {
if (use == call->get(1)) {
isConstRef = false;
}
}
else if (call->isPrimitive(PRIM_SET_MEMBER) ||
call->isPrimitive(PRIM_SET_SVEC_MEMBER)) {
// BHARSH 2016-11-02
// In the expr (set_member base member rhs),
// If use == base, I take the conservative approach and decide that 'use'
// is not a const-ref. I'm not sure that we've decided what const means
// for fields yet, so this seems safest.
//
// If use == rhs, then we would need to do analysis for the member field.
// That's beyond the scope of what I'm attempting at the moment, so to
// be safe we'll return false for that case.
if (use == call->get(1) || use == call->get(3)) {
isConstRef = false;
} else {
// use == member
// If 'rhs' is not a ref, then we're writing into 'use'. Otherwise it's
// a pointer copy and we don't care if 'rhs' is writable.
if (!call->get(3)->isRef()) {
isConstRef = false;
}
}
} else {
// To be safe, exit the loop with 'false' if we're unsure of how to
// handle a primitive.
isConstRef = false;
}
}
if (isFirstCall) {
if (isConstRef) {
INT_ASSERT(info->finalizedConstness == false);
if (ArgSymbol* arg = toArgSymbol(sym)) {
arg->intent = INTENT_CONST_REF;
} else {
INT_ASSERT(isVarSymbol(sym));
sym->qual = QUAL_CONST_REF;
}
}
info->reset();
info->finalizedConstness = true;
} else if (!isConstRef) {
info->finalizedConstness = true;
}
return isConstRef;
}
