[Polly][ScopInfo] Integrate ScalarDefUseChain into polly::Scop. NFC.

[Meinersbur]

Summary

Before this patch, ScalarDefUseChain was a tool used by DeLICM to find all reads and writes of scalar accesses. It iterated once over all accesses and stores the accesses into maps.

By integrating it into the Scop class, we can keep the maps up-to-date without the need for recomputing them. It will be needed for more than DeLICM in the future, such as SCoP simplification, code movement between virtual statements, and array expansion (GSoC project).

Compared to ScalarUseDefChain, we save two maps by finding the ScopStmt a Def/PHIRead must reside in, and use its already existing lookup function to find the MemoryAccess.

[grosser]

LGTM.

lib/Analysis/ScopInfo.cpp

4955 ↗

(On Diff #107325)

Start assert statement with uppercase.

Also "can only BE used after"?

polly/trunk/include/polly/ScopInfo.h

private:
   long ArrayIdx = 0;
 
   /// The smallest statement index not yet assigned.
   long StmtIdx = 0;
 
   /// A number that uniquely represents a Scop within its function
   const int ID;
 
+  /// List of all uses (i.e. read MemoryAccesses) for a MemoryKind::Value
+  /// scalar.
+  DenseMap<const ScopArrayInfo *, SmallVector<MemoryAccess *, 4>> ValueUseAccs;
+
+  /// List of all incoming values (write MemoryAccess) of a MemoryKind::PHI or
+  /// MemoryKind::ExitPHI scalar.
+  DenseMap<const ScopArrayInfo *, SmallVector<MemoryAccess *, 4>>
+      PHIIncomingAccs;
+
   /// Return the ID for a new Scop within a function
   static int getNextID(std::string ParentFunc);
 
   /// Scop constructor; invoked from ScopBuilder::buildScop.
   Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI,
        ScopDetection::DetectionContext &DC, OptimizationRemarkEmitter &ORE);
 
   //@}
ScopStmt *addScopStmt(__isl_take isl_map *SourceRel,
                         __isl_take isl_set *Domain);
 
   /// Add the access function to all MemoryAccess objects of the Scop
   ///        created in this pass.
   void addAccessFunction(MemoryAccess *Access) {
     AccessFunctions.emplace_back(Access);
   }
 
+  /// Add metadata for @p Access.
+  void addAccessData(MemoryAccess *Access);
+
+  /// Remove the metadata stored for @p Access.
+  void removeAccessData(MemoryAccess *Access);
+
   ScalarEvolution *getSE() const;
 
   /// Get the count of parameters used in this Scop.
   ///
   /// @return The count of parameters used in this Scop.
   size_t getNumParams() const { return Parameters.size(); }
 
   /// Take a list of parameters and add the new ones to the scop.
public:
   /// array.
   long getNextArrayIdx() { return ArrayIdx++; }
 
   /// Get the next free statement index.
   ///
   /// This function returns a unique index which can be used to identify a
   /// statement.
   long getNextStmtIdx() { return StmtIdx++; }
+
+  /// Return the MemoryAccess that writes an llvm::Value, represented by a
+  /// ScopArrayInfo.
+  ///
+  /// There can be at most one such MemoryAccess per llvm::Value in the SCoP.
+  /// Zero is possible for read-only values.
+  MemoryAccess *getValueDef(const ScopArrayInfo *SAI) const;
+
+  /// Return all MemoryAccesses that us an llvm::Value, represented by a
+  /// ScopArrayInfo.
+  ArrayRef<MemoryAccess *> getValueUses(const ScopArrayInfo *SAI) const;
+
+  /// Return the MemoryAccess that represents an llvm::PHINode.
+  ///
+  /// ExitPHIs's PHINode is not within the SCoPs. This function returns nullptr
+  /// for them.
+  MemoryAccess *getPHIRead(const ScopArrayInfo *SAI) const;
+
+  /// Return all MemoryAccesses for all incoming statements of a PHINode,
+  /// represented by a ScopArrayInfo.
+  ArrayRef<MemoryAccess *> getPHIIncomings(const ScopArrayInfo *SAI) const;
 };
 
 /// Print Scop scop to raw_ostream O.
 static inline raw_ostream &operator<<(raw_ostream &O, const Scop &scop) {
   scop.print(O);
   return O;
 }
 

polly/trunk/lib/Analysis/ScopInfo.cpp

