[Polly] Move MAY/MUST write property to IRAccess

[jdoerfert]

217665.

include/polly/TempScopInfo.h

 public:
   Value *BaseAddress;
 
   const SCEV *Offset;
 
   // The type of the scev affine function
   enum TypeKind {
     READ = 0x1,
-    WRITE = 0x2,
+    MUST_WRITE = 0x2,
+    MAY_WRITE = 0x3,
   };
 
 private:
   unsigned ElemBytes;
   TypeKind Type;
   bool IsAffine;
 
 public:
public:
   const SCEV *getOffset() const { return Offset; }
 
   unsigned getElemSizeInBytes() const { return ElemBytes; }
 
   bool isAffine() const { return IsAffine; }
 
   bool isRead() const { return Type == READ; }
 
-  bool isWrite() const { return Type == WRITE; }
+  bool isWrite() const { return Type == MUST_WRITE; }
+
+  bool isMayWrite() const { return Type == MAY_WRITE; }
 
   bool isScalar() const { return Subscripts.size() == 0; }
 
   void print(raw_ostream &OS) const;
 };
 
 class Comparison {
   const SCEV *LHS;

lib/Analysis/ScopInfo.cpp

 }
 //===----------------------------------------------------------------------===//
 
 MemoryAccess::~MemoryAccess() {
   isl_map_free(AccessRelation);
   isl_map_free(newAccessRelation);
 }
 
+static MemoryAccess::AccessType getMemoryAccessType(const IRAccess &Access) {
+  switch (Access.getType()) {
+  case IRAccess::READ:
+    return MemoryAccess::READ;
+  case IRAccess::MUST_WRITE:
+    return MemoryAccess::MUST_WRITE;
+  case IRAccess::MAY_WRITE:
+    return MemoryAccess::MAY_WRITE;
+  }
+  llvm_unreachable("Unknown IRAccess type!");
+}
+
 isl_id *MemoryAccess::getArrayId() const {
   return isl_map_get_tuple_id(AccessRelation, isl_dim_out);
 }
 
 isl_map *MemoryAccess::getAccessRelation() const {
   return isl_map_copy(AccessRelation);
 }
 
void MemoryAccess::assumeNoOutOfBound(const IRAccess &Access) {
   Outside = isl_set_params(Outside);
   Outside = isl_set_complement(Outside);
   Statement->getParent()->addAssumption(Outside);
   isl_space_free(Space);
 }
 
 MemoryAccess::MemoryAccess(const IRAccess &Access, Instruction *AccInst,
                            ScopStmt *Statement)
-    : Statement(Statement), Inst(AccInst), newAccessRelation(nullptr) {
+    : Type(getMemoryAccessType(Access)), Statement(Statement), Inst(AccInst),
+      newAccessRelation(nullptr) {
 
   isl_ctx *Ctx = Statement->getIslCtx();
   BaseAddr = Access.getBase();
   BaseName = getIslCompatibleName("MemRef_", getBaseAddr(), "");
   isl_id *BaseAddrId = isl_id_alloc(Ctx, getBaseName().c_str(), nullptr);
 
   if (!Access.isAffine()) {
     // We overapproximate non-affine accesses with a possible access to the
     // whole array. For read accesses it does not make a difference, if an
     // access must or may happen. However, for write accesses it is important to
     // differentiate between writes that must happen and writes that may happen.
     AccessRelation = isl_map_from_basic_map(createBasicAccessMap(Statement));
     AccessRelation =
         isl_map_set_tuple_id(AccessRelation, isl_dim_out, BaseAddrId);
-    Type = Access.isRead() ? READ : MAY_WRITE;
     return;
   }
 
-  Type = Access.isRead() ? READ : MUST_WRITE;
-
   isl_space *Space = isl_space_alloc(Ctx, 0, Statement->getNumIterators(), 0);
   AccessRelation = isl_map_universe(Space);
 
   for (int i = 0, Size = Access.Subscripts.size(); i < Size; ++i) {
     isl_pw_aff *Affine =
         SCEVAffinator::getPwAff(Statement, Access.Subscripts[i]);
 
     if (Size == 1) {

lib/Analysis/TempScopInfo.cpp

 #define DEBUG_TYPE "polly-analyze-ir"
 
 //===----------------------------------------------------------------------===//
 /// Helper Classes
 
 void IRAccess::print(raw_ostream &OS) const {
   if (isRead())
     OS << "Read ";
-  else
+  else {
+    if (isMayWrite())
+      OS << "May";
     OS << "Write ";
-
+  }
   OS << BaseAddress->getName() << '[' << *Offset << "]\n";
 }
 
 void Comparison::print(raw_ostream &OS) const {
   // Not yet implemented.
 }
 
 /// Helper function to print the condition
IRAccess TempScopInfo::buildIRAccess(Instruction *Inst, Loop *L, Region *R) {
   if (LoadInst *Load = dyn_cast<LoadInst>(Inst)) {
     SizeType = Load->getType();
     Size = TD->getTypeStoreSize(SizeType);
     Type = IRAccess::READ;
   } else {
     StoreInst *Store = cast<StoreInst>(Inst);
     SizeType = Store->getValueOperand()->getType();
     Size = TD->getTypeStoreSize(SizeType);
-    Type = IRAccess::WRITE;
+    Type = IRAccess::MUST_WRITE;
   }
 
   const SCEV *AccessFunction = SE->getSCEVAtScope(getPointerOperand(*Inst), L);
   const SCEVUnknown *BasePointer =
       dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFunction));
 
   assert(BasePointer && "Could not find base pointer");
   AccessFunction = SE->getMinusSCEV(AccessFunction, BasePointer);
   SmallVector<const SCEV *, 4> Subscripts, Sizes;
 
   MemAcc *Acc = InsnToMemAcc[Inst];
   if (PollyDelinearize && Acc)
     return IRAccess(Type, BasePointer->getValue(), AccessFunction, Size, true,
                     Acc->DelinearizedSubscripts, Acc->Shape->DelinearizedSizes);
 
   bool IsAffine = isAffineExpr(R, AccessFunction, *SE, BasePointer->getValue());
   Subscripts.push_back(AccessFunction);
+  if (!IsAffine && Type == IRAccess::MUST_WRITE)
+    Type = IRAccess::MAY_WRITE;
+
   Sizes.push_back(SE->getConstant(ZeroOffset->getType(), Size));
   return IRAccess(Type, BasePointer->getValue(), AccessFunction, Size, IsAffine,
                   Subscripts, Sizes);
 }
 
 void TempScopInfo::buildAccessFunctions(Region &R, BasicBlock &BB) {
   AccFuncSetType Functions;
   Loop *L = LI->getLoopFor(&BB);
 
   for (BasicBlock::iterator I = BB.begin(), E = --BB.end(); I != E; ++I) {
     Instruction *Inst = I;
     if (isa<LoadInst>(Inst) || isa<StoreInst>(Inst))
       Functions.push_back(std::make_pair(buildIRAccess(Inst, L, &R), Inst));
 
     if (!isa<StoreInst>(Inst) && buildScalarDependences(Inst, &R)) {
       // If the Instruction is used outside the statement, we need to build the
       // write access.
       SmallVector<const SCEV *, 4> Subscripts, Sizes;
-      IRAccess ScalarAccess(IRAccess::WRITE, Inst, ZeroOffset, 1, true,
+      IRAccess ScalarAccess(IRAccess::MUST_WRITE, Inst, ZeroOffset, 1, true,
                             Subscripts, Sizes);
       Functions.push_back(std::make_pair(ScalarAccess, Inst));
     }
   }
 
   if (Functions.empty())
     return;