Lines Matching defs:MemoryAccess

1454   enum MemoryAccess::AccessType AccType =
1455       isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
1520   enum MemoryAccess::AccessType AccType =
1521       isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
1607   addArrayAccess(Stmt, Inst, MemoryAccess::MUST_WRITE, DestPtrSCEV->getValue(),
1629   addArrayAccess(Stmt, Inst, MemoryAccess::READ, SrcPtrSCEV->getValue(),
1655         !isModSet(ArgMR) ? MemoryAccess::READ : MemoryAccess::MAY_WRITE;
1692   enum MemoryAccess::AccessType AccType =
1693       isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
1725   if (!IsAffine && AccType == MemoryAccess::MUST_WRITE)
1726     AccType = MemoryAccess::MAY_WRITE;
2114 MemoryAccess *ScopBuilder::addMemoryAccess(
2115     ScopStmt *Stmt, Instruction *Inst, MemoryAccess::AccessType AccType,
2141   if (!isKnownMustAccess && AccType == MemoryAccess::MUST_WRITE)
2142     AccType = MemoryAccess::MAY_WRITE;
2144   auto *Access = new MemoryAccess(Stmt, Inst, AccType, BaseAddress, ElementType,
2153                                  MemoryAccess::AccessType AccType,
2302     for (MemoryAccess *Access : Stmt) {
2364   addMemoryAccess(Stmt, Inst, MemoryAccess::MUST_WRITE, Inst, Inst->getType(),
2372   // In a first step, the MemoryAccess is created, but without the
2387     // Uses of these kinds do not need a MemoryAccess.
2391     // Add MemoryAccess for invariant values only if requested.
2398     // Do not create another MemoryAccess for reloading the value if one already
2403     addMemoryAccess(UserStmt, nullptr, MemoryAccess::READ, V, V->getType(),
2436   // Do not add more than one MemoryAccess per PHINode and ScopStmt.
2437   if (MemoryAccess *Acc = IncomingStmt->lookupPHIWriteOf(PHI)) {
2443   MemoryAccess *Acc = addMemoryAccess(
2444       IncomingStmt, PHI, MemoryAccess::MUST_WRITE, PHI, PHI->getType(), true,
2452   addMemoryAccess(PHIStmt, PHI, MemoryAccess::READ, PHI, PHI->getType(), true,
2484 static MemoryAccess::ReductionType
2487     return MemoryAccess::RT_NONE;
2491       return MemoryAccess::RT_NONE;
2494     return MemoryAccess::RT_ADD;
2496     return MemoryAccess::RT_BOR;
2498     return MemoryAccess::RT_BXOR;
2500     return MemoryAccess::RT_BAND;
2503       return MemoryAccess::RT_NONE;
2507       return MemoryAccess::RT_NONE;
2508     return MemoryAccess::RT_MUL;
2510     return MemoryAccess::RT_NONE;
2515 static MemoryAccess::ReductionType
2516 combineReductionType(MemoryAccess::ReductionType RT0,
2517                      MemoryAccess::ReductionType RT1) {
2518   if (RT0 == MemoryAccess::RT_BOTTOM)
2522   return MemoryAccess::RT_NONE;
2527 bool hasIntersectingAccesses(isl::set AllAccs, MemoryAccess *LoadMA,
2528                              MemoryAccess *StoreMA, isl::set Domain,
2529                              SmallVector<MemoryAccess *, 8> &MemAccs) {
2533   for (MemoryAccess *MA : MemAccs) {
2552 bool checkCandidatePairAccesses(MemoryAccess *LoadMA, MemoryAccess *StoreMA,
2554                                 SmallVector<MemoryAccess *, 8> &MemAccs) {
2600   using StatePairTy = std::pair<unsigned, MemoryAccess::ReductionType>;
2647             std::make_pair(Load, std::make_pair(1, MemoryAccess::RT_BOTTOM)));
2670       MemoryAccess::ReductionType CurRedType = getReductionType(BinOp);
2694           MemoryAccess::ReductionType OpRedType = OpInFlowPair.second.second;
2695           MemoryAccess::ReductionType InstRedType =
2698           MemoryAccess::ReductionType NewRedType =
2723   using MemAccPair = std::pair<MemoryAccess *, MemoryAccess *>;
2724   DenseMap<MemAccPair, MemoryAccess::ReductionType> ValidCandidates;
2728   for (MemoryAccess *WriteMA : Stmt.MemAccs) {
2738       MemoryAccess *ReadMA = &Stmt.getArrayAccessFor(MaInFlowSetElem.first);
2747       MemoryAccess::ReductionType RT = MaInFlowSetElem.second.second;
2754       Valid = Valid && RT != MemoryAccess::RT_BOTTOM;
2755       Valid = Valid && RT != MemoryAccess::RT_NONE;
2772     MemoryAccess *LoadMA = CandidatePair.first.first;
2781     MemoryAccess::ReductionType RT = CandidatePair.second;
2809     for (MemoryAccess *Access : Stmt) {
2848 bool ScopBuilder::hasNonHoistableBasePtrInScop(MemoryAccess *MA,
2903 isl::set ScopBuilder::getNonHoistableCtx(MemoryAccess *Access,
2981 bool ScopBuilder::canAlwaysBeHoisted(MemoryAccess *MA,
3143   for (MemoryAccess *Access : Accesses) {
3155     for (MemoryAccess *Access2 : EqClass2.InvariantAccesses)
3166     for (MemoryAccess *Access : Stmt) {
3187     for (MemoryAccess *BasePtrAccess : BasePtrAccesses) {
3208   for (MemoryAccess *Access : Stmt.MemAccs) {
3328   for (MemoryAccess *MA : AliasGroup)
3344 static isl::set getAccessDomain(MemoryAccess *MA) {
3378   DenseMap<Value *, MemoryAccess *> PtrToAcc;
3389     for (MemoryAccess *MA : Stmt) {
3460   for (MemoryAccess *Access : AliasGroup) {
3485   for (MemoryAccess *MA : AliasGroup) {
3495   for (MemoryAccess *MA : AliasGroup) {
3496     if (MemoryAccess *BasePtrMA = scop->lookupBasePtrAccess(MA))
3536       MemoryAccess *MA = *AGI;
3562 /// kind of use (derived from a statement's MemoryAccess).
3645       // Invariant loads require a MemoryAccess to be created in some statement.
3646       // It is not important to which statement the MemoryAccess is added
3680       addArrayAccess(GlobalReadStmt, MemAccInst(GlobalRead), MemoryAccess::READ,