reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

tools/polly/include/polly/ScopBuilder.h
  698     return scop->getRequiredInvariantLoads().count(LI);
  827   std::unique_ptr<Scop> getScop() { return std::move(scop); }
tools/polly/lib/Analysis/ScopBuilder.cpp
  298   int OldDepth = scop->getRelativeLoopDepth(OldL);
  299   int NewDepth = scop->getRelativeLoopDepth(NewL);
  317     auto &R = scop->getRegion();
  347   PWACtx PWAC = scop->getPwAff(E, BB, NonNegative);
  445         getUniqueNonErrorValue(PHI, &scop->getRegion(), LI, DT));
  484     Region &R = scop->getRegion();
  548     scop->invalidate(COMPLEXITY, TI ? TI->getDebugLoc() : DebugLoc(),
  600       if (!scop->isNonAffineSubRegion(SubRegion)) {
  608     isl::set &Domain = scop->getOrInitEmptyDomain(BB);
  614     Domain = Domain.align_params(scop->getParamSpace());
  617     if (BBLoop && BBLoop->getHeader() == BB && scop->contains(BBLoop))
  631   auto *RI = scop->getRegion().getRegionInfo();
  634   if (!BBReg || BBReg->getEntry() != BB || !scop->contains(ExitBB))
  640   while (L && scop->contains(L)) {
  649   isl::set Domain = scop->getOrInitEmptyDomain(BB);
  652   Loop *ExitBBLoop = getFirstNonBoxedLoopFor(ExitBB, LI, scop->getBoxedLoops());
  657   isl::set &ExitDomain = scop->getOrInitEmptyDomain(ExitBB);
  672   if (scop->getRegion().getEntry() == BB)
  676   auto &RI = *scop->getRegion().getRegionInfo();
  678   Loop *BBLoop = getFirstNonBoxedLoopFor(BB, LI, scop->getBoxedLoops());
  713     isl::set PredBBDom = scop->getDomainConditions(PredBB);
  715         getFirstNonBoxedLoopFor(PredBB, LI, scop->getBoxedLoops());
  725   int LoopDepth = scop->getRelativeLoopDepth(L);
  729   assert(scop->isDomainDefined(HeaderBB));
  730   isl::set &HeaderBBDom = scop->getOrInitEmptyDomain(HeaderBB);
  742     if (!scop->isDomainDefined(LatchBB))
  745     isl::set LatchBBDom = scop->getDomainConditions(LatchBB);
  768     int LatchLoopDepth = scop->getRelativeLoopDepth(LI.getLoopFor(LatchBB));
  795   if (scop->hasNSWAddRecForLoop(L))
  799   scop->recordAssumption(INFINITELOOP, UnboundedCtx,
  808   const InvariantLoadsSetTy &RIL = scop->getRequiredInvariantLoads();
  815       scop->addInvariantLoadMapping(LInst, ClassRep);
  820     scop->addInvariantEquivClass(
  827   bool IsOnlyNonAffineRegion = scop->isNonAffineSubRegion(R);
  830   int LD = scop->getRelativeLoopDepth(L);
  832       isl_set_universe(isl_space_set_alloc(scop->getIslCtx().get(), 0, LD + 1));
  836   scop->setDomain(EntryBB, Domain);
  885       if (!scop->isNonAffineSubRegion(SubRegion)) {
  892     if (containsErrorBlock(RN, scop->getRegion(), LI, DT))
  893       scop->notifyErrorBlock();
  902     if (!scop->isDomainDefined(BB))
  904     isl::set Domain = scop->getDomainConditions(BB);
  906     scop->updateMaxLoopDepth(isl_set_n_dim(Domain.get()));
  946       if (!scop->contains(SuccBB))
  959           getFirstNonBoxedLoopFor(SuccBB, LI, scop->getBoxedLoops());
  966       isl::set &SuccDomain = scop->getOrInitEmptyDomain(SuccBB);
  983       scop->invalidate(COMPLEXITY, DebugLoc());
 1002       if (!scop->isNonAffineSubRegion(SubRegion)) {
 1008     bool ContainsErrorBlock = containsErrorBlock(RN, scop->getRegion(), LI, DT);
 1010     isl::set &Domain = scop->getOrInitEmptyDomain(BB);
 1022       scop->recordAssumption(ERRORBLOCK, DomPar,
 1040       if (!scop->contains(SuccBB))
 1048           getFirstNonBoxedLoopFor(SuccBB, LI, scop->getBoxedLoops());
 1065       scop->invalidate(COMPLEXITY, TI->getDebugLoc(), TI->getParent());
 1087   if (!IsExitBlock && canSynthesize(PHI, *scop, &SE, Scope))
 1097     ScopStmt *OpStmt = scop->getIncomingStmtFor(PHI->getOperandUse(u));
 1173   Loop *L = getLoopSurroundingScop(*scop, LI);
 1175   buildSchedule(scop->getRegion().getNode(), LoopStack);
 1177   scop->setScheduleTree(LoopStack[0].Schedule);
 1205   Loop *OuterScopLoop = getLoopSurroundingScop(*scop, LI);
 1232     if (!scop->contains(L))
 1251     if (!scop->isNonAffineSubRegion(LocalRegion)) {
 1261   for (auto *Stmt : scop->getStmtListFor(RN)) {
 1303   if (scop->isEscaping(Inst))
 1491   for (auto &AS : llvm::reverse(scop->recorded_assumptions())) {
 1494       scop->addAssumption(AS.Kind, AS.Set, AS.Loc, AS.Sign,
 1500     isl_set *Dom = scop->getDomainConditions(AS.BB).release();
 1519     scop->addAssumption(AS.Kind, isl::manage(S), AS.Loc, AS_RESTRICTION, AS.BB);
 1521   scop->clearRecordedAssumptions();
 1531     bool InScop = scop->contains(CI);
 1532     if (!InScop && !scop->isDominatedBy(DT, CI->getParent()))
 1538     auto &R = scop->getRegion();
 1550       Param = scop->getRepresentingInvariantLoadSCEV(Param);
 1551       if (scop->isParam(Param))
 1559     auto *Dom = InScop ? isl_set_copy(scop->getDomainConditions(BB).get())
 1560                        : isl_set_copy(scop->getContext().get());
 1595         scop->getContext().intersect(isl::manage(AssumptionCtx));
 1596     scop->setContext(newContext);
 1645   const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads();
 1650     if (!isAffineExpr(&scop->getRegion(), SurroundingLoop, Subscript, SE,
 1691   auto &InsnToMemAcc = scop->getInsnToMemAccMap();
 1717     scop->invalidate(DELINEARIZATION, Inst->getDebugLoc(), Inst->getParent());
 1736   const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads();
 1739   bool LengthIsAffine = isAffineExpr(&scop->getRegion(), SurroundingLoop,
 1871                   isAffineExpr(&scop->getRegion(), SurroundingLoop,
 1874   const InvariantLoadsSetTy &ScopRIL = scop->getRequiredInvariantLoads();
 1903   for (auto &Stmt : *scop) {
 1918   for (BasicBlock *BB : scop->getRegion().blocks()) {
 1926          !canSynthesize(Inst, *scop, &SE, L);
 1966   long BBIdx = scop->getNextStmtIdx();
 1974       scop->addScopStmt(BB, Name, SurroundingLoop, Instructions);
 1981   scop->addScopStmt(BB, Name, SurroundingLoop, Instructions);
 2155   long BBIdx = scop->getNextStmtIdx();
 2163     scop->addScopStmt(BB, Name, L, std::move(InstList));
 2174   scop->addScopStmt(BB, EpilogueName, L, {});
 2178   if (scop->isNonAffineSubRegion(&SR)) {
 2181         getFirstNonBoxedLoopFor(SR.getEntry(), LI, scop->getBoxedLoops());
 2185     long RIdx = scop->getNextStmtIdx();
 2187     scop->addScopStmt(&SR, Name, SurroundingLoop, Instructions);
 2219   if (isErrorBlock(BB, scop->getRegion(), LI, DT))
 2241   const InvariantLoadsSetTy &RIL = scop->getRequiredInvariantLoads();
 2295   scop->addAccessFunction(Access);
 2351   isl::union_set Accessed = scop->getAccesses().range();
 2353   for (auto Array : scop->arrays()) {
 2430     for (auto &Access : scop->access_functions())
 2449   for (ScopStmt &Stmt : *scop) {
 2476   for (ScopStmt &Stmt : *scop)
 2493   for (auto &Stmt : *scop)
 2499   for (auto &Stmt : *scop)
 2505   for (auto &Stmt : *scop)
 2513   ScopStmt *Stmt = scop->getStmtFor(Inst);
 2521     Stmt = scop->getLastStmtFor(Inst->getParent());
 2547   auto VUse = VirtualUse::create(scop.get(), UserStmt, Scope, V, false);
 2588     scop->getOrCreateScopArrayInfo(PHI, PHI->getType(), {},
 2625   isl::id Id = isl::id::alloc(scop->getIslCtx(), Stmt.getBaseName(), &Stmt);
 2627   Stmt.Domain = scop->getDomainConditions(&Stmt);
 2743   auto &RIL = scop->getRequiredInvariantLoads();
 2745     assert(LI && scop->contains(LI));
 2748     for (ScopStmt &Stmt : *scop)
 2750         scop->invalidate(INVARIANTLOAD, LI->getDebugLoc(), LI->getParent());
 2760   isl::union_map Writes = scop->getWrites();
 2761   for (ScopStmt &Stmt : *scop) {
 2803   if (auto *BasePtrMA = scop->lookupBasePtrAccess(MA)) {
 2810       return scop->contains(BasePtrInst);
 2819   isl::set UserContext = isl::set(scop->getIslCtx(), UserContextStr.c_str());
 2820   isl::space Space = scop->getParamSpace();
 2832         scop->getContext().get_dim_name(isl::dim::param, i);
 2850   isl::set newContext = scop->getContext().intersect(UserContext);
 2851   scop->setContext(newContext);
 2891   auto &DL = scop->getFunction().getParent()->getDataLayout();
 2918   scop->addAssumption(INVARIANTLOAD, WrittenCtx, LI->getDebugLoc(),
 2938       isAParameter(LInst->getPointerOperand(), scop->getFunction()))
 2983     scop->invalidate(COMPLEXITY, AccInst->getDebugLoc(), AccInst->getParent());
 2997       for (const SCEV *Parameter : scop->parameters()) {
 3003         if (isl::id ParamId = scop->getIdForParam(Parameter)) {
 3035       MACtx = MACtx.gist_params(scop->getContext());
 3039     for (auto &IAClass : scop->invariantEquivClasses()) {
 3082     scop->addInvariantEquivClass(
 3174   for (InvariantEquivClassTy &EqClass : scop->InvariantEquivClasses) {
 3178         findCanonicalArray(*scop, BasePtrAccesses);
 3184       const ScopArrayInfo *BasePtrSAI = scop->getScopArrayInfoOrNull(
 3195       if (isUsedForIndirectHoistedLoad(*scop, BasePtrSAI))
 3198       replaceBasePtrArrays(*scop, BasePtrSAI, CanonicalBasePtrSAI);
 3217     auto *SAI = scop->getOrCreateScopArrayInfo(Access->getOriginalBaseAddr(),
 3220     scop->addAccessData(Access);
 3298   isl::union_set Domains = scop->getDomains();
 3299   isl::union_map Accesses = isl::union_map::empty(scop->getParamSpace());
 3309     LimitReached |= !buildMinMaxAccess(Set, MinMaxAccesses, *scop);
 3330     if (scop->getAliasGroups().size())
 3338   scop->invalidate(ALIASING, DebugLoc());
 3341       dbgs() << "\n\nNOTE: Run time checks for " << scop->getNameStr()
 3356   for (ScopStmt &Stmt : *scop) {
 3408     if (!scop->hasFeasibleRuntimeContext())
 3412       IslMaxOperationsGuard MaxOpGuard(scop->getIslCtx().get(), OptComputeOut);
 3417     if (isl_ctx_last_error(scop->getIslCtx().get()) == isl_error_quota) {
 3418       scop->invalidate(COMPLEXITY, DebugLoc());
 3463       scop->invalidate(ALIASING, MA->getAccessInstruction()->getDebugLoc(),
 3472     if (MemoryAccess *BasePtrMA = scop->lookupBasePtrAccess(MA))
 3473       scop->addRequiredInvariantLoad(
 3498   scop->addAliasGroup(MinMaxAccessesReadWrite, MinMaxAccessesReadOnly);
 3600   scop.reset(new Scop(R, SE, LI, DT, *SD.getDetectionContext(&R), ORE));
 3607   const InvariantLoadsSetTy &RIL = scop->getRequiredInvariantLoads();
 3608   for (BasicBlock *BB : scop->getRegion().blocks()) {
 3609     if (isErrorBlock(*BB, scop->getRegion(), LI, DT))
 3624       ArrayRef<ScopStmt *> List = scop->getStmtListFor(BB);
 3639   if (!R.isTopLevelRegion() && !scop->hasSingleExitEdge()) {
 3673   for (ScopStmt &Stmt : scop->Stmts)
 3682   scop->removeStmtNotInDomainMap();
 3683   scop->simplifySCoP(false);
 3684   if (scop->isEmpty()) {
 3690   for (ScopStmt &Stmt : *scop) {
 3701   if (!scop->hasFeasibleRuntimeContext()) {
 3708   if (!scop->isProfitable(UnprofitableScalarAccs)) {
 3709     scop->invalidate(PROFITABLE, DebugLoc());
 3719   scop->realignParams();
 3727   scop->simplifyContexts();
 3736   scop->simplifySCoP(true);
 3740   if (!scop->hasFeasibleRuntimeContext()) {
 3746   verifyUses(scop.get(), LI, DT);
 3765   LLVM_DEBUG(dbgs() << *scop);
 3767   if (!scop->hasFeasibleRuntimeContext()) {
 3771     scop.reset();
 3775     if (scop->getMaxLoopDepth() > 0)