|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
tools/polly/include/polly/Simplify.h 26 class ScopStmt;
tools/polly/include/polly/Support/ScopHelper.h 35 class ScopStmt;
tools/polly/include/polly/ZoneAlgo.h 32 class ScopStmt;
References
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
127 ArrayRef(const std::vector<U *, A> &Vec,
129 std::is_convertible<U *const *, T const *>::value>::type* = 0)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
tools/polly/include/polly/CodeGen/BlockGenerators.h 83 void copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
289 BasicBlock *copyBB(ScopStmt &Stmt, BasicBlock *BB, ValueMapT &BBMap,
304 void copyBB(ScopStmt &Stmt, BasicBlock *BB, BasicBlock *BBCopy,
315 void generateScalarLoads(ScopStmt &Stmt, LoopToScevMapT <S,
335 void generateBeginStmtTrace(ScopStmt &Stmt, LoopToScevMapT <S,
348 Value *buildContainsCondition(ScopStmt &Stmt, const isl::set &Subdomain);
361 void generateConditionalExecution(ScopStmt &Stmt, const isl::set &Subdomain,
378 virtual void generateScalarStores(ScopStmt &Stmt, LoopToScevMapT <S,
447 Value *trySynthesizeNewValue(ScopStmt &Stmt, Value *Old, ValueMapT &BBMap,
474 Value *getNewValue(ScopStmt &Stmt, Value *Old, ValueMapT &BBMap,
477 void copyInstScalar(ScopStmt &Stmt, Instruction *Inst, ValueMapT &BBMap,
481 Loop *getLoopForStmt(const ScopStmt &Stmt) const;
487 Value *generateLocationAccessed(ScopStmt &Stmt, MemAccInst Inst,
506 Value *generateLocationAccessed(ScopStmt &Stmt, Loop *L, Value *Pointer,
536 Value *generateArrayLoad(ScopStmt &Stmt, LoadInst *load, ValueMapT &BBMap,
543 void generateArrayStore(ScopStmt &Stmt, StoreInst *store, ValueMapT &BBMap,
550 virtual void copyPHIInstruction(ScopStmt &, PHINode *, ValueMapT &,
572 void copyInstruction(ScopStmt &Stmt, Instruction *Inst, ValueMapT &BBMap,
578 bool canSyntheziseInStmt(ScopStmt &Stmt, Instruction *Inst);
625 static void generate(BlockGenerator &BlockGen, ScopStmt &Stmt,
662 Value *getVectorValue(ScopStmt &Stmt, Value *Old, ValueMapT &VectorMap,
685 Value *generateStrideOneLoad(ScopStmt &Stmt, LoadInst *Load,
703 Value *generateStrideZeroLoad(ScopStmt &Stmt, LoadInst *Load,
721 Value *generateUnknownStrideLoad(ScopStmt &Stmt, LoadInst *Load,
728 void generateLoad(ScopStmt &Stmt, LoadInst *Load, ValueMapT &VectorMap,
732 void copyUnaryInst(ScopStmt &Stmt, UnaryInstruction *Inst,
735 void copyBinaryInst(ScopStmt &Stmt, BinaryOperator *Inst,
741 void copyStore(ScopStmt &Stmt, StoreInst *Store, ValueMapT &VectorMap,
748 void copyInstScalarized(ScopStmt &Stmt, Instruction *Inst,
762 void generateScalarVectorLoads(ScopStmt &Stmt, ValueMapT &VectorBlockMap);
767 void verifyNoScalarStores(ScopStmt &Stmt);
772 void copyInstruction(ScopStmt &Stmt, Instruction *Inst, ValueMapT &VectorMap,
779 void copyStmt(ScopStmt &Stmt, __isl_keep isl_id_to_ast_expr *NewAccesses);
800 void copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
905 void addOperandToPHI(ScopStmt &Stmt, PHINode *PHI, PHINode *PHICopy,
955 generateScalarStores(ScopStmt &Stmt, LoopToScevMapT <S, ValueMapT &BBMAp,
968 virtual void copyPHIInstruction(ScopStmt &Stmt, PHINode *Inst,
tools/polly/include/polly/CodeGen/IslNodeBuilder.h 63 void addReferencesFromStmt(const ScopStmt *Stmt, void *UserPtr,
344 createNewAccesses(ScopStmt *Stmt, __isl_keep isl_ast_node *Node);
379 void createSubstitutions(__isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
381 void createSubstitutionsVector(__isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
418 void generateCopyStmt(ScopStmt *Stmt,
tools/polly/include/polly/DependenceInfo.h 54 using StatementToIslMapTy = DenseMap<ScopStmt *, isl::map>;
tools/polly/include/polly/ScopBuilder.h 56 SmallVector<std::pair<ScopStmt *, Instruction *>, 16> GlobalReads;
313 bool buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt);
322 bool buildAccessMultiDimParam(MemAccInst Inst, ScopStmt *Stmt);
330 bool buildAccessMemIntrinsic(MemAccInst Inst, ScopStmt *Stmt);
338 bool buildAccessCallInst(MemAccInst Inst, ScopStmt *Stmt);
345 void buildAccessSingleDim(MemAccInst Inst, ScopStmt *Stmt);
460 void buildMemoryAccess(MemAccInst Inst, ScopStmt *Stmt);
467 void buildScalarDependences(ScopStmt *UserStmt, Instruction *Inst);
484 void buildPHIAccesses(ScopStmt *PHIStmt, PHINode *PHI,
524 void buildAccessFunctions(ScopStmt *Stmt, BasicBlock &BB,
543 MemoryAccess *addMemoryAccess(ScopStmt *Stmt, Instruction *Inst,
564 void addArrayAccess(ScopStmt *Stmt, MemAccInst MemAccInst,
588 void ensureValueRead(Value *V, ScopStmt *UserStmt);
604 void ensurePHIWrite(PHINode *PHI, ScopStmt *IncomintStmt,
630 void addPHIReadAccess(ScopStmt *PHIStmt, PHINode *PHI);
636 void buildDomain(ScopStmt &Stmt);
639 void collectSurroundingLoops(ScopStmt &Stmt);
652 void checkForReductions(ScopStmt &Stmt);
689 void addInvariantLoads(ScopStmt &Stmt, InvariantAccessesTy &InvMAs);
727 void buildAccessRelations(ScopStmt &Stmt);
tools/polly/include/polly/ScopInfo.h 524 ScopStmt *Statement;
634 isl::basic_map createBasicAccessMap(ScopStmt *Statement);
720 MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst, AccessType AccType,
735 MemoryAccess(ScopStmt *Stmt, AccessType AccType, isl::map AccRel);
1040 ScopStmt *getStatement() const { return Statement; }
1182 ScopStmt(const ScopStmt &) = delete;
1183 const ScopStmt &operator=(const ScopStmt &) = delete;
1183 const ScopStmt &operator=(const ScopStmt &) = delete;
1625 raw_ostream &operator<<(raw_ostream &OS, const ScopStmt &S);
1768 using StmtSet = std::list<ScopStmt>;
1787 DenseMap<BasicBlock *, std::vector<ScopStmt *>> StmtMap;
1790 DenseMap<Instruction *, ScopStmt *> InstStmtMap;
2009 void removeStmts(std::function<bool(ScopStmt &)> ShouldDelete,
2013 void removeFromStmtMap(ScopStmt &Stmt);
2062 ScopStmt *addScopStmt(isl::map SourceRel, isl::map TargetRel,
2409 ArrayRef<ScopStmt *> getStmtListFor(BasicBlock *BB) const;
2414 ScopStmt *getIncomingStmtFor(const Use &U) const;
2422 ScopStmt *getLastStmtFor(BasicBlock *BB) const;
2426 ArrayRef<ScopStmt *> getStmtListFor(Region *R) const;
2431 ArrayRef<ScopStmt *> getStmtListFor(RegionNode *RN) const;
2435 ScopStmt *getStmtFor(Instruction *Inst) const {
2606 isl::set getDomainConditions(const ScopStmt *Stmt) const;
tools/polly/include/polly/Simplify.h 42 llvm::SmallVector<MemoryAccess *, 32> getAccessesInOrder(ScopStmt &Stmt);
tools/polly/include/polly/Support/ScopHelper.h 499 bool hasDebugCall(ScopStmt *Stmt);
tools/polly/include/polly/Support/VirtualInstruction.h 67 ScopStmt *User;
84 VirtualUse(ScopStmt *User, Value *Val, UseKind Kind, const SCEV *ScevExpr,
120 static VirtualUse create(Scop *S, ScopStmt *UserStmt, Loop *UserScope,
123 static VirtualUse create(ScopStmt *UserStmt, Loop *UserScope, Value *Val,
137 ScopStmt *getUser() const { return User; }
177 ScopStmt *User;
180 VirtualOperandIterator(ScopStmt *User, User::op_iterator U)
235 ScopStmt *Stmt = nullptr;
244 VirtualInstruction(ScopStmt *Stmt, Instruction *Inst)
269 ScopStmt *getStmt() const { return Stmt; }
308 ScopStmt *OnlyLocal = nullptr);
317 return DenseMapInfo<polly::ScopStmt *>::isEqual(LHS.getStmt(),
325 TombstoneKey.Stmt = DenseMapInfo<polly::ScopStmt *>::getTombstoneKey();
332 EmptyKey.Stmt = DenseMapInfo<polly::ScopStmt *>::getEmptyKey();
338 return DenseMapInfo<std::pair<polly::ScopStmt *, Instruction *>>::
tools/polly/include/polly/ZoneAlgo.h 60 llvm::DenseMap<ScopStmt *, isl::map> ScalarReachDefZone;
157 llvm::DenseMap<std::pair<ScopStmt *, ScopStmt *>, isl::map> DefToTargetCache;
157 llvm::DenseMap<std::pair<ScopStmt *, ScopStmt *>, isl::map> DefToTargetCache;
183 void collectIncompatibleElts(ScopStmt *Stmt, isl::union_set &IncompatibleElts,
204 isl::map computeUseToDefFlowDependency(ScopStmt *UseStmt, ScopStmt *DefStmt);
204 isl::map computeUseToDefFlowDependency(ScopStmt *UseStmt, ScopStmt *DefStmt);
228 isl::map getScatterFor(ScopStmt *Stmt) const;
240 isl::set getDomainFor(ScopStmt *Stmt) const;
270 isl::map getDefToTarget(ScopStmt *DefStmt, ScopStmt *TargetStmt);
270 isl::map getDefToTarget(ScopStmt *DefStmt, ScopStmt *TargetStmt);
280 isl::map getScalarReachingDefinition(ScopStmt *Stmt);
295 isl::map makeUnknownForDomain(ScopStmt *Stmt) const;
334 isl::map makeValInst(llvm::Value *Val, ScopStmt *UserStmt, llvm::Loop *Scope,
342 isl::union_map makeNormalizedValInst(llvm::Value *Val, ScopStmt *UserStmt,
tools/polly/lib/Analysis/DependenceInfo.cpp 128 for (ScopStmt &Stmt : S)
133 for (ScopStmt &Stmt : S) {
530 for (ScopStmt &Stmt : S) {
575 for (ScopStmt &Stmt : S) {
649 for (ScopStmt &Stmt : S) {
tools/polly/lib/Analysis/ScopBuilder.cpp 1075 void ScopBuilder::buildPHIAccesses(ScopStmt *PHIStmt, PHINode *PHI,
1097 ScopStmt *OpStmt = scop->getIncomingStmtFor(PHI->getOperandUse(u));
1117 void ScopBuilder::buildScalarDependences(ScopStmt *UserStmt,
1261 for (auto *Stmt : scop->getStmtListFor(RN)) {
1600 bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
1673 bool ScopBuilder::buildAccessMultiDimParam(MemAccInst Inst, ScopStmt *Stmt) {
1724 bool ScopBuilder::buildAccessMemIntrinsic(MemAccInst Inst, ScopStmt *Stmt) {
1793 bool ScopBuilder::buildAccessCallInst(MemAccInst Inst, ScopStmt *Stmt) {
1842 void ScopBuilder::buildAccessSingleDim(MemAccInst Inst, ScopStmt *Stmt) {
1886 void ScopBuilder::buildMemoryAccess(MemAccInst Inst, ScopStmt *Stmt) {
1903 for (auto &Stmt : *scop) {
2210 void ScopBuilder::buildAccessFunctions(ScopStmt *Stmt, BasicBlock &BB,
2263 ScopStmt *Stmt, Instruction *Inst, MemoryAccess::AccessType AccType,
2300 void ScopBuilder::addArrayAccess(ScopStmt *Stmt, MemAccInst MemAccInst,
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);
2536 void ScopBuilder::ensureValueRead(Value *V, ScopStmt *UserStmt) {
2581 void ScopBuilder::ensurePHIWrite(PHINode *PHI, ScopStmt *IncomingStmt,
2618 void ScopBuilder::addPHIReadAccess(ScopStmt *PHIStmt, PHINode *PHI) {
2624 void ScopBuilder::buildDomain(ScopStmt &Stmt) {
2631 void ScopBuilder::collectSurroundingLoops(ScopStmt &Stmt) {
2681 void ScopBuilder::checkForReductions(ScopStmt &Stmt) {
2748 for (ScopStmt &Stmt : *scop)
2761 for (ScopStmt &Stmt : *scop) {
2862 auto &Stmt = *Access->getStatement();
2968 void ScopBuilder::addInvariantLoads(ScopStmt &Stmt,
3089 ScopStmt *Stmt = StoreMA->getStatement();
3161 for (ScopStmt &Stmt : S)
3203 void ScopBuilder::buildAccessRelations(ScopStmt &Stmt) {
3356 for (ScopStmt &Stmt : *scop) {
3552 auto *Stmt = S->getStmtFor(&Inst);
3624 ArrayRef<ScopStmt *> List = scop->getStmtListFor(BB);
3626 ScopStmt *RILStmt = List.front();
3652 ScopStmt *GlobalReadStmt = GlobalReadPair.first;
3673 for (ScopStmt &Stmt : scop->Stmts)
3690 for (ScopStmt &Stmt : *scop) {
tools/polly/lib/Analysis/ScopInfo.cpp 634 isl::basic_map MemoryAccess::createBasicAccessMap(ScopStmt *Statement) {
885 MemoryAccess::MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst,
904 MemoryAccess::MemoryAccess(ScopStmt *Stmt, AccessType AccType, isl::map AccRel)
978 auto *Stmt = getStatement();
1372 raw_ostream &polly::operator<<(raw_ostream &OS, const ScopStmt &S) {
1614 for (ScopStmt &Stmt : *this)
1670 isl::set Scop::getDomainConditions(const ScopStmt *Stmt) const {
1712 void Scop::removeFromStmtMap(ScopStmt &Stmt) {
1737 void Scop::removeStmts(std::function<bool(ScopStmt &)> ShouldDelete,
1992 auto *BasePtrStmt = getStmtFor(PointerBaseInst);
2190 for (const ScopStmt &Stmt : *this) {
2270 for (const ScopStmt &Stmt : *this)
2285 for (ScopStmt &Stmt : *this) {
2348 for (ScopStmt &Stmt : *this) {
2373 auto *Stmt = &Stmts.back();
2386 auto *Stmt = &Stmts.back();
2406 ScopStmt *Scop::addScopStmt(isl::map SourceRel, isl::map TargetRel,
2421 ArrayRef<ScopStmt *> Scop::getStmtListFor(BasicBlock *BB) const {
2428 ScopStmt *Scop::getIncomingStmtFor(const Use &U) const {
2436 if (ScopStmt *IncomingStmt = getStmtFor(IncomingInst))
2445 ScopStmt *Scop::getLastStmtFor(BasicBlock *BB) const {
2446 ArrayRef<ScopStmt *> StmtList = getStmtListFor(BB);
2452 ArrayRef<ScopStmt *> Scop::getStmtListFor(RegionNode *RN) const {
2458 ArrayRef<ScopStmt *> Scop::getStmtListFor(Region *R) const {
2579 for (const ScopStmt &Stmt : *this) {
tools/polly/lib/CodeGen/BlockGenerators.cpp 64 Value *BlockGenerator::trySynthesizeNewValue(ScopStmt &Stmt, Value *Old,
97 Value *BlockGenerator::getNewValue(ScopStmt &Stmt, Value *Old, ValueMapT &BBMap,
214 void BlockGenerator::copyInstScalar(ScopStmt &Stmt, Instruction *Inst,
256 BlockGenerator::generateLocationAccessed(ScopStmt &Stmt, MemAccInst Inst,
267 ScopStmt &Stmt, Loop *L, Value *Pointer, ValueMapT &BBMap,
306 Loop *BlockGenerator::getLoopForStmt(const ScopStmt &Stmt) const {
311 Value *BlockGenerator::generateArrayLoad(ScopStmt &Stmt, LoadInst *Load,
329 void BlockGenerator::generateArrayStore(ScopStmt &Stmt, StoreInst *Store,
350 bool BlockGenerator::canSyntheziseInStmt(ScopStmt &Stmt, Instruction *Inst) {
356 void BlockGenerator::copyInstruction(ScopStmt &Stmt, Instruction *Inst,
416 void BlockGenerator::copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
435 BasicBlock *BlockGenerator::copyBB(ScopStmt &Stmt, BasicBlock *BB,
451 void BlockGenerator::copyBB(ScopStmt &Stmt, BasicBlock *BB, BasicBlock *CopyBB,
557 ScopStmt &Stmt, LoopToScevMapT <S, ValueMapT &BBMap,
582 Value *BlockGenerator::buildContainsCondition(ScopStmt &Stmt,
607 ScopStmt &Stmt, const isl::set &Subdomain, StringRef Subject,
660 void BlockGenerator::generateBeginStmtTrace(ScopStmt &Stmt, LoopToScevMapT <S,
756 ScopStmt &Stmt, LoopToScevMapT <S, ValueMapT &BBMap,
977 for (auto &Stmt : S)
1018 Value *VectorBlockGenerator::getVectorValue(ScopStmt &Stmt, Value *Old,
1050 ScopStmt &Stmt, LoadInst *Load, VectorValueMapT &ScalarMaps,
1080 ScopStmt &Stmt, LoadInst *Load, ValueMapT &BBMap,
1103 ScopStmt &Stmt, LoadInst *Load, VectorValueMapT &ScalarMaps,
1125 ScopStmt &Stmt, LoadInst *Load, ValueMapT &VectorMap,
1159 void VectorBlockGenerator::copyUnaryInst(ScopStmt &Stmt, UnaryInstruction *Inst,
1173 void VectorBlockGenerator::copyBinaryInst(ScopStmt &Stmt, BinaryOperator *Inst,
1190 ScopStmt &Stmt, StoreInst *Store, ValueMapT &VectorMap,
1264 ScopStmt &Stmt, Instruction *Inst, ValueMapT &VectorMap,
1292 ScopStmt &Stmt, Instruction *Inst, ValueMapT &VectorMap,
1335 ScopStmt &Stmt, ValueMapT &VectorBlockMap) {
1354 void VectorBlockGenerator::verifyNoScalarStores(ScopStmt &Stmt) {
1364 ScopStmt &Stmt, __isl_keep isl_id_to_ast_expr *NewAccesses) {
1456 void RegionGenerator::copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
1623 ScopStmt *Stmt = MA->getStatement();
1664 ScopStmt *Stmt = MA->getStatement();
1690 ScopStmt &Stmt, LoopToScevMapT <S, ValueMapT &BBMap,
1737 void RegionGenerator::addOperandToPHI(ScopStmt &Stmt, PHINode *PHI,
1785 void RegionGenerator::copyPHIInstruction(ScopStmt &Stmt, PHINode *PHI,
tools/polly/lib/CodeGen/IslAst.cpp 680 ScopStmt *AccessStmt = (ScopStmt *)CallExprId.get_user();
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 209 const ScopStmt *Stmt, BasicBlock *BB) {
228 void addReferencesFromStmt(const ScopStmt *Stmt, void *UserPtr,
392 ScopStmt *Stmt = (ScopStmt *)isl_id_get_user(Id);
750 ScopStmt *Stmt =
833 IslNodeBuilder::createNewAccesses(ScopStmt *Stmt,
905 ScopStmt *Stmt, LoopToScevMapT <S) {
924 __isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
942 ScopStmt *Stmt, __isl_keep isl_id_to_ast_expr *NewAccesses) {
973 ScopStmt *Stmt;
tools/polly/lib/Exchange/JSONExporter.cpp 149 for (ScopStmt &Stmt : S) {
282 for (ScopStmt &Stmt : S) {
325 for (ScopStmt &Stmt : S) {
363 for (ScopStmt &Stmt : S) {
tools/polly/lib/Support/ScopHelper.cpp 745 bool polly::hasDebugCall(ScopStmt *Stmt) {
tools/polly/lib/Support/VirtualInstruction.cpp 24 ScopStmt *UserStmt = S->getStmtFor(UI);
52 VirtualUse VirtualUse::create(Scop *S, ScopStmt *UserStmt, Loop *UserScope,
199 addInstructionRoots(ScopStmt *Stmt,
227 static void addAccessRoots(ScopStmt *Stmt,
256 static void addRoots(ScopStmt *Stmt,
280 ScopStmt *OnlyLocal = nullptr) {
321 ScopStmt *Stmt = Acc->getStatement();
373 ScopStmt *Stmt = VInst.getStmt();
407 ScopStmt *OnlyLocal) {
414 for (auto &Stmt : *S)
tools/polly/lib/Transform/DeLICM.cpp 788 isl::map makeValInst(Value *Val, ScopStmt *UserStmt, Loop *Scope,
810 auto *WriteStmt = MA->getStatement();
1094 auto *PHIWriteStmt = PHIWrite->getStatement();
1234 for (auto &Stmt : *S) {
tools/polly/lib/Transform/ForwardOpTree.cpp 327 for (auto &Stmt : *S) {
346 MemoryAccess *makeReadArrayAccess(ScopStmt *Stmt, LoadInst *LI,
391 ForwardingDecision forwardKnownLoad(ScopStmt *TargetStmt, Instruction *Inst,
392 ScopStmt *UseStmt, Loop *UseLoop,
393 ScopStmt *DefStmt, Loop *DefLoop,
543 ForwardingDecision reloadKnownContent(ScopStmt *TargetStmt, Instruction *Inst,
544 ScopStmt *UseStmt, Loop *UseLoop,
545 ScopStmt *DefStmt, Loop *DefLoop,
613 ForwardingDecision forwardSpeculatable(ScopStmt *TargetStmt,
615 ScopStmt *DefStmt, Loop *DefLoop,
690 ForwardingDecision forwardTree(ScopStmt *TargetStmt, Value *UseVal,
691 ScopStmt *UseStmt, Loop *UseLoop, bool DoIt) {
692 ScopStmt *DefStmt = nullptr;
800 ScopStmt *Stmt = RA->getStatement();
833 for (ScopStmt &Stmt : *S) {
tools/polly/lib/Transform/MaximalStaticExpansion.cpp 210 for (ScopStmt &Stmt : S) {
tools/polly/lib/Transform/ScheduleOptimizer.cpp 686 auto *Stmt = static_cast<ScopStmt *>(InputDimId.get_user());
771 auto *Stmt = static_cast<ScopStmt *>(InputDimsId.get_user());
1098 auto *Stmt = static_cast<ScopStmt *>(InputDimsId.get_user());
1123 auto *NewStmt = Stmt->getParent()->addScopStmt(
tools/polly/lib/Transform/Simplify.cpp 161 for (auto &Stmt : *S) {
221 for (auto &Stmt : *S) {
395 for (auto &Stmt : *S) {
501 for (ScopStmt &Stmt : *S) {
540 for (ScopStmt &Stmt : *S)
548 ScopStmt *Stmt = MA->getStatement();
556 for (ScopStmt &Stmt : *S) {
608 for (auto &Stmt : *S) {
tools/polly/lib/Transform/ZoneAlgo.cpp 295 static bool onlySameValueWrites(ScopStmt *Stmt) {
321 void ZoneAlgorithm::collectIncompatibleElts(ScopStmt *Stmt,
393 ScopStmt *Stmt = MA->getStatement();
420 ScopStmt *Stmt = MA->getStatement();
449 auto *Stmt = MA->getStatement();
482 isl::map ZoneAlgorithm::computeUseToDefFlowDependency(ScopStmt *UseStmt,
483 ScopStmt *DefStmt) {
600 for (auto &Stmt : *S)
608 isl::map ZoneAlgorithm::getScatterFor(ScopStmt *Stmt) const {
631 isl::set ZoneAlgorithm::getDomainFor(ScopStmt *Stmt) const {
645 isl::map ZoneAlgorithm::getDefToTarget(ScopStmt *DefStmt,
646 ScopStmt *TargetStmt) {
699 isl::map ZoneAlgorithm::getScalarReachingDefinition(ScopStmt *Stmt) {
713 auto *Stmt = static_cast<ScopStmt *>(isl_id_get_user(DomId.get()));
720 isl::map ZoneAlgorithm::makeUnknownForDomain(ScopStmt *Stmt) const {
747 isl::map ZoneAlgorithm::makeValInst(Value *Val, ScopStmt *UserStmt, Loop *Scope,
806 auto *ValStmt = S->getStmtFor(Inst);
873 ScopStmt *UserStmt,
938 auto *IncomingStmt = static_cast<ScopStmt *>(InTupleId.get_user());
969 for (auto &Stmt : *S) {
994 for (ScopStmt &Stmt : *S) {
1016 for (ScopStmt &Stmt : *S) {
1036 ScopStmt *IncomingStmt = MA->getStatement();
1084 for (auto &Stmt : *S) {
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
486 destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/list.tcc 68 typedef _List_node<_Tp> _Node;
74 _Tp* __val = __tmp->_M_valptr();
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/bits/std_function.h 299 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
628 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 123 typedef _Tp value_type;
usr/include/c++/7.4.0/bits/stl_list.h 112 __gnu_cxx::__aligned_membuf<_Tp> _M_storage;
113 _Tp* _M_valptr() { return _M_storage._M_ptr(); }
114 _Tp const* _M_valptr() const { return _M_storage._M_ptr(); }
130 typedef _List_iterator<_Tp> _Self;
131 typedef _List_node<_Tp> _Node;
135 typedef _Tp value_type;
136 typedef _Tp* pointer;
137 typedef _Tp& reference;
209 typedef _List_const_iterator<_Tp> _Self;
210 typedef const _List_node<_Tp> _Node;
211 typedef _List_iterator<_Tp> iterator;
215 typedef _Tp value_type;
216 typedef const _Tp* pointer;
217 typedef const _Tp& reference;
304 rebind<_Tp>::other _Tp_alloc_type;
307 rebind<_List_node<_Tp> >::other _Node_alloc_type;
503 class list : protected _List_base<_Tp, _Alloc>
514 typedef _List_base<_Tp, _Alloc> _Base;
521 typedef _Tp value_type;
526 typedef _List_iterator<_Tp> iterator;
527 typedef _List_const_iterator<_Tp> const_iterator;
537 typedef _List_node<_Tp> _Node;
1587 remove(const _Tp& __value);
usr/include/c++/7.4.0/ext/aligned_buffer.h 52 struct _Tp2 { _Tp _M_t; };
54 alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
69 _Tp*
73 const _Tp*
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 135 construct(_Up* __p, _Args&&... __args)
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
140 destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/type_traits 1633 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1983 { typedef _Up type; };