[Polly][Refactor][NFC] Generalize the creation of ScopArrayInfo objects.

[jdoerfert]

The idea here is that we do not need an IRAccess (on of those temporary objects we produce) to generate the ScopArrayInfo object but only the actual array base pointer/type and dimension sizes.

[jdoerfert]

Closed by commit rL221512 (authored by @jdoerfert).

polly/trunk/include/polly/ScopInfo.h

public:
 
   reverse_iterator rbegin() { return Stmts.rbegin(); }
   reverse_iterator rend() { return Stmts.rend(); }
   const_reverse_iterator rbegin() const { return Stmts.rbegin(); }
   const_reverse_iterator rend() const { return Stmts.rend(); }
   //@}
 
   /// @brief Return the (possibly new) ScopArrayInfo object for @p Access.
-  const ScopArrayInfo *getOrCreateScopArrayInfo(const IRAccess &Access,
-                                                Instruction *AccessInst);
+  const ScopArrayInfo *
+  getOrCreateScopArrayInfo(Value *BasePtr, Type *AccessType,
+                           const SmallVector<const SCEV *, 4> &Sizes);
 
   /// @brief Return the cached ScopArrayInfo object for @p BasePtr.
   const ScopArrayInfo *getScopArrayInfo(Value *BasePtr);
 
   void setContext(isl_set *NewContext);
 
   /// @brief Align the parameters in the statement to the scop context
   void realignParams();

polly/trunk/include/polly/Support/ScopHelper.h

 // Small functions that help with LLVM-IR.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef POLLY_SUPPORT_IRHELPER_H
 #define POLLY_SUPPORT_IRHELPER_H
 
 namespace llvm {
+class Type;
 class Instruction;
 class LoopInfo;
 class Loop;
 class ScalarEvolution;
 class SCEV;
 class Value;
 class PHINode;
 class Region;

 /// @return If the PHINode has an incoming BB that jumps to the parent BB
 ///         of the PHINode with an invoke instruction, return true,
 ///         otherwise, return false.
 bool hasInvokeEdge(const llvm::PHINode *PN);
 
 llvm::Value *getPointerOperand(llvm::Instruction &Inst);
 llvm::BasicBlock *createSingleExitEdge(llvm::Region *R, llvm::Pass *P);
 
+/// @brief Return the type of the access.
+llvm::Type *getAccessInstType(llvm::Instruction *AccInst);
+
 /// @brief Simplify the region in a SCoP to have a single unconditional entry
 ///        edge and a single exit edge.
 ///
 /// @param S  The SCoP that is simplified.
 /// @param P  The pass that is currently running.
 ///
 /// @return The unique entering block for the region.
 llvm::BasicBlock *simplifyRegion(polly::Scop *S, llvm::Pass *P);

polly/trunk/lib/Analysis/ScopInfo.cpp

void ScopStmt::buildScattering(SmallVectorImpl<unsigned> &Scatter) {
   Scattering = isl_map_align_params(Scattering, Parent.getParamSpace());
 }
 
 void ScopStmt::buildAccesses(TempScop &tempScop) {
   for (const auto &AccessPair : *tempScop.getAccessFunctions(BB)) {
     const IRAccess &Access = AccessPair.first;
     Instruction *AccessInst = AccessPair.second;
 
-    const ScopArrayInfo *SAI =
-        getParent()->getOrCreateScopArrayInfo(Access, AccessInst);
+    Type *AccessType = getAccessInstType(AccessInst)->getPointerTo();
+    const ScopArrayInfo *SAI = getParent()->getOrCreateScopArrayInfo(
+        Access.getBase(), AccessType, Access.Sizes);
+
     MemAccs.push_back(new MemoryAccess(Access, AccessInst, this, SAI));
 
     // We do not track locations for scalar memory accesses at the moment.
     //
     // We do not have a use for this information at the moment. If we need this
     // at some point, the "instruction -> access" mapping needs to be enhanced
     // as a single instruction could then possibly perform multiple accesses.
     if (!Access.isScalar()) {
for (MinMaxVectorTy *MinMaxAccesses : MinMaxAliasGroups) {
     for (MinMaxAccessTy &MMA : *MinMaxAccesses) {
       isl_pw_multi_aff_free(MMA.first);
       isl_pw_multi_aff_free(MMA.second);
     }
     delete MinMaxAccesses;
   }
 }
 
-const ScopArrayInfo *Scop::getOrCreateScopArrayInfo(const IRAccess &Access,
-                                                    Instruction *AccessInst) {
-  Value *BasePtr = Access.getBase();
+const ScopArrayInfo *
+Scop::getOrCreateScopArrayInfo(Value *BasePtr, Type *AccessType,
+                               const SmallVector<const SCEV *, 4> &Sizes) {
   const ScopArrayInfo *&SAI = ScopArrayInfoMap[BasePtr];
-  if (!SAI) {
-    Type *AccessType = getPointerOperand(*AccessInst)->getType();
-    SAI = new ScopArrayInfo(BasePtr, AccessType, getIslCtx(), Access.Sizes);
-  }
+  if (!SAI)
+    SAI = new ScopArrayInfo(BasePtr, AccessType, getIslCtx(), Sizes);
   return SAI;
 }
 
 const ScopArrayInfo *Scop::getScopArrayInfo(Value *BasePtr) {
   const SCEV *PtrSCEV = SE->getSCEV(BasePtr);
   const SCEVUnknown *PtrBaseSCEV =
       cast<SCEVUnknown>(SE->getPointerBase(PtrSCEV));
   const ScopArrayInfo *SAI = ScopArrayInfoMap[PtrBaseSCEV->getValue()];

polly/trunk/lib/Support/ScopHelper.cpp

Value *polly::getPointerOperand(Instruction &Inst) {
   else if (StoreInst *store = dyn_cast<StoreInst>(&Inst))
     return store->getPointerOperand();
   else if (GetElementPtrInst *gep = dyn_cast<GetElementPtrInst>(&Inst))
     return gep->getPointerOperand();
 
   return 0;
 }
 
+Type *polly::getAccessInstType(Instruction *AccInst) {
+  if (StoreInst *Store = dyn_cast<StoreInst>(AccInst))
+    return Store->getValueOperand()->getType();
+  return AccInst->getType();
+}
+
 bool polly::hasInvokeEdge(const PHINode *PN) {
   for (unsigned i = 0, e = PN->getNumIncomingValues(); i < e; ++i)
     if (InvokeInst *II = dyn_cast<InvokeInst>(PN->getIncomingValue(i)))
       if (II->getParent() == PN->getIncomingBlock(i))
         return true;
 
   return false;
 }