自学教程：C++ toCallExpr函数代码示例

/* * Attempts to replace iteration over simple anonymous ranges with calls to * direct iterators that take low, high and stride as arguments. This is to * avoid the cost of constructing ranges, and if the stride is known at compile * time, provide a more optimized iterator that uses "<, <=, >, or >=" as the * relational operator. * * This is only meant to replace anonymous range iteration for "simple" bounded * ranges. Simple means it's a range of the form "low..high" or "low..high by * stride". Anything more complex is ignored with the thinking that this should * optimize the most common range iterators, but it could be expanded to handle * more cases. * * An alternative is to update scalar replacement of aggregates to work on * ranges, which should be able to achieve similar results as this optimization * while handling all ranges, including non-anonymous ranges. * * Will optimize things like: * - "for i in 1..10" * - "for i in 1..10+1" * - "var lo=1, hi=10;for i in lo..hi" * - "for i in 1..10 by 2" * - "for (i, j) in zip(1..10 by 2, 1..10 by -2)" * - "for (i, j) in zip(A, 1..10 by 2)" // will optimize range iter still * - "coforall i in 1..10 by 2"         // works for coforalls as well * * Will not optimize ranges like: * - "for in in (1..)"             // doesn't handle unbounded ranges * - "for i in 1..10 by 2 by 2"    // doesn't handle more than one by operator * - "for i in 1..10 align 2"      // doesn't handle align operator * - "for i in 1..#10"             // doesn't handle # operator * - "var r = 1..10"; for i in r"  // not an anonymous range * - "forall i in 1..10"           // does not get applied to foralls * * Note that this function is pretty fragile because it relies on names of * functions/iterators as well as the arguments and order of those * functions/iterators but there's not really a way around it this early in * compilation. If the iterator can't be replaced, it is left unchanged. */static void tryToReplaceWithDirectRangeIterator(Expr* iteratorExpr){  CallExpr* range = NULL;  Expr* stride = NULL;  if (CallExpr* call = toCallExpr(iteratorExpr))  {    // grab the stride if we have a strided range    if (call->isNamed("chpl_by"))    {      range = toCallExpr(call->get(1)->copy());      stride = toExpr(call->get(2)->copy());    }    // assume the call is the range (checked below) and set default stride    else    {      range = call;      stride = new SymExpr(new_IntSymbol(1));    }    // see if we're looking at a builder for a bounded range. the builder is    // iteratable since range has these() iterators    if (range && range->isNamed("chpl_build_bounded_range"))    {      // replace the range construction with a direct range iterator      Expr* low = range->get(1)->copy();      Expr* high = range->get(2)->copy();      iteratorExpr->replace(new CallExpr("chpl_direct_range_iter", low, high, stride));    }  }}

  forv_Vec(DefExpr, def, gDefExprs) {    if (toVarSymbol(def->sym)) {      // The test for FLAG_TEMP allows compiler-generated (temporary) variables      // to be declared without an explicit type or initializer expression.      if ((!def->init || def->init->isNoInitExpr())          && !def->exprType && !def->sym->hasFlag(FLAG_TEMP))        if (isBlockStmt(def->parentExpr) && !isArgSymbol(def->parentSymbol))          if (def->parentExpr != rootModule->block && def->parentExpr != stringLiteralModule->block)            if (!def->sym->hasFlag(FLAG_INDEX_VAR))              USR_FATAL_CONT(def->sym,                             "Variable '%s' is not initialized or has no type",                             def->sym->name);    }    //    // This test checks to see if query domains (e.g., '[?D]') are    // used in places other than formal argument type specifiers.    //    if (!isFnSymbol(def->parentSymbol)) {      if (CallExpr* type = toCallExpr(def->exprType)) {        if (type->isNamed("chpl__buildArrayRuntimeType")) {          if (CallExpr* domainExpr = toCallExpr(type->get(1))) {            DefExpr* queryDomain = toDefExpr(domainExpr->get(1));            if (queryDomain) {              USR_FATAL_CONT(queryDomain,                             "Domain query expressions may currently only be used in formal argument types");            }          }        }      }    }    checkPrivateDecls(def);  }

// Determines if the expression is in the header of a Loop expression//// After normalization, the conditional test for a WhileStmt is expressed as// a SymExpr inside a primitive CallExpr.//// The init, test, incr clauses of a C-For loop are expressed as BlockStmts// that contain the relevant expressions.  This function only returns true// for the expressions inside the BlockStmt and not the BlockStmt itself//// TODO should this be updated to only look for exprs in the test segment that// are conditional primitives?//static bool isInLoopHeader(Expr* expr) {  bool retval = false;  if (expr->parentExpr == NULL) {    retval = false;  } else if (CallExpr* call = toCallExpr(expr->parentExpr)) {    if (call->isPrimitive(PRIM_BLOCK_WHILEDO_LOOP) ||        call->isPrimitive(PRIM_BLOCK_DOWHILE_LOOP)) {      retval = true;    }  } else if (expr->parentExpr->parentExpr == NULL) {    retval = false;  } else if (CallExpr* call = toCallExpr(expr->parentExpr->parentExpr)) {    if (call->isPrimitive(PRIM_BLOCK_C_FOR_LOOP))      retval = true;  } else {    retval = false;  }  return retval;}

void BlockStmt::replaceChild(Expr* old_ast, Expr* new_ast) {  if (old_ast == blockInfo)    blockInfo = toCallExpr(new_ast);  else if (old_ast == modUses)    modUses = toCallExpr(new_ast);  else    INT_FATAL(this, "Unexpected case in BlockStmt::replaceChild");}

// Insert pairs into available copies map// Also, record references when they are created.static void extractReferences(Expr* expr,                              RefMap& refs){  // We're only interested in call expressions.  if (CallExpr* call = toCallExpr(expr))  {    // Only the move primitive creates an available pair.    if (call->isPrimitive(PRIM_MOVE) || call->isPrimitive(PRIM_ASSIGN))    {      SymExpr* lhe = toSymExpr(call->get(1)); // Left-Hand Expression      Symbol* lhs = lhe->var; // Left-Hand Symbol      if (SymExpr* rhe = toSymExpr(call->get(2))) // Right-Hand Expression      {        Symbol* rhs = rhe->var; // Right-Hand Symbol        if (lhs->type->symbol->hasFlag(FLAG_REF) &&            rhs->type->symbol->hasFlag(FLAG_REF))        {          // This is a ref <- ref assignment.          // Which means that the lhs is now also a reference to whatever the          // rhs refers to.          RefMap::iterator refDef = refs.find(rhs);          // Refs can come from outside the function (e.g. through arguments),          // so are not necessarily defined within the function.          if (refDef != refs.end())          {            Symbol* val = refDef->second;#if DEBUG_CP            if (debug > 0)              printf("Creating ref (%s[%d], %s[%d])/n",                     lhs->name, lhs->id, val->name, val->id);#endif            refs.insert(RefMapElem(lhs, val));          }        }      }      if (CallExpr* rhc = toCallExpr(call->get(2)))      {        if (rhc->isPrimitive(PRIM_ADDR_OF))        {          SymExpr* rhe = toSymExpr(rhc->get(1));          // Create the pair lhs <- &rhs.          Symbol* lhs = lhe->var;          Symbol* rhs = rhe->var;#if DEBUG_CP          if (debug > 0)            printf("Creating ref (%s[%d], %s[%d])/n",                   lhs->name, lhs->id, rhs->name, rhs->id);#endif          refs.insert(RefMapElem(lhs, rhs));        }      }    }  }}

void collectMyCallExprs(BaseAST* ast, Vec<CallExpr*>& callExprs,                        FnSymbol* parent_fn) {  AST_CHILDREN_CALL(ast, collectMyCallExprs, callExprs, parent_fn);  if (CallExpr* callExpr = toCallExpr(ast))    if (callExpr->parentSymbol == parent_fn)      callExprs.add(callExpr);}

static voidview_ast(BaseAST* ast, bool number = false, int mark = -1, int indent = 0) {  if (!ast)    return;  if (Expr* expr = toExpr(ast)) {    printf("/n");    for (int i = 0; i < indent; i++)      printf(" ");    printf("(");    if (ast->id == mark)      printf("***");    if (number)      printf("%d ", ast->id);    printf("%s", expr->astTagAsString());    if (isBlockStmt(expr))      if (FnSymbol* fn = toFnSymbol(expr->parentSymbol))        if (expr == fn->where)          printf(" where");    if (GotoStmt *gs= toGotoStmt(ast)) {      printf( " ");      view_ast(gs->label, number, mark, indent+1);    }    if (CallExpr* call = toCallExpr(expr))      if (call->primitive)        printf(" %s", call->primitive->name);    if (NamedExpr* named = toNamedExpr(expr))      printf(" /"%s/"", named->name);    if (toDefExpr(expr))      printf(" ");    int64_t i;    const char *str;    if (get_int(expr, &i)) {      printf(" %" PRId64, i);    } else if (get_string(expr, &str)) {      printf(" /"%s/"", str);    }    if (SymExpr* sym = toSymExpr(expr)) {      printf(" ");      view_sym(sym->var, number, mark);    } else if (UnresolvedSymExpr* sym = toUnresolvedSymExpr(expr)) {      printf(" '%s'", sym->unresolved);    }  }  if (Symbol* sym = toSymbol(ast)) {    view_sym(sym, number, mark);  }  AST_CHILDREN_CALL(ast, view_ast, number, mark, indent+2);  if (toExpr(ast))    printf(")");}

//// Returns true if 'ref' is only used in the following cases:////   1) Used in 'defCall', usually a PRIM_ADDR_OF or PRIM_SET_REFERENCE////   2) Passed to an initializer in the 'this' slot.////   3) Initialized from a function call, as represented by return-by-ref.//// An initializer can thwart detection of a 'const' thing because it takes the// "this" argument by ref. Normally such a pattern would cause us to assume// the variable was not const, but in this case we know it is a single def.//// defCall: The CallExpr where 'ref' is set from a PRIM_ADDR_OF or// PRIM_SET_REFERENCE. This call will be ignored while considering uses of// the 'ref' Symbol.//static bool onlyUsedForInitOrRetarg(Symbol* ref, CallExpr* defCall) {  bool seenInitOrRetarg = false;  INT_ASSERT(ref->isRef());  INT_ASSERT(defCall != NULL);  for_SymbolSymExprs(use, ref) {    if (use->parentExpr == defCall)      continue;    CallExpr* call = toCallExpr(use->parentExpr);    if (FnSymbol*  fn = call->resolvedFunction()) {      ArgSymbol* form = actual_to_formal(use);      if (passedToInitOrRetarg(use, form, fn)) {        INT_ASSERT(!seenInitOrRetarg); // init/retarg happens just once        seenInitOrRetarg = true;      } else {        return false;  // a use other than what we are looking for      }    }  }  return true;}

static void removeVoidReturn(BlockStmt* cloneBody) {  CallExpr* retexpr = toCallExpr(cloneBody->body.tail);  INT_ASSERT(retexpr && retexpr->isPrimitive(PRIM_RETURN));  INT_ASSERT(toSymExpr(retexpr->get(1))->symbol() == gVoid);  retexpr->remove();}

void collectMyCallExprsSTL(BaseAST* ast, std::vector<CallExpr*>& callExprs,                           FnSymbol* parent_fn) {  AST_CHILDREN_CALL(ast, collectMyCallExprsSTL, callExprs, parent_fn);  if (CallExpr* callExpr = toCallExpr(ast))    if (callExpr->parentSymbol == parent_fn)      callExprs.push_back(callExpr);}

//// Assumes 'parent' is a PRIM_MOVE or PRIM_ASSIGN//// Returns false if the LHS of the move/assign indicates that the rhs cannot// be a const-ref. For example, if we have a case like this://// (move A, (set-reference B))//// where 'A' and 'B' are references, B cannot be a const-ref if A is not a// const-ref.//// In the case of a dereference, (move A, (deref B)), this function will return// true because we're simply reading B.//static bool canRHSBeConstRef(CallExpr* parent, SymExpr* use) {  INT_ASSERT(isMoveOrAssign(parent));  SymExpr* LHS = toSymExpr(parent->get(1));  CallExpr* rhs = toCallExpr(parent->get(2));  INT_ASSERT(rhs);  switch (rhs->primitive->tag) {    case PRIM_GET_MEMBER:    case PRIM_GET_MEMBER_VALUE:    case PRIM_GET_SVEC_MEMBER:    case PRIM_GET_SVEC_MEMBER_VALUE:    case PRIM_GET_REAL:    case PRIM_GET_IMAG:    case PRIM_ADDR_OF:    case PRIM_SET_REFERENCE: {      // If LHS is a reference and is not a const-ref, the reference in 'rhs'      // should not be considered a const-ref either.      //      // For the get-member primitives, I intend this to be a safe approach      // until we know what const-ref means for fields. Basically, if any field      // might be modified I do not consider the base object to be const-ref.      //      // Note that the get-*-value primitives may return a reference if the      // field is a reference.      if (LHS->isRef()) {        if (!inferConstRef(LHS->symbol())) {          return false;        }      }    }    default:      break;  }  return isSafeRefPrimitive(use);}

//// inlines the function called by 'call' at that call site//static voidinlineCall(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);  }

void deadVariableElimination(FnSymbol* fn) {  Vec<Symbol*> symSet;  Vec<SymExpr*> symExprs;  collectSymbolSetSymExprVec(fn, symSet, symExprs);  Map<Symbol*,Vec<SymExpr*>*> defMap;  Map<Symbol*,Vec<SymExpr*>*> useMap;  buildDefUseMaps(symSet, symExprs, defMap, useMap);  forv_Vec(Symbol, sym, symSet)  {    // We're interested only in VarSymbols.    if (!isVarSymbol(sym))      continue;    // A method must have a _this symbol, even if it is not used.    if (sym == fn->_this)      continue;    if (isDeadVariable(sym, defMap, useMap)) {      for_defs(se, defMap, sym) {        CallExpr* call = toCallExpr(se->parentExpr);        INT_ASSERT(call &&                   (call->isPrimitive(PRIM_MOVE) ||                    call->isPrimitive(PRIM_ASSIGN)));        Expr* rhs = call->get(2)->remove();        if (!isSymExpr(rhs))          call->replace(rhs);        else          call->remove();      }      sym->defPoint->remove();    }  }

  forv_Vec(FnSymbol, fn, gFnSymbols)  {    if (VarSymbol* ret = toVarSymbol(fn->getReturnSymbol()))    {      // The return value of an initCopy function should not be autodestroyed.      // Normally, the return value of a function is autoCopied, but since      // autoCopy is typically defined in terms of initCopy, this would lead to      // infinite recursion.  That is, the return value of initCopy must be      // handled specially.      if (fn->hasFlag(FLAG_INIT_COPY_FN))        ret->removeFlag(FLAG_INSERT_AUTO_DESTROY);      // This is just a workaround for memory management being handled specially      // for internally reference-counted types. (sandboxing)      TypeSymbol* ts = ret->type->symbol;      if (ts->hasFlag(FLAG_ARRAY) ||          ts->hasFlag(FLAG_DOMAIN))        ret->removeFlag(FLAG_INSERT_AUTO_DESTROY);      // Do we need to add other record-wrapped types here?  Testing will tell.      // NOTE 1: When the value of a record field is established in a default      // constructor, it is initialized using a MOVE.  That means that ownership      // of that value is shared between the formal_tmp and the record field.      // If the autodestroy flag is left on that formal temp, then it will be      // destroyed which -- for ref-counted types -- can result in a dangling      // reference.  So here, we look for that case and remove it.        if (fn->hasFlag(FLAG_DEFAULT_CONSTRUCTOR))      {        Map<Symbol*,Vec<SymExpr*>*> defMap;        Map<Symbol*,Vec<SymExpr*>*> useMap;        buildDefUseMaps(fn, defMap, useMap);        std::vector<DefExpr*> defs;        collectDefExprs(fn, defs);        for_vector(DefExpr, def, defs)        {          if (VarSymbol* var = toVarSymbol(def->sym))          {            // Examine only those bearing the explicit autodestroy flag.            if (! var->hasFlag(FLAG_INSERT_AUTO_DESTROY))              continue;            // Look for a use in a PRIM_SET_MEMBER where the field is a record            // type, and remove the flag.            // (We don't actually check that var is of record type, because            // chpl__autoDestroy() does nothing when applied to all other types.            for_uses(se, useMap, var)            {              CallExpr* call = toCallExpr(se->parentExpr);              if (call->isPrimitive(PRIM_SET_MEMBER) &&                  toSymExpr(call->get(3))->var == var)                var->removeFlag(FLAG_INSERT_AUTO_DESTROY);            }          }        }        freeDefUseMaps(defMap, useMap);      }

// Remove the return statement and the def of 'ret'. Return 'ret'.// See also removeRetSymbolAndUses().static Symbol* removeParIterReturn(BlockStmt* cloneBody, Symbol* retsym) {  CallExpr* retexpr = toCallExpr(cloneBody->body.tail);  INT_ASSERT(retexpr && retexpr->isPrimitive(PRIM_RETURN));  if (retsym == NULL) {    retsym = toSymExpr(retexpr->get(1))->symbol();    INT_ASSERT(retsym->type->symbol->hasFlag(FLAG_ITERATOR_RECORD));  } else {    CallExpr* move = toCallExpr(retsym->getSingleDef()->getStmtExpr());    INT_ASSERT(move->isPrimitive(PRIM_MOVE) || move->isPrimitive(PRIM_ASSIGN));    retsym = toSymExpr(move->get(2))->symbol();    move->remove();  }  retexpr->remove();  return retsym;}

//// Find the _waitEndCount and _endCountFree calls that comes after 'fromHere'.// Since these two calls come together, it is prettier to insert// our stuff after the latter.//static Expr* findTailInsertionPoint(Expr* fromHere, bool isCoforall) {  Expr* curr = fromHere;  if (isCoforall) curr = curr->parentExpr;  CallExpr* result = NULL;  while ((curr = curr->next)) {    if (CallExpr* call = toCallExpr(curr))      if (call->isNamed("_waitEndCount")) {        result = call;        break;      }  }  INT_ASSERT(result);  CallExpr* freeEC = toCallExpr(result->next);  // Currently these two calls come together.  INT_ASSERT(freeEC && freeEC->isNamed("_endCountFree"));  return freeEC;}

static void optimizeAnonymousRangeIteration(Expr* iteratorExpr, bool zippered){  if (!zippered)    tryToReplaceWithDirectRangeIterator(iteratorExpr);  // for zippered iterators, try to replace each iterator of the tuple  else    if (CallExpr* call = toCallExpr(iteratorExpr))      if (call->isNamed("_build_tuple"))        for_actuals(actual, call)          tryToReplaceWithDirectRangeIterator(actual);}

void ReturnByRef::insertAssignmentToFormal(FnSymbol* fn, ArgSymbol* formal){  Expr*     returnPrim  = fn->body->body.tail;  SET_LINENO(returnPrim);  CallExpr* returnCall  = toCallExpr(returnPrim);  Expr*     returnValue = returnCall->get(1)->remove();  CallExpr* moveExpr    = new CallExpr(PRIM_MOVE, formal, returnValue);  returnPrim->insertBefore(moveExpr);}

//// BHARSH TODO: Fix up PRIM_ADDR_OF's return type function to correctly// handle this//// The 'returnInfoRef' function for PRIM_ADDR_OF is currently set up to// always return with the Qualifier QUAL_REF. This function is intended// as a workaround to handle the case where we have a wide-ref in a// PRIM_ADDR_OF://// (move "wide-ref dest" (addr-of "wide-ref src"))//// Otherwise, 'returnInfoRef' would hide the fact that the actual is a wide-ref// and it would appear as though we had a local reference.//// Note that this case is actually just a copy of a pointer's address, and// will not generate an addrof in the generated code.//staticbool isAddrOfWideRefVar(Expr* e){  // ADDR_OF of a wide ref variable is a wide ref (not a ref).  if (CallExpr* call = toCallExpr(e))    if (call->isPrimitive(PRIM_ADDR_OF))      if (SymExpr* se = toSymExpr(call->get(1)))        if (se->symbol()->qualType().isWideRef())          return true;  return false;}

void localizeGlobals() {  if (fNoGlobalConstOpt) return;  forv_Vec(FnSymbol, fn, gFnSymbols) {    Map<Symbol*,VarSymbol*> globals;    std::vector<BaseAST*> asts;    collect_asts(fn->body, asts);    for_vector(BaseAST, ast, asts) {      if (SymExpr* se = toSymExpr(ast)) {        Symbol* var = se->symbol();        ModuleSymbol* parentmod = toModuleSymbol(var->defPoint->parentSymbol);        CallExpr* parentExpr = toCallExpr(se->parentExpr);        bool inAddrOf = parentExpr && parentExpr->isPrimitive(PRIM_ADDR_OF);        bool lhsOfMove = parentExpr && isMoveOrAssign(parentExpr) && (parentExpr->get(1) == se);        // Is var a global constant?        // Don't replace the var name in its init function since that's        //      where we're setting the value. Similarly, dont replace them        //      inside initStringLiterals        // If the parentSymbol is the rootModule, the var is 'void,'        //      'false,' '0,' ...        // Also don't replace it when it's in an addr of primitive.        if (parentmod &&            fn != parentmod->initFn &&            fn != initStringLiterals &&            !inAddrOf &&            !lhsOfMove &&            var->hasFlag(FLAG_CONST) &&            var->defPoint->parentSymbol != rootModule) {          VarSymbol* local_global = globals.get(var);          SET_LINENO(se); // Set the se line number for output          if (!local_global) {            const char * newname = astr("local_", var->cname);            local_global = newTemp(newname, var->type);            fn->insertAtHead(new CallExpr(PRIM_MOVE, local_global, var));            fn->insertAtHead(new DefExpr(local_global));            // Copy string immediates to localized strings so that            // we can show the string value in comments next to uses.            if (!llvmCodegen)              if (VarSymbol* localVarSym = toVarSymbol(var))                if (Immediate* immediate = localVarSym->immediate)                  if (immediate->const_kind == CONST_KIND_STRING)                    local_global->immediate =                      new Immediate(immediate->v_string, immediate->string_kind);            globals.put(var, local_global);          }          se->replace(new SymExpr(toSymbol(local_global)));        }      }    }  }

static boolremoveIdentityDefs(Symbol* sym) {  bool change = false;  for_defs(def, defMap, sym) {    CallExpr* move = toCallExpr(def->parentExpr);    if (move && isMoveOrAssign(move)) {      SymExpr* rhs = toSymExpr(move->get(2));      if (rhs && def->symbol() == rhs->symbol()) {        move->remove();        change = true;      }    }  }

static boolremoveIdentityDefs(Symbol* sym) {  bool change = false;  for_defs(def, defMap, sym) {    CallExpr* move = toCallExpr(def->parentExpr);    if (move && move->isPrimitive(PRIM_MOVE)) {      SymExpr* rhs = toSymExpr(move->get(2));      if (rhs && def->var == rhs->var) {        move->remove();        change = true;      }    }  }

/* * Returns true if `e` has no side effects. Checked side effects are: *  - Read/write to a global *  - Is/contains essential primitive *  - If it's a call to functions with ref arguments *  - If the LHS of a PRIM_MOVE appears in the exprToMove * * For now, this is a very conservative analysis. A more precise analysis * could distinguish between reads and writes to memory and to take into * account alias analysis. */bool SafeExprAnalysis::exprHasNoSideEffects(Expr* e, Expr* exprToMove) {  if(safeExprCache.count(e) > 0) {    return safeExprCache[e];  }  if(CallExpr* ce = toCallExpr(e)) {    if(!ce->isPrimitive()) {      FnSymbol* fnSym = ce->theFnSymbol();      const bool cachedSafeFn = safeFnCache.count(fnSym);      if(!cachedSafeFn) {        const bool retval = fnHasNoSideEffects(fnSym);        safeFnCache[fnSym] = retval;        return retval;      }      return safeFnCache[fnSym];    }    else {      //primitive      if(! isSafePrimitive(ce)){        safeExprCache[e] = false;        return false;      }      else if (exprToMove != NULL) {        //        // Exposed by AST pattern like this:        //          |---|------- `exprToMove`        // (move T (+ A B))        // (move A B) -------- `ce`        // (move B T)        //        // Without this check could turn into:        //        // (move A B)        // (move B (+ A B))        //        // Which is incorrect.        //        if (ce->isPrimitive(PRIM_MOVE)) {          INT_ASSERT(isSymExpr(ce->get(1)));          std::vector<SymExpr*> syms;          collectSymExprs(exprToMove, syms);          for_vector(SymExpr, s, syms) {            if (s->symbol() == toSymExpr(ce->get(1))->symbol()) {              safeExprCache[e] = false;              return false;            }          }        }      }    }  }

// Does 'fn' return the result of a call to 'se' ?static bool isReturnedValue(FnSymbol* fn, SymExpr* se) {  Symbol* currSym  = fn->getReturnSymbol();  // Traverse the chain of moves. Like in stripReturnScaffolding().  while (true) {    if (SymExpr* defSE = currSym->getSingleDef())      if (CallExpr* defMove = toCallExpr(defSE->parentExpr))        if (defMove->isPrimitive(PRIM_MOVE)) {          Expr* defSrc = defMove->get(2);          if (CallExpr* srcCall = toCallExpr(defSrc))            if (srcCall->baseExpr == se)              return true;  // found it          if (SymExpr* srcSE = toSymExpr(defSrc)) {            currSym = srcSE->symbol();            continue;  // continue traversing the chain of moves          }        }    // The chain of moves is over. Return false.    break;  }  return false;}

//// Do a breadth first search starting from functions generated for local blocks// for all function calls in each level of the search, if they directly cause// communication, add a local temp that isn't wide. If it is a resolved call,// meaning that it isn't a primitive or external function, clone it and add it// to the queue of functions to handle at the next iteration of the BFS.//static void handleLocalBlocks() {  Map<FnSymbol*,FnSymbol*> cache; // cache of localized functions  Vec<BlockStmt*> queue; // queue of blocks to localize  forv_Vec(BlockStmt, block, gBlockStmts) {    if (block->parentSymbol) {      // NOAKES 2014/11/25 Transitional.  Avoid calling blockInfoGet()      if (block->isLoopStmt() == true) {      } else if (block->blockInfoGet()) {        if (block->blockInfoGet()->isPrimitive(PRIM_BLOCK_LOCAL)) {          queue.add(block);        }      }    }  }  forv_Vec(BlockStmt, block, queue) {    std::vector<CallExpr*> calls;    collectCallExprs(block, calls);    for_vector(CallExpr, call, calls) {      localizeCall(call);      if (FnSymbol* fn = call->isResolved()) {        SET_LINENO(fn);        if (FnSymbol* alreadyLocal = cache.get(fn)) {          call->baseExpr->replace(new SymExpr(alreadyLocal));        } else {          if (!fn->hasFlag(FLAG_EXTERN)) {            FnSymbol* local = fn->copy();            local->addFlag(FLAG_LOCAL_FN);            local->name = astr("_local_", fn->name);            local->cname = astr("_local_", fn->cname);            fn->defPoint->insertBefore(new DefExpr(local));            call->baseExpr->replace(new SymExpr(local));            queue.add(local->body);            cache.put(fn, local);            cache.put(local, local); // to handle recursion            if (local->retType->symbol->hasFlag(FLAG_WIDE_REF)) {              CallExpr* ret = toCallExpr(local->body->body.tail);              INT_ASSERT(ret && ret->isPrimitive(PRIM_RETURN));              // Capture the return expression in a local temp.              insertLocalTemp(ret->get(1));              local->retType = ret->get(1)->typeInfo();            }          }        }      }    }

// If there is exactly one definition of var by something of reference type, // then return the call that defines it.// Otherwise, return NULL.static CallExpr*findRefDef(Map<Symbol*,Vec<SymExpr*>*>& defMap, Symbol* var) {  CallExpr* ret = NULL;  for_defs(def, defMap, var) {    if (CallExpr* call = toCallExpr(def->parentExpr)) {      if (call->isPrimitive(PRIM_MOVE) || call->isPrimitive(PRIM_ASSIGN))        if (call->get(2)->isRef()) {          if (ret)            return NULL;          else            ret = call;        }    }  }  return ret;}

//// Returns true if 'use' appears in a non-side-effecting primitive.//static bool isSafeRefPrimitive(SymExpr* use) {  CallExpr* call = toCallExpr(use->parentExpr);  INT_ASSERT(call);  switch (call->primitive->tag) {    case PRIM_ADDR_OF:    case PRIM_SET_REFERENCE:    case PRIM_DEREF:    case PRIM_WIDE_GET_LOCALE:    case PRIM_NOOP:    case PRIM_UNARY_MINUS:    case PRIM_UNARY_PLUS:    case PRIM_UNARY_NOT:    case PRIM_UNARY_LNOT:    case PRIM_ADD:    case PRIM_SUBTRACT:    case PRIM_MULT:    case PRIM_DIV:    case PRIM_MOD:    case PRIM_LSH:    case PRIM_RSH:    case PRIM_EQUAL:    case PRIM_NOTEQUAL:    case PRIM_LESSOREQUAL:    case PRIM_GREATEROREQUAL:    case PRIM_LESS:    case PRIM_GREATER:    case PRIM_AND:    case PRIM_OR:    case PRIM_XOR:    case PRIM_POW:    case PRIM_MIN:    case PRIM_MAX:    case PRIM_CHECK_NIL:    case PRIM_LOCAL_CHECK:    case PRIM_PTR_EQUAL:    case PRIM_PTR_NOTEQUAL:    case PRIM_SIZEOF_BUNDLE:    case PRIM_SIZEOF_DDATA_ELEMENT:    case PRIM_WIDE_GET_NODE:      return true;    default:      return false;  }}

static boolsymExprIsSetByUse(SymExpr* use) {  if (CallExpr* call = toCallExpr(use->parentExpr)) {    if (FnSymbol* fn = call->resolvedFunction()) {      ArgSymbol* formal = actual_to_formal(use);      if (formal->intent == INTENT_INOUT || formal->intent == INTENT_OUT) {        // Shouldn't this be a Def, not a Use, then?        INT_ASSERT(0);        return true;      }      if (formal->type->symbol->hasFlag(FLAG_REF) &&          (fn->hasFlag(FLAG_ALLOW_REF) ||           formal->hasFlag(FLAG_WRAP_WRITTEN_FORMAL))) {        // This case has to do with wrapper functions (promotion?)        return true;      }    } else if (call->isPrimitive(PRIM_SET_MEMBER)) {      // PRIM_SET_MEMBER to set the pointer inside of a reference      // counts as "setter"      // the below conditional would better be isRefType()      if (!call->get(2)->typeInfo()->refType) {        return true;      }    } else if (call->isPrimitive(PRIM_RETURN) ||               call->isPrimitive(PRIM_YIELD)) {      FnSymbol* inFn = toFnSymbol(call->parentSymbol);      // It is not necessary to use the 'ref' version      // if the function result is returned by 'const ref'.      if (inFn->retTag == RET_CONST_REF) return false;      // MPF: it seems to cause problems to return false      // here when inFn->retTag is RET_VALUE.      // TODO: can we add      //if (inFn->retTag == RET_VALUE) return false;      return true;    }  }  return false;}

void localizeGlobals() {  if (fNoGlobalConstOpt) return;  forv_Vec(FnSymbol, fn, gFnSymbols) {    Map<Symbol*,VarSymbol*> globals;    std::vector<BaseAST*> asts;    collect_asts(fn->body, asts);    for_vector(BaseAST, ast, asts) {      if (SymExpr* se = toSymExpr(ast)) {        Symbol* var = se->var;        ModuleSymbol* parentmod = toModuleSymbol(var->defPoint->parentSymbol);        CallExpr* parentExpr = toCallExpr(se->parentExpr);        bool inAddrOf = parentExpr && parentExpr->isPrimitive(PRIM_ADDR_OF);        // Is var a global constant?        // Don't replace the var name in its init function since that's        //      where we're setting the value. Similarly, dont replace them        //      inside initStringLiterals        // If the parentSymbol is the rootModule, the var is 'void,'        //      'false,' '0,' ...        // Also don't replace it when it's in an addr of primitive.        if (parentmod &&            fn != parentmod->initFn &&            fn != initStringLiterals &&            !inAddrOf &&            var->hasFlag(FLAG_CONST) &&            var->defPoint->parentSymbol != rootModule) {          VarSymbol* local_global = globals.get(var);          SET_LINENO(se); // Set the se line number for output          if (!local_global) {            const char * newname = astr("local_", var->cname);            local_global = newTemp(newname, var->type);            fn->insertAtHead(new CallExpr(PRIM_MOVE, local_global, var));            fn->insertAtHead(new DefExpr(local_global));            globals.put(var, local_global);          }          se->replace(new SymExpr(toSymbol(local_global)));        }      }    }  }