ScopInfo: Add getTupe() method to MemoryAccess

We also move the enum to UPPERCASE.

llvm-svn: 186259

2 files changed, 23 insertions, 18 deletions

diff --git a/polly/include/polly/ScopInfo.h b/polly/include/polly/ScopInfo.h
index 9fc370ce5ce..8c56582f8ea 100755
--- a/polly/include/polly/ScopInfo.h
+++ b/polly/include/polly/ScopInfo.h
@@ -60,11 +60,7 @@ class Comparison;
 //===----------------------------------------------------------------------===//
 /// @brief Represent memory accesses in statements.
 class MemoryAccess {
-  // DO NOT IMPLEMENT
-  MemoryAccess(const MemoryAccess &);
-  // DO NOT IMPLEMENT
-  const MemoryAccess &operator=(const MemoryAccess &);
-
+public:
   /// @brief The access type of a memory access
   ///
   /// There are three kind of access types:
@@ -86,11 +82,17 @@ class MemoryAccess {
   /// contain a new value if there is actually a write or the old value may
   /// remain, if no write happens.
   enum AccessType {
-    Read,
-    MustWrite,
-    MayWrite
+    READ,
+    MUST_WRITE,
+    MAY_WRITE
   };
 
+private:
+  // DO NOT IMPLEMENT
+  MemoryAccess(const MemoryAccess &);
+  // DO NOT IMPLEMENT
+  const MemoryAccess &operator=(const MemoryAccess &);
+
   isl_map *AccessRelation;
   enum AccessType Type;
 
@@ -122,18 +124,21 @@ public:
 
   ~MemoryAccess();
 
+  /// @brief Get the type of a memory access.
+  enum AccessType getType() { return Type; }
+
   /// @brief Is this a read memory access?
-  bool isRead() const { return Type == MemoryAccess::Read; }
+  bool isRead() const { return Type == MemoryAccess::READ; }
 
   /// @brief Is this a must-write memory access?
-  bool isMustWrite() const { return Type == MemoryAccess::MustWrite; }
+  bool isMustWrite() const { return Type == MemoryAccess::MUST_WRITE; }
 
   /// @brief Is this a may-write memory access?
-  bool isMayWrite() const { return Type == MemoryAccess::MayWrite; }
+  bool isMayWrite() const { return Type == MemoryAccess::MAY_WRITE; }
 
   /// @brief Is this a write memory access?
   bool isWrite() const {
-    return Type == MemoryAccess::MustWrite || Type == MemoryAccess::MayWrite;
+    return Type == MemoryAccess::MUST_WRITE || Type == MemoryAccess::MAY_WRITE;
   }
 
   isl_map *getAccessRelation() const;
diff --git a/polly/lib/Analysis/ScopInfo.cpp b/polly/lib/Analysis/ScopInfo.cpp
index acb76a0b564..c0aeb0c0aab 100644
--- a/polly/lib/Analysis/ScopInfo.cpp
+++ b/polly/lib/Analysis/ScopInfo.cpp
@@ -288,11 +288,11 @@ MemoryAccess::MemoryAccess(const IRAccess &Access, const Instruction *AccInst,
     // 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));
-    Type = Access.isRead() ? Read : MayWrite;
+    Type = Access.isRead() ? READ : MAY_WRITE;
     return;
   }
 
-  Type = Access.isRead() ? Read : MustWrite;
+  Type = Access.isRead() ? READ : MUST_WRITE;
 
   isl_pw_aff *Affine = SCEVAffinator::getPwAff(Statement, Access.getOffset());
 
@@ -325,7 +325,7 @@ void MemoryAccess::realignParams() {
 MemoryAccess::MemoryAccess(const Value *BaseAddress, ScopStmt *Statement) {
   newAccessRelation = NULL;
   BaseAddr = BaseAddress;
-  Type = Read;
+  Type = READ;
   statement = Statement;
 
   isl_basic_map *BasicAccessMap = createBasicAccessMap(Statement);
@@ -336,13 +336,13 @@ MemoryAccess::MemoryAccess(const Value *BaseAddress, ScopStmt *Statement) {
 
 void MemoryAccess::print(raw_ostream &OS) const {
   switch (Type) {
-  case Read:
+  case READ:
     OS.indent(12) << "ReadAccess := \n";
     break;
-  case MustWrite:
+  case MUST_WRITE:
     OS.indent(12) << "MustWriteAccess := \n";
     break;
-  case MayWrite:
+  case MAY_WRITE:
     OS.indent(12) << "MayWriteAccess := \n";
     break;
   }