for (MemoryAccess *Access : MemAccs) {
     else if (Access->isValueKind())
       Ty = MemoryKind::Value;
     else
       Ty = MemoryKind::Array;
 
     auto *SAI = S.getOrCreateScopArrayInfo(Access->getOriginalBaseAddr(),
                                            ElementType, Access->Sizes, Ty);
     Access->buildAccessRelation(SAI);
+    S.addAccessData(Access);
   }
 }
 
 MemoryAccess *ScopStmt::lookupPHIReadOf(PHINode *PHI) const {
   for (auto *MA : *this) {
     if (!MA->isRead())
       continue;
     if (!MA->isLatestAnyPHIKind())
void ScopStmt::removeMemoryAccess(MemoryAccess *MA) {
   // instruction, hence would not be removed by this function. However, it is
   // only used for invariant LoadInst accesses, its arguments are always affine,
   // hence synthesizable, and therefore there are no MemoryKind::Value READ
   // accesses to be removed.
   auto Predicate = [&](MemoryAccess *Acc) {
     return Acc->getAccessInstruction() == MA->getAccessInstruction();
   };
   for (auto *MA : MemAccs) {
-    if (Predicate(MA))
+    if (Predicate(MA)) {
       removeAccessData(MA);
+      Parent.removeAccessData(MA);
+    }
   }
   MemAccs.erase(std::remove_if(MemAccs.begin(), MemAccs.end(), Predicate),
                 MemAccs.end());
   InstructionToAccess.erase(MA->getAccessInstruction());
 }
 
 void ScopStmt::removeSingleMemoryAccess(MemoryAccess *MA) {
   auto MAIt = std::find(MemAccs.begin(), MemAccs.end(), MA);
   assert(MAIt != MemAccs.end());
   MemAccs.erase(MAIt);
 
   removeAccessData(MA);
+  Parent.removeAccessData(MA);
 
   auto It = InstructionToAccess.find(MA->getAccessInstruction());
   if (It != InstructionToAccess.end()) {
     It->second.remove(MA);
     if (It->second.empty())
       InstructionToAccess.erase(MA->getAccessInstruction());
   }
 }

 ScopArrayInfo *Scop::getArrayInfoByName(const std::string BaseName) {
   for (auto &SAI : arrays()) {
     if (SAI->getName() == BaseName)
       return SAI;
   }
   return nullptr;
 }
 
+void Scop::addAccessData(MemoryAccess *Access) {
+  const ScopArrayInfo *SAI = Access->getOriginalScopArrayInfo();
+  assert(SAI && "can only use after access relations have been constructed");
+
+  if (Access->isOriginalValueKind() && Access->isRead())
+    ValueUseAccs[SAI].push_back(Access);
+  else if (Access->isOriginalAnyPHIKind() && Access->isWrite())
+    PHIIncomingAccs[SAI].push_back(Access);
+}
+
+void Scop::removeAccessData(MemoryAccess *Access) {
+  if (Access->isOriginalValueKind() && Access->isRead()) {
+    auto &Uses = ValueUseAccs[Access->getScopArrayInfo()];
+    std::remove(Uses.begin(), Uses.end(), Access);
+  } else if (Access->isOriginalAnyPHIKind() && Access->isWrite()) {
+    auto &Incomings = PHIIncomingAccs[Access->getScopArrayInfo()];
+    std::remove(Incomings.begin(), Incomings.end(), Access);
+  }
+}
+
+MemoryAccess *Scop::getValueDef(const ScopArrayInfo *SAI) const {
+  assert(SAI->isValueKind());
+
+  Instruction *Val = dyn_cast<Instruction>(SAI->getBasePtr());
+  if (!Val)
+    return nullptr;
+
+  ScopStmt *Stmt = getStmtFor(Val);
+  if (!Stmt)
+    return nullptr;
+
+  return Stmt->lookupValueWriteOf(Val);
+}
+
+ArrayRef<MemoryAccess *> Scop::getValueUses(const ScopArrayInfo *SAI) const {
+  assert(SAI->isValueKind());
+  auto It = ValueUseAccs.find(SAI);
+  if (It == ValueUseAccs.end())
+    return {};
+  return It->second;
+}
+
+MemoryAccess *Scop::getPHIRead(const ScopArrayInfo *SAI) const {
+  assert(SAI->isPHIKind() || SAI->isExitPHIKind());
+
+  if (SAI->isExitPHIKind())
+    return nullptr;
+
+  PHINode *PHI = cast<PHINode>(SAI->getBasePtr());
+  ScopStmt *Stmt = getStmtFor(PHI);
+  assert(Stmt && "PHINode must be within the SCoP");
+
+  return Stmt->lookupPHIReadOf(PHI);
+}
+
+ArrayRef<MemoryAccess *> Scop::getPHIIncomings(const ScopArrayInfo *SAI) const {
+  assert(SAI->isPHIKind() || SAI->isExitPHIKind());
+  auto It = PHIIncomingAccs.find(SAI);
+  if (It == PHIIncomingAccs.end())
+    return {};
+  return It->second;
+}
+
 //===----------------------------------------------------------------------===//
 void ScopInfoRegionPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequired<RegionInfoPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
   AU.addRequiredTransitive<ScopDetectionWrapperPass>();
   AU.addRequired<AAResultsWrapperPass>();

polly/trunk/lib/Transform/DeLICM.cpp

 STATISTIC(DeLICMOutOfQuota,
           "Analyses aborted because max_operations was reached");
 STATISTIC(DeLICMIncompatible, "Number of SCoPs incompatible for analysis");
 STATISTIC(MappedValueScalars, "Number of mapped Value scalars");
 STATISTIC(MappedPHIScalars, "Number of mapped PHI scalars");
 STATISTIC(TargetsMapped, "Number of stores used for at least one mapping");
 STATISTIC(DeLICMScopsModified, "Number of SCoPs optimized");
 
-/// Class for keeping track of scalar def-use chains in the polyhedral
-/// representation.
-///
-/// MemoryKind::Value:
-/// There is one definition per llvm::Value or zero (read-only values defined
-/// before the SCoP) and an arbitrary number of reads.
-///
-/// MemoryKind::PHI, MemoryKind::ExitPHI:
-/// There is at least one write (the incoming blocks/stmts) and one
-/// (MemoryKind::PHI) or zero (MemoryKind::ExitPHI) reads per llvm::PHINode.
-class ScalarDefUseChains {
-private:
-  /// The definitions (i.e. write MemoryAccess) of a MemoryKind::Value scalar.
-  DenseMap<const ScopArrayInfo *, MemoryAccess *> ValueDefAccs;
-
-  /// List of all uses (i.e. read MemoryAccesses) for a MemoryKind::Value
-  /// scalar.
-  DenseMap<const ScopArrayInfo *, SmallVector<MemoryAccess *, 4>> ValueUseAccs;
-
-  /// The receiving part (i.e. read MemoryAccess) of a MemoryKind::PHI scalar.
-  DenseMap<const ScopArrayInfo *, MemoryAccess *> PHIReadAccs;
-
-  /// List of all incoming values (write MemoryAccess) of a MemoryKind::PHI or
-  /// MemoryKind::ExitPHI scalar.
-  DenseMap<const ScopArrayInfo *, SmallVector<MemoryAccess *, 4>>
-      PHIIncomingAccs;
-
-public:
-  /// Find the MemoryAccesses that access the ScopArrayInfo-represented memory.
-  ///
-  /// @param S The SCoP to analyze.
-  void compute(Scop *S) {
-    // Purge any previous result.
-    reset();
-
-    for (auto &Stmt : *S) {
-      for (auto *MA : Stmt) {
-        if (MA->isOriginalValueKind() && MA->isWrite()) {
-          auto *SAI = MA->getScopArrayInfo();
-          assert(!ValueDefAccs.count(SAI) &&
-                 "There can be at most one "
-                 "definition per MemoryKind::Value scalar");
-          ValueDefAccs[SAI] = MA;
-        }
-
-        if (MA->isOriginalValueKind() && MA->isRead())
-          ValueUseAccs[MA->getScopArrayInfo()].push_back(MA);
-
-        if (MA->isOriginalAnyPHIKind() && MA->isRead()) {
-          auto *SAI = MA->getScopArrayInfo();
-          assert(!PHIReadAccs.count(SAI) &&
-                 "There must be exactly one read "
-                 "per PHI (that's where the PHINode is)");
-          PHIReadAccs[SAI] = MA;
-        }
-
-        if (MA->isOriginalAnyPHIKind() && MA->isWrite())
-          PHIIncomingAccs[MA->getScopArrayInfo()].push_back(MA);
-      }
-    }
-  }
-
-  /// Free all memory used by the analysis.
-  void reset() {
-    ValueDefAccs.clear();
-    ValueUseAccs.clear();
-    PHIReadAccs.clear();
-    PHIIncomingAccs.clear();
-  }
-
-  MemoryAccess *getValueDef(const ScopArrayInfo *SAI) const {
-    return ValueDefAccs.lookup(SAI);
-  }
-
-  ArrayRef<MemoryAccess *> getValueUses(const ScopArrayInfo *SAI) const {
-    auto It = ValueUseAccs.find(SAI);
-    if (It == ValueUseAccs.end())
-      return {};
-    return It->second;
-  }
-
-  MemoryAccess *getPHIRead(const ScopArrayInfo *SAI) const {
-    return PHIReadAccs.lookup(SAI);
-  }
-
-  ArrayRef<MemoryAccess *> getPHIIncomings(const ScopArrayInfo *SAI) const {
-    auto It = PHIIncomingAccs.find(SAI);
-    if (It == PHIIncomingAccs.end())
-      return {};
-    return It->second;
-  }
-};
-
 isl::union_map computeReachingDefinition(isl::union_map Schedule,
                                          isl::union_map Writes, bool InclDef,
                                          bool InclRedef) {
   return computeReachingWrite(Schedule, Writes, false, InclDef, InclRedef);
 }
 
 isl::union_map computeReachingOverwrite(isl::union_map Schedule,
                                         isl::union_map Writes,

 private:
   /// Knowledge before any transformation took place.
   Knowledge OriginalZone;
 
   /// Current knowledge of the SCoP including all already applied
   /// transformations.
   Knowledge Zone;
 
-  /// For getting the MemoryAccesses that write or read a given scalar.
-  ScalarDefUseChains DefUse;
-
   /// Number of StoreInsts something can be mapped to.
   int NumberOfCompatibleTargets = 0;
 
   /// The number of StoreInsts to which at least one value or PHI has been
   /// mapped to.
   int NumberOfTargetsMapped = 0;
 
   /// The number of llvm::Value mapped to some array element.
private:
   }
 
   /// Determine whether @p SAI is a scalar that can be mapped to an array
   /// element.
   bool isMappable(const ScopArrayInfo *SAI) {
     assert(SAI);
 
     if (SAI->isValueKind()) {
-      auto *MA = DefUse.getValueDef(SAI);
+      auto *MA = S->getValueDef(SAI);
       if (!MA) {
         DEBUG(dbgs()
               << "    Reject because value is read-only within the scop\n");
         return false;
       }
 
       // Mapping if value is used after scop is not supported. The code
       // generator would need to reload the scalar after the scop, but it
if (SAI->isValueKind()) {
           return false;
         }
       }
 
       return true;
     }
 
     if (SAI->isPHIKind()) {
-      auto *MA = DefUse.getPHIRead(SAI);
+      auto *MA = S->getPHIRead(SAI);
       assert(MA);
 
       // Mapping of an incoming block from before the SCoP is not supported by
       // the code generator.
       auto PHI = cast<PHINode>(MA->getAccessInstruction());
       for (auto Incoming : PHI->blocks()) {
         if (!S->contains(Incoming)) {
           DEBUG(dbgs() << "    Reject because at least one incoming block is "
private:
   std::tuple<isl::union_map, isl::map>
   computeValueUses(const ScopArrayInfo *SAI) {
     assert(SAI->isValueKind());
 
     // { DomainRead[] }
     auto Reads = makeEmptyUnionSet();
 
     // Find all uses.
-    for (auto *MA : DefUse.getValueUses(SAI))
+    for (auto *MA : S->getValueUses(SAI))
       Reads =
           give(isl_union_set_add_set(Reads.take(), getDomainFor(MA).take()));
 
     // { DomainRead[] -> Scatter[] }
     auto ReadSchedule = getScatterFor(Reads);
 
-    auto *DefMA = DefUse.getValueDef(SAI);
+    auto *DefMA = S->getValueDef(SAI);
     assert(DefMA);
 
     // { DomainDef[] }
     auto Writes = getDomainFor(DefMA);
 
     // { DomainDef[] -> Scatter[] }
     auto WriteScatter = getScatterFor(Writes);
 
private:
   /// @return { DomainPHIRead[] -> DomainPHIWrite[] }
   isl::union_map computePerPHI(const ScopArrayInfo *SAI) {
     assert(SAI->isPHIKind());
 
     // { DomainPHIWrite[] -> Scatter[] }
     auto PHIWriteScatter = makeEmptyUnionMap();
 
     // Collect all incoming block timepoint.
-    for (auto *MA : DefUse.getPHIIncomings(SAI)) {
+    for (auto *MA : S->getPHIIncomings(SAI)) {
       auto Scatter = getScatterFor(MA);
       PHIWriteScatter =
           give(isl_union_map_add_map(PHIWriteScatter.take(), Scatter.take()));
     }
 
     // { DomainPHIRead[] -> Scatter[] }
-    auto PHIReadScatter = getScatterFor(DefUse.getPHIRead(SAI));
+    auto PHIReadScatter = getScatterFor(S->getPHIRead(SAI));
 
     // { DomainPHIRead[] -> Scatter[] }
     auto BeforeRead = beforeScatter(PHIReadScatter, true);
 
     // { Scatter[] }
     auto WriteTimes = singleton(
         give(isl_union_map_range(PHIWriteScatter.copy())), ScatterSpace);
 
private:
   /// @param SAI       Representation of the scalar's memory to map.
   /// @param TargetElt { Scatter[] -> Element[] }
   ///                  Suggestion where to map a scalar to when at a timepoint.
   ///
   /// @return true if the scalar was successfully mapped.
   bool tryMapValue(const ScopArrayInfo *SAI, isl::map TargetElt) {
     assert(SAI->isValueKind());
 
-    auto *DefMA = DefUse.getValueDef(SAI);
+    auto *DefMA = S->getValueDef(SAI);
     assert(DefMA->isValueKind());
     assert(DefMA->isMustWrite());
     auto *V = DefMA->getAccessValue();
     auto *DefInst = DefMA->getAccessInstruction();
 
     // Stop if the scalar has already been mapped.
     if (!DefMA->getLatestScopArrayInfo()->isValueKind())
       return false;
private:
   /// @param Lifetime  { DomainDef[] -> Zone[] }
   ///                  The lifetime of each llvm::Value definition for
   ///                  reporting.
   /// @param Proposed  Mapping constraints for reporting.
   void mapValue(const ScopArrayInfo *SAI, isl::map DefTarget,
                 isl::union_map UseTarget, isl::map Lifetime,
                 Knowledge Proposed) {
     // Redirect the read accesses.
-    for (auto *MA : DefUse.getValueUses(SAI)) {
+    for (auto *MA : S->getValueUses(SAI)) {
       // { DomainUse[] }
       auto Domain = getDomainFor(MA);
 
       // { DomainUse[] -> Element[] }
       auto NewAccRel = give(isl_union_map_intersect_domain(
           UseTarget.copy(), isl_union_set_from_set(Domain.take())));
       simplify(NewAccRel);
 
       assert(isl_union_map_n_map(NewAccRel.keep()) == 1);
       MA->setNewAccessRelation(isl_map_from_union_map(NewAccRel.take()));
     }
 
-    auto *WA = DefUse.getValueDef(SAI);
+    auto *WA = S->getValueDef(SAI);
     WA->setNewAccessRelation(DefTarget.copy());
     applyLifetime(Proposed);
 
     MappedValueScalars++;
     NumberOfMappedValueScalars += 1;
   }
 
   /// Express the incoming values of a PHI for each incoming statement in an
   /// isl::union_map.
   ///
   /// @param SAI The PHI scalar represented by a ScopArrayInfo.
   ///
   /// @return { PHIWriteDomain[] -> ValInst[] }
   isl::union_map determinePHIWrittenValues(const ScopArrayInfo *SAI) {
     auto Result = makeEmptyUnionMap();
 
     // Collect the incoming values.
-    for (auto *MA : DefUse.getPHIIncomings(SAI)) {
+    for (auto *MA : S->getPHIIncomings(SAI)) {
       // { DomainWrite[] -> ValInst[] }
       isl::union_map ValInst;
       auto *WriteStmt = MA->getStatement();
 
       auto Incoming = MA->getIncoming();
       assert(!Incoming.empty());
       if (Incoming.size() == 1) {
         ValInst = makeValInst(Incoming[0].second, WriteStmt,
private:
   ///
   /// @param SAI       Representation of the scalar's memory to map.
   /// @param TargetElt { Scatter[] -> Element[] }
   ///                  Suggestion where to map the scalar to when at a
   ///                  timepoint.
   ///
   /// @return true if the PHI scalar has been mapped.
   bool tryMapPHI(const ScopArrayInfo *SAI, isl::map TargetElt) {
-    auto *PHIRead = DefUse.getPHIRead(SAI);
+    auto *PHIRead = S->getPHIRead(SAI);
     assert(PHIRead->isPHIKind());
     assert(PHIRead->isRead());
 
     // Skip if already been mapped.
     if (!PHIRead->getLatestScopArrayInfo()->isPHIKind())
       return false;
 
     // { DomainRead[] -> Scatter[] }
bool tryMapPHI(const ScopArrayInfo *SAI, isl::map TargetElt) {
     // { DomainWrite[] -> Element[] }
     auto WritesTarget = give(isl_union_map_reverse(isl_union_map_apply_domain(
         PerPHIWrites.copy(), isl_union_map_from_map(PHITarget.copy()))));
     simplify(WritesTarget);
 
     // { DomainWrite[] }
     auto UniverseWritesDom = give(isl_union_set_empty(ParamSpace.copy()));
 
-    for (auto *MA : DefUse.getPHIIncomings(SAI))
+    for (auto *MA : S->getPHIIncomings(SAI))
       UniverseWritesDom = give(isl_union_set_add_set(UniverseWritesDom.take(),
                                                      getDomainFor(MA).take()));
 
     auto RelevantWritesTarget = WritesTarget;
     if (DelicmOverapproximateWrites)
       WritesTarget = expandMapping(WritesTarget, UniverseWritesDom);
 
     auto ExpandedWritesDom = give(isl_union_map_domain(WritesTarget.copy()));
private:
   ///                    New access target for each PHI incoming write.
   /// @param Lifetime    { DomainRead[] -> Zone[] }
   ///                    The lifetime of each PHI for reporting.
   /// @param Proposed    Mapping constraints for reporting.
   void mapPHI(const ScopArrayInfo *SAI, isl::map ReadTarget,
               isl::union_map WriteTarget, isl::map Lifetime,
               Knowledge Proposed) {
     // Redirect the PHI incoming writes.
-    for (auto *MA : DefUse.getPHIIncomings(SAI)) {
+    for (auto *MA : S->getPHIIncomings(SAI)) {
       // { DomainWrite[] }
       auto Domain = getDomainFor(MA);
 
       // { DomainWrite[] -> Element[] }
       auto NewAccRel = give(isl_union_map_intersect_domain(
           WriteTarget.copy(), isl_union_set_from_set(Domain.take())));
       simplify(NewAccRel);
 
       assert(isl_union_map_n_map(NewAccRel.keep()) == 1);
       MA->setNewAccessRelation(isl_map_from_union_map(NewAccRel.take()));
     }
 
     // Redirect the PHI read.
-    auto *PHIRead = DefUse.getPHIRead(SAI);
+    auto *PHIRead = S->getPHIRead(SAI);
     PHIRead->setNewAccessRelation(ReadTarget.copy());
     applyLifetime(Proposed);
 
     MappedPHIScalars++;
     NumberOfMappedPHIScalars++;
   }
 
   /// Search and map scalars to memory overwritten by @p TargetStoreMA.
while (!Worklist.empty()) {
         continue;
       }
 
       // Try to map MemoryKind::Value scalars.
       if (SAI->isValueKind()) {
         if (!tryMapValue(SAI, EltTarget))
           continue;
 
-        auto *DefAcc = DefUse.getValueDef(SAI);
+        auto *DefAcc = S->getValueDef(SAI);
         ProcessAllIncoming(DefAcc->getStatement());
 
         AnyMapped = true;
         continue;
       }
 
       // Try to map MemoryKind::PHI scalars.
       if (SAI->isPHIKind()) {
         if (!tryMapPHI(SAI, EltTarget))
           continue;
         // Add inputs of all incoming statements to the worklist. Prefer the
         // input accesses of the incoming blocks.
-        for (auto *PHIWrite : DefUse.getPHIIncomings(SAI)) {
+        for (auto *PHIWrite : S->getPHIIncomings(SAI)) {
           auto *PHIWriteStmt = PHIWrite->getStatement();
           bool FoundAny = false;
           for (auto Incoming : PHIWrite->getIncoming()) {
             auto *IncomingInputMA =
                 PHIWriteStmt->lookupInputAccessOf(Incoming.second);
             if (!IncomingInputMA)
               continue;
 
public:
   /// @return True if the computed lifetimes (#Zone) is usable.
   bool computeZone() {
     // Check that nothing strange occurs.
     if (!isCompatibleScop()) {
       DeLICMIncompatible++;
       return false;
     }
 
-    DefUse.compute(S);
     isl::union_set EltUnused;
     isl::union_map EltKnown, EltWritten;
 
     {
       IslMaxOperationsGuard MaxOpGuard(IslCtx.get(), DelicmMaxOps);
 
       computeCommon();