[polly] r186259 - ScopInfo: Add getTupe() method to MemoryAccess

[Tobias Grosser]

Author: grosser
Date: Sat Jul 13 15:41:24 2013
New Revision: 186259

URL: http://llvm.org/viewvc/llvm-project?rev=186259&view=rev
Log:
ScopInfo: Add getTupe() method to MemoryAccess

We also move the enum to UPPERCASE.

Modified:
    polly/trunk/include/polly/ScopInfo.h
    polly/trunk/lib/Analysis/ScopInfo.cpp

Modified: polly/trunk/include/polly/ScopInfo.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/ScopInfo.h?rev=186259&r1=186258&r2=186259&view=diff
==============================================================================
--- polly/trunk/include/polly/ScopInfo.h (original)
+++ polly/trunk/include/polly/ScopInfo.h Sat Jul 13 15:41:24 2013
@@ -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;

Modified: polly/trunk/lib/Analysis/ScopInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/Analysis/ScopInfo.cpp?rev=186259&r1=186258&r2=186259&view=diff
==============================================================================
--- polly/trunk/lib/Analysis/ScopInfo.cpp (original)
+++ polly/trunk/lib/Analysis/ScopInfo.cpp Sat Jul 13 15:41:24 2013
@@ -288,11 +288,11 @@ MemoryAccess::MemoryAccess(const IRAcces
     // 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 *
 
 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;
   }