[Polly] ScopInfo: Harmonize the different ARRAY_KINDs

[grosser]

Summary

Over time different vocabulary has been introduced to describe the different
memory objects in Polly, resulting in different - often inconsistent - naming
schemes in different parts of Polly. We now standartize this to the following
scheme:

KIND_ARRAY, KIND_VALUE, KIND_PHI, KIND_EXIT_PHI
            | ---------- isScalar ------------|

In most cases this naming scheme has already been used previously (this
minimizes changes and ensures we remain consistent with previous publications).
The main change is that we remove KIND_SCALAR to clearify the difference between
a scalar as a memory object of kind VALUE, PHI or EXIT_PHI and a value (former
KIND_SCALAR) which is a memory object modeling a llvm::Value.

We also move all documentation to the KIND_* enum in the ScopArrayInfo class,
remove the second enum in the MemoryAccess class and update documentation to be
formulated from the perspective of the memory object, rather than the memory
access. The terms "Implicit"/"Explicit", formerly used to describe memory
accesses, have been dropped. From the perspective of memory accesses they
described the different memory kinds well - especially from the perspective of
code generation - but just from the perspective of a memory object it seems more
straightforward to talk about scalars and arrays, rather than explicit and
implicit arrays. The last comment is clearly subjective, though. A less
subjective reason to go for these terms is the historic use both in mailing list
discussions and publications.

---

This is a first draft of a possible harmonization. I originally intended to use
'implicit' instead of scalar, but when going through the code (and the test
cases) the noise this caused got pretty large. Hence, I just used the term
"VALUE" as proposed by Michael instead of "scalar" as name of our 'standard
scalar'. I am pretty happy with this for now, but clearly additional comments
are still welcome.

[Meinersbur]

I welcome any consistent naming scheme.

MemoryAccess::print still prints "[SCALAR: 0]" or "[SCALAR: 1]". It should maybe print the kind instead, although this requires a lot of unit tests to change.

KIND_VALUE fits because it originates from an llvm::Value, analogously to a KIND_PHI originating from an llvm:PHINode. The reason I did not name like this in my first commit is that we have WRITE MemoryAccesses to such "values", but values are not written to (like variables), but defined.

I kind of liked the distinction of implicit/explicit (i.e. whether it comes from an explicit LoadInst/StoreInst or it is a result of how we model scalars), but it might also be orthogonal to the array kind.

include/polly/ScopInfo.h

119

array of arbitrary dimensionality.

multi-dimensional could be understood as at least 2 dimensions.

600–601

ScopArrayInfo::KIND, ARRAYKIND, KIND_ARRAY is confusing.

I don't think ScopArrayInfo::KIND is too long to require a typedef, but if, it should have the same name as the declaration in ScopArrayInfo. The individual values (e.g. ScopArrayInfo::KIND_ARRAY) still need to be fully qualified.

LLVM's style guide says the enum type names should not be all caps, and uses "Kind" as suffix instead of prefix.

696

The function name sounds gramatically wrong.

[grosser]

In D15307#305845, @Meinersbur wrote:

I welcome any consistent naming scheme.

MemoryAccess::print still prints "[SCALAR: 0]" or "[SCALAR: 1]". It should maybe print the kind instead, although this requires a lot of unit tests to change.

Scalar:0 and Scalar: 1 is technically not wrong, but clearly we code print more precise information. However, this seems to be a separate patch (especially due to the unit-test noise it will cause).

KIND_VALUE fits because it originates from an llvm::Value, analogously to a KIND_PHI originating from an llvm:PHINode. The reason I did not name like this in my first commit is that we have WRITE MemoryAccesses to such "values", but values are not written to (like variables), but defined.

You are right that values are not written. Still, I am very happy with this name due to the llvm::Value correspondance.

I kind of liked the distinction of implicit/explicit (i.e. whether it comes from an explicit LoadInst/StoreInst or it is a result of how we model scalars), but it might also be orthogonal to the array kind.

Right.

include/polly/ScopInfo.h

119

Now:

"Models a one or multi-dimensional array"

600–601

ScopArrayInfo::KIND, ARRAYKIND, KIND_ARRAY is confusing.

We are now left with ScopArrayInfo::MemoryKind and
ScopArrayInfo::MK_Array.

I don't think ScopArrayInfo::KIND is too long to require a
typedef, but if, it should have the same name as the
declaration in ScopArrayInfo. The individual values (e.g.
ScopArrayInfo::KIND_ARRAY) still need to be fully
qualified.

I dropped the typedef.

LLVM's style guide says the enum type names should
not be all caps, and uses "Kind" as suffix instead of
prefix.

I now follow the llvm style guide:

"Enumerators (e.g. enum { Foo, Bar }) and public member variables should start with an upper-case letter, just like types"

"enumerators should have a prefix corresponding to the enum declaration name. For example, enum ValueKind { ... }; may contain enumerators like VK_Argument, VK_BasicBlock, etc"

696

I now moved to hasKindArray(). Does this sound better?

I could also use isArrayKind(), but I would like the different Kind* functions to be close by alphabetically such that they can be easy found when autocompleting.

[grosser]

Addressed Michael's comments

[grosser]

Add some missed KindValue -> MK_Value transformations

[Meinersbur]

include/polly/ScopInfo.h

309

Rename to hasKindPHI() for consistency with MemoryAccess::hasKindPHI?

600–602

The style guide also seem to prefer consistency with existing styles. enum AccessType uses all caps values. We could change it as well (in a different patch).

696

Personally, I'd prefer isArrayKind() or isArrayAccess(). No objective reasons.

[grosser]

Address Michael's comments:

• Use isArrayKind instead of hasKindArray
• Rename is PHI to isPHIKind for consistency

[grosser]

Hi Michael,

thank your for your comments. The latest patch should address all your comments. Can you have a final look?

include/polly/ScopInfo.h

309

Changed.

600–602

Good idea.

696

I do not feel strong about this. Changed to isArrayKind.

[grosser]

Missed the hasKindValue -> isValueKind update

[Meinersbur]

Don't you want to wait for a third opinion?

include/polly/ScopInfo.h

144

llvm::Value %V is depicted below

174

Something seems to have gone wrong after clang-format

218

READs

696

Me neither; Code completion in Visual Studio will suggest isXXXKind when typing isKind.

[grosser]

• Fix clang-format issue
• READss

llvm::Value %V is depicted below

The sentence continues accross the picture, where there is also the relevant
'is' you are looking for.

Don't you want to wait for a third opinion?

Yes, I would appreciate a comment from someone else. Just wanted to make sure
you know I wanted to get still feedback on the final version.

[jdoerfert]

LGTM.

[grosser]

Committed in https://llvm.org/svn/llvm-project/polly/trunk@255467

(I forgot to add the phabricator review in the commit message)

include/polly/ScopInfo.h

 
 /// @brief A class to store information about arrays in the SCoP.
 ///
 /// Objects are accessible via the ScoP, MemoryAccess or the id associated with
 /// the MemoryAccess access function.
 ///
 class ScopArrayInfo {
 public:
-  /// @brief The type of a memory access.
-  enum ARRAYKIND {
-    // Scalar references to SSA values.
-    KIND_SCALAR,
-
-    // Scalar references used to model PHI nodes
-    KIND_PHI,
-
-    // Like KIND_PHI, but for PHIs in the exit node. Depending on context, these
-    // are handled like KIND_SCALAR.
-    KIND_EXIT_PHI,
+  /// @brief The kind of a ScopArrayInfo memory object.
+  ///
+  /// We distinguish between arrays and various scalar memory objects. We use
+  /// the term ``array'' to describe memory objects that consist of a set of
+  /// individual data elements arranged in a multi-dimensional grid. A scalar
+  /// memory object describes an individual data element and is used to model
+  /// the definition and uses of llvm::Values.
+  ///
+  /// The polyhedral model does traditionally not reason about SSA values. To
+  /// reason about llvm::Values we model them "as if" they were zero-dimensional
+  /// memory objects, even though they were not actually allocated in (main)
+  /// memory.  Memory for such objects is only alloca[ed] at CodeGeneration
+  /// time. To relate the memory slots used during code generation with the
+  /// llvm::Values they belong to the new names for these corresponding stack
+  /// slots are derived by appending suffixes (currently ".s2a" and ".phiops")
+  /// to the name of the original llvm::Value. To describe how def/uses are
+  /// modeled exactly we use these suffixes here as well.
+  ///
+  /// There are currently four different kinds of memory objects:
+  enum MemoryKind {
+    /// MK_Array: Models a one or multi-dimensional array
+    ///
+    /// A memory object that can be described by a multi-dimensional array.
+    /// Memory objects of this type are used to model actual multi-dimensional
+    /// arrays as they exist in LLVM-IR, but they are also used to describe
+    /// other objects:
+    ///   - A single data element allocated on the stack using 'alloca' is
+    ///     modeled as a one-dimensional, single-element array.
+    ///   - A single data element allocated as a global variable is modeled as
+    ///     one-dimensional, single-element array.
+    ///   - Certain multi-dimensional arrays with variable size, which in
+    ///     LLVM-IR are commonly expressed as a single-dimensional access with a
+    ///     complicated access function, are modeled as multi-dimensional
+    ///     memory objects (grep for "delinearization").
+    MK_Array,
+
+    /// MK_Value: Models an llvm::Value
+    ///
+    /// Memory objects of type MK_Value are used to model the data flow
+    /// induced by llvm::Values. For each llvm::Value that is used across
+    /// BasicBocks one ScopArrayInfo object is created. A single memory WRITE
+    /// stores the llvm::Value at its definition into the memory object and at
+    /// each use of the llvm::Value (ignoring trivial intra-block uses) a
+    /// corresponding READ is added. For instance, the use/def chain of a
+    /// llvm::Value %V depicted below
+    ///              ______________________
+    ///              |DefBB:              |
+    ///              |  %V = float op ... |
+    ///              ----------------------
+    ///               |                  |
+    /// _________________               _________________
+    /// |UseBB1:        |               |UseBB2:        |
+    /// |  use float %V |               |  use float %V |
+    /// -----------------               -----------------
+    ///
+    /// is modeled as if the following memory accesses occured:
+    ///
+    ///                        __________________________
+    ///                        |entry:                  |
+    ///                        |  %V.s2a = alloca float |
+    ///                        --------------------------
+    ///                                     |
+    ///                    ___________________________________
+    ///                    |DefBB:                           |
+    ///                    |  store %float %V, float* %V.sa2 |
+    ///                    -----------------------------------
+    ///                           |                   |
+    /// ____________________________________ ___________________________________
+    /// |UseBB1:                           | |UseBB2:                          |
+    /// |  %V.reload1 = load float* %V.s2a | |  %V.reload2 = load float* %V.s2a|
+    /// |  use float %V.reload1            | |  use float %V.reload2           |
+    /// ------------------------------------ -----------------------------------
+    ///
+    MK_Value,
 
-    // References to (multi-dimensional) arrays
-    KIND_ARRAY,
+    /// MK_PHI: Models PHI nodes within the SCoP
+    ///
+    /// Besides the MK_Value memory object used to model the normal
+    /// llvm::Value dependences described above, PHI nodes require an additional
+    /// memory object of type MK_PHI to describe the forwarding of values to
+    /// the PHI node.
+    ///
+    /// As an example, a PHIInst instructions
+    ///
+    /// %PHI = phi float [ %Val1, %IncomingBlock1 ], [ %Val2, %IncomingBlock2 ]
+    ///
+    /// is modeled as if the accesses occured this way:
+    ///
+    ///                    _______________________________
+    ///                    |entry:                       |
+    ///                    |  %PHI.phiops = alloca float |
+    ///                    -------------------------------
+    ///                           |              |
+    /// __________________________________  __________________________________
+    /// |IncomingBlock1:                 |  |IncomingBlock2:                 |
+    /// |  ...                           |  |  ...                           |
+    /// |  store float %Val1 %PHI.phiops |  |  store float %Val2 %PHI.phiops |
+    /// |  br label % JoinBlock          |  |  br label %JoinBlock           |
+    /// ----------------------------------  ----------------------------------
+    ///                             \            /
+    ///                              \          /
+    ///               _________________________________________
+    ///               |JoinBlock:                             |
+    ///               |  %PHI = load float, float* PHI.phiops |
+    ///               -----------------------------------------
+    ///
+    /// Note that there can also be a scalar write access for %PHI if used in a
+    /// different BasicBlock, i.e. there can be a memory object %PHI.phiops as
+    /// well as a memory object %PHI.s2a.
+    MK_PHI,
+
+    /// MK_ExitPHI: Models PHI nodes in the SCoP's exit block
+    ///
+    /// For PHI nodes in the Scop's exit block a special memory object kind is
+    /// used. The modeling used is identical to MK_PHI, with the exception
+    /// that there are no READs from these memory objects. The PHINode's
+    /// llvm::Value is treated as a value escaping the SCoP. WRITE accesses
+    /// write directly to the escaping value's ".s2a" alloca.
+    MK_ExitPHI
   };
 
   /// @brief Construct a ScopArrayInfo object.
   ///
   /// @param BasePtr        The array base pointer.
   /// @param ElementType    The type of the elements stored in the array.
   /// @param IslCtx         The isl context used to create the base pointer id.
   /// @param DimensionSizes A vector containing the size of each dimension.
   /// @param Kind           The kind of the array object.
   /// @param DL             The data layout of the module.
   /// @param S              The scop this array object belongs to.
   ScopArrayInfo(Value *BasePtr, Type *ElementType, isl_ctx *IslCtx,
-                ArrayRef<const SCEV *> DimensionSizes, enum ARRAYKIND Kind,
+                ArrayRef<const SCEV *> DimensionSizes, enum MemoryKind Kind,
                 const DataLayout &DL, Scop *S);
 
   ///  @brief Update the sizes of the ScopArrayInfo object.
   ///
   ///  A ScopArrayInfo object may with certain outer dimensions not being added
   ///  on the first creation. This function allows to update the sizes of the
   ///  ScopArrayInfo object by adding additional outer array dimensions.
   ///
public:
   /// During code generation of PHI nodes, there is a need for two kinds of
   /// virtual storage. The normal one as it is used for all scalar dependences,
   /// where the result of the PHI node is stored and later loaded from as well
   /// as a second one where the incoming values of the PHI nodes are stored
   /// into and reloaded when the PHI is executed. As both memories use the
   /// original PHI node as virtual base pointer, we have this additional
   /// attribute to distinguish the PHI node specific array modeling from the
   /// normal scalar array modeling.
-  bool isPHI() const { return Kind == KIND_PHI; };
+  bool isPHIKind() const { return Kind == MK_PHI; };
 
   /// @brief Dump a readable representation to stderr.
   void dump() const;
 
   /// @brief Print a readable representation to @p OS.
   ///
   /// @param SizeAsPwAff Print the size as isl_pw_aff
   void print(raw_ostream &OS, bool SizeAsPwAff = false) const;
private:
   SmallVector<const SCEV *, 4> DimensionSizes;
 
   /// @brief The sizes of each dimension as isl_pw_aff.
   SmallVector<isl_pw_aff *, 4> DimensionSizesPw;
 
   /// @brief The type of this scop array info object.
   ///
   /// We distinguish between SCALAR, PHI and ARRAY objects.
-  enum ARRAYKIND Kind;
+  enum MemoryKind Kind;
 
   /// @brief The data layout of the module.
   const DataLayout &DL;
 
   /// @brief The scop this SAI object belongs to.
   Scop &S;
 };
 
 /// @brief Represent memory accesses in statements.
 class MemoryAccess {
   friend class Scop;
   friend class ScopStmt;
 
 public:
-  /// @brief Description of the cause of a MemoryAccess being added.
-  ///
-  /// We distinguish between explicit and implicit accesses. Explicit are those
-  /// for which there is a load or store instruction in the analyzed IR.
-  /// Implicit accesses are derived from defintions and uses of llvm::Values.
-  /// The polyhedral model has no notion of such values or SSA form, hence they
-  /// are modeled "as if" they were accesses to zero-dimensional arrays even if
-  /// they do represent accesses to (main) memory in the analyzed IR code. The
-  /// actual memory for the zero-dimensional arrays is only created using
-  /// allocas at CodeGeneration, with suffixes (currently ".s2a" and ".phiops")
-  /// added to the value's name. To describe how def/uses are modeled using
-  /// accesses we use these these suffixes here as well.
-  /// There are currently three separate kinds of access origins:
-  ///
-  ///
-  /// * Explicit access
-  ///
-  /// Memory is accessed by either a load (READ) or store (*_WRITE) found in the
-  /// IR. #AccessInst is the LoadInst respectively StoreInst. The #BaseAddr is
-  /// the array pointer being accesses without subscript. #AccessValue is the
-  /// llvm::Value the StoreInst writes, respectively the result of the LoadInst
-  /// (the LoadInst itself).
-  ///
-  ///
-  /// * Accessing an llvm::Value (a scalar)
-  ///
-  /// This is either a *_WRITE for the value's definition (i.e. exactly one per
-  /// llvm::Value) or a READ when the scalar is used in a different
-  /// BasicBlock. For instance, a use/def chain of such as %V in
-  ///              ______________________
-  ///              |DefBB:              |
-  ///              |  %V = float op ... |
-  ///              ----------------------
-  ///               |                  |
-  /// _________________               _________________
-  /// |UseBB1:        |               |UseBB2:        |
-  /// |  use float %V |               |  use float %V |
-  /// -----------------               -----------------
-  ///
-  /// is modeled as if the accesses had occured this way:
-  ///
-  ///                        __________________________
-  ///                        |entry:                  |
-  ///                        |  %V.s2a = alloca float |
-  ///                        --------------------------
-  ///                                     |
-  ///                    ___________________________________
-  ///                    |DefBB:                           |
-  ///                    |  store %float %V, float* %V.sa2 |
-  ///                    -----------------------------------
-  ///                           |                   |
-  /// ____________________________________  ____________________________________
-  /// |UseBB1:                           |  |UseBB2:                           |
-  /// |  %V.reload1 = load float* %V.s2a |  |  %V.reload2 = load float* %V.s2a |
-  /// |  use float %V.reload1            |  |  use float %V.reload2            |
-  /// ------------------------------------  ------------------------------------
-  ///
-  /// #AccessInst is either the llvm::Value for WRITEs or the value's user for
-  /// READS. The #BaseAddr is represented by the value's definition (i.e. the
-  /// llvm::Value itself) as no such alloca yet exists before CodeGeneration.
-  /// #AccessValue is also the llvm::Value itself.
-  ///
-  ///
-  /// * Accesses to emulate PHI nodes within the SCoP
-  ///
-  /// PHIInst instructions such as
-  ///
-  /// %PHI = phi float [ %Val1, %IncomingBlock1 ], [ %Val2, %IncomingBlock2 ]
-  ///
-  /// are modeled as if the accesses occured this way:
-  ///
-  ///                    _______________________________
-  ///                    |entry:                       |
-  ///                    |  %PHI.phiops = alloca float |
-  ///                    -------------------------------
-  ///                           |              |
-  /// __________________________________  __________________________________
-  /// |IncomingBlock1:                 |  |IncomingBlock2:                 |
-  /// |  ...                           |  |  ...                           |
-  /// |  store float %Val1 %PHI.phiops |  |  store float %Val2 %PHI.phiops |
-  /// |  br label % JoinBlock          |  |  br label %JoinBlock           |
-  /// ----------------------------------  ----------------------------------
-  ///                             \            /
-  ///                              \          /
-  ///               _________________________________________
-  ///               |JoinBlock:                             |
-  ///               |  %PHI = load float, float* PHI.phiops |
-  ///               -----------------------------------------
-  ///
-  /// Since the stores and loads do not exist in the analyzed code, the
-  /// #AccessInst of a load is the PHIInst and a incoming block's terminator for
-  /// stores. The #BaseAddr is represented through the PHINode because there
-  /// also such alloca in the analyzed code. The #AccessValue is represented by
-  /// the PHIInst itself.
-  ///
-  /// Note that there can also be a scalar write access for %PHI if used in a
-  /// different BasicBlock, i.e. there can be a %PHI.phiops as well as a
-  /// %PHI.s2a.
-  ///
-  ///
-  /// * Accesses to emulate PHI nodes that are in the SCoP's exit block
-  ///
-  /// Like the previous, but the PHI itself is not located in the SCoP itself.
-  /// There will be no READ type MemoryAccess for such values. The PHINode's
-  /// llvm::Value is treated as a value escaping the SCoP. WRITE accesses write
-  /// directly to the escaping value's ".s2a" alloca.
-  enum AccessOrigin { EXPLICIT, SCALAR, PHI, EXIT_PHI };
-
   /// @brief The access type of a memory access
   ///
   /// There are three kind of access types:
   ///
   /// * A read access
   ///
   /// A certain set of memory locations are read and may be used for internal
   /// calculations.
private:
   const MemoryAccess &operator=(const MemoryAccess &) = delete;
 
   /// @brief A unique identifier for this memory access.
   ///
   /// The identifier is unique between all memory accesses belonging to the same
   /// scop statement.
   isl_id *Id;
 
-  /// @brief What is modeled by this MemoetyAccess.
-  /// @see AccessOrigin
-  enum AccessOrigin Origin;
+  /// @brief What is modeled by this MemoryAccess.
+  /// @see ScopArrayInfo::MemoryKind
+  ScopArrayInfo::MemoryKind Kind;
 
   /// @brief Whether it a reading or writing access, and if writing, whether it
   /// is conditional (MAY_WRITE).
   enum AccessType AccType;
 
   /// @brief Reduction type for reduction like accesses, RT_NONE otherwise
   ///
   /// An access is reduction like if it is part of a load-store chain in which
private:
   /// @brief Parent ScopStmt of this access.
   ScopStmt *Statement;
 
   // Properties describing the accessed array.
   // TODO: It might be possible to move them to ScopArrayInfo.
   // @{
 
   /// @brief The base address (e.g., A for A[i+j]).
+  ///
+  /// The #BaseAddr of a memory access of kind MK_Array is the base pointer
+  /// of the memory access.
+  /// The #BaseAddr of a memory access of kind MK_PHI or MK_ExitPHI is the
+  /// PHI node itself.
+  /// The #BaseAddr of a memory access of kind MK_Value is the instruction
+  /// defining the value.
   AssertingVH<Value> BaseAddr;
 
   /// @brief An unique name of the accessed array.
   std::string BaseName;
 
   /// @brief Size in bytes of a single array element.
   unsigned ElemBytes;
 
   /// @brief Size of each dimension of the accessed array.
   SmallVector<const SCEV *, 4> Sizes;
   // @}
 
   // Properties describing the accessed element.
   // @{
 
   /// @brief The access instruction of this memory access.
+  ///
+  /// For memory accesses of kind MK_Array the access instruction is the
+  /// Load or Store instruction performing the access.
+  ///
+  /// For memory accesses of kind MK_PHI or MK_ExitPHI the access
+  /// instruction of a load access is the PHI instruction. The access
+  /// instruction of a PHI-store is the incoming's block's terminator
+  /// intruction.
+  ///
+  /// For memory accesses of kind MK_Value the access instruction of a load
+  /// access is the instruction that uses the load. The access instruction of
+  /// a write access is the intruction that defines the llvm::Value.
   Instruction *AccessInstruction;
 
   /// @brief The value associated with this memory access.
   ///
-  ///  - For real memory accesses it is the loaded result or the stored value.
-  ///  - For straight line scalar accesses it is the access instruction itself.
-  ///  - For PHI operand accesses it is the operand value.
+  ///  - For array memory accesses (MK_Array) it is the loaded result or the
+  ///    stored value.
+  ///  - For accesses of kind MK_Value it is the access instruction itself.
+  ///  - For accesses of kind MK_PHI or MK_ExitPHI it is the operand value
+  ///    of the PHI node.
   ///
   AssertingVH<Value> AccessValue;
 
   /// @brief Are all the subscripts affine expression?
   bool IsAffine;
 
   /// @brief Subscript expression for each dimension.
   SmallVector<const SCEV *, 4> Subscripts;
public:
   /// @brief Create a new MemoryAccess.
   ///
   /// @param Stmt       The parent statement.
   /// @param AccessInst The instruction doing the access.
   /// @param BaseAddr   The accessed array's address.
   /// @param ElemBytes  Number of accessed bytes.
   /// @param AccType    Whether read or write access.
   /// @param IsAffine   Whether the subscripts are affine expressions.
-  /// @param Origin     What is the purpose of this access?
+  /// @param Kind       The kind of memory accessed.
   /// @param Subscripts Subscipt expressions
   /// @param Sizes      Dimension lengths of the accessed array.
   /// @param BaseName   Name of the acessed array.
   MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst, AccessType Type,
                Value *BaseAddress, unsigned ElemBytes, bool Affine,
                ArrayRef<const SCEV *> Subscripts, ArrayRef<const SCEV *> Sizes,
-               Value *AccessValue, AccessOrigin Origin, StringRef BaseName);
+               Value *AccessValue, ScopArrayInfo::MemoryKind Kind,
+               StringRef BaseName);
   ~MemoryAccess();
 
   /// @brief Get the type of a memory access.
   enum AccessType getType() { return AccType; }
 
   /// @brief Is this a reduction like access?
   bool isReductionLike() const { return RedType != RT_NONE; }
 
   /// @brief Is this a read memory access?
public:
 
   /// Is always the same memory accessed for a given statement instance set?
   /// Schedule is a map from the statement to a schedule where the innermost
   /// dimension is the dimension of the innermost loop containing the
   /// statement.
   bool isStrideZero(__isl_take const isl_map *Schedule) const;
 
   /// @brief Whether this is an access of an explicit load or store in the IR.
-  bool isExplicit() const { return Origin == EXPLICIT; }
+  bool isArrayKind() const { return Kind == ScopArrayInfo::MK_Array; }
 
-  /// @brief Whether this access represents a register access or models PHI
-  /// nodes.
-  bool isImplicit() const { return !isExplicit(); }
+  /// @brief Whether this access is an array to a scalar memory object.
+  ///
+  /// Scalar accesses are accesses to MK_Value, MK_PHI or MK_ExitPHI.
+  bool isScalarKind() const { return !isArrayKind(); }
 
   /// @brief Is this MemoryAccess modeling scalar dependences?
-  bool isScalar() const { return Origin == SCALAR; }
+  bool isValueKind() const { return Kind == ScopArrayInfo::MK_Value; }
 
   /// @brief Is this MemoryAccess modeling special PHI node accesses?
-  bool isPHI() const { return Origin == PHI; }
+  bool isPHIKind() const { return Kind == ScopArrayInfo::MK_PHI; }
 
   /// @brief Is this MemoryAccess modeling the accesses of a PHI node in the
   /// SCoP's exit block?
-  bool isExitPHI() const { return Origin == EXIT_PHI; }
+  bool isExitPHIKind() const { return Kind == ScopArrayInfo::MK_ExitPHI; }
 
   /// @brief Get the statement that contains this memory access.
   ScopStmt *getStatement() const { return Statement; }
 
   /// @brief Get the reduction type of this access
   ReductionType getReductionType() const { return RedType; }
 
   /// @brief Set the updated access relation read from JSCOP file.
public:
   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.
   ///
   /// @param ElementType The type of the elements stored in this array.
-  /// @param Kind The kind of array info object.
+  /// @param Kind        The kind of the array info object.
   const ScopArrayInfo *getOrCreateScopArrayInfo(Value *BasePtr,
                                                 Type *ElementType,
                                                 ArrayRef<const SCEV *> Sizes,
-                                                ScopArrayInfo::ARRAYKIND Kind);
+                                                ScopArrayInfo::MemoryKind Kind);
 
   /// @brief Return the cached ScopArrayInfo object for @p BasePtr.
   ///
-  /// @param BasePtr  The base pointer the object has been stored for.
-  /// @param Kind The kind of array info object.
+  /// @param BasePtr   The base pointer the object has been stored for.
+  /// @param Kind      The kind of array info object.
   const ScopArrayInfo *getScopArrayInfo(Value *BasePtr,
-                                        ScopArrayInfo::ARRAYKIND Kind);
+                                        ScopArrayInfo::MemoryKind Kind);
 
   void setContext(isl_set *NewContext);
 
   /// @brief Align the parameters in the statement to the scop context
   void realignParams();
 
   /// @brief Return true if the SCoP contained at least one error block.
   bool hasErrorBlock() const { return HasErrorBlock; }
class ScopInfo : public RegionPass {
   ///                    inside @p BB.
   /// @param Type        The kind of access.
   /// @param BaseAddress The accessed array's base address.
   /// @param ElemBytes   Size of accessed array element.
   /// @param Affine      Whether all subscripts are affine expressions.
   /// @param AccessValue Value read or written.
   /// @param Subscripts  Access subscripts per dimension.
   /// @param Sizes       The array diminsion's sizes.
-  /// @param Origin      Purpose of this access.
+  /// @param Kind        The kind of memory accessed.
   void addMemoryAccess(BasicBlock *BB, Instruction *Inst,
                        MemoryAccess::AccessType Type, Value *BaseAddress,
                        unsigned ElemBytes, bool Affine, Value *AccessValue,
                        ArrayRef<const SCEV *> Subscripts,
                        ArrayRef<const SCEV *> Sizes,
-                       MemoryAccess::AccessOrigin Origin);
+                       ScopArrayInfo::MemoryKind Kind);
 
   /// @brief Create a MemoryAccess that represents either a LoadInst or
   /// StoreInst.
   ///
   /// @param MemAccInst  The LoadInst or StoreInst.
   /// @param Type        The kind of access.
   /// @param BaseAddress The accessed array's base address.
   /// @param ElemBytes   Size of accessed array element.
   /// @param IsAffine    Whether all subscripts are affine expressions.
   /// @param Subscripts  Access subscripts per dimension.
   /// @param Sizes       The array dimension's sizes.
   /// @param AccessValue Value read or written.
-  /// @see AccessOrigin
-  void addExplicitAccess(Instruction *MemAccInst, MemoryAccess::AccessType Type,
-                         Value *BaseAddress, unsigned ElemBytes, bool IsAffine,
-                         ArrayRef<const SCEV *> Subscripts,
-                         ArrayRef<const SCEV *> Sizes, Value *AccessValue);
+  /// @see ScopArrayInfo::MemoryKind
+  void addArrayAccess(Instruction *MemAccInst, MemoryAccess::AccessType Type,
 
   /// @brief Create a MemoryAccess for writing an llvm::Value.
   ///
   /// The access will be created at the @p Value's definition.
   ///
   /// @param Value The value to be written.
   /// @see addScalarReadAccess()
-  /// @see AccessOrigin
+  /// @see ScopArrayInfo::MemoryKind
   void addScalarWriteAccess(Instruction *Value);
 
   /// @brief Create a MemoryAccess for reloading an llvm::Value.
   ///
   /// Use this overload only for non-PHI instructions.
   ///
   /// @param Value The scalar expected to be loaded.
   /// @param User  User of the scalar; this is where the access is added.
   /// @see addScalarWriteAccess()
-  /// @see AccessOrigin
+  /// @see ScopArrayInfo::MemoryKind
   void addScalarReadAccess(Value *Value, Instruction *User);
 
   /// @brief Create a MemoryAccess for reloading an llvm::Value.
   ///
   /// This is for PHINodes using the scalar. As we model it, the used value must
   /// be available at the incoming block instead of when hitting the
   /// instruction.
   ///
   /// @param Value  The scalar expected to be loaded.
   /// @param User   The PHI node referencing @p Value.
   /// @param UserBB Incoming block for the incoming @p Value.
   /// @see addPHIWriteAccess()
   /// @see addScalarWriteAccess()
-  /// @see AccessOrigin
+  /// @see ScopArrayInfo::MemoryKind
   void addScalarReadAccess(Value *Value, PHINode *User, BasicBlock *UserBB);
 
   /// @brief Create a write MemoryAccess for the incoming block of a phi node.
   ///
   /// Each of the incoming blocks write their incoming value to be picked in the
   /// phi's block.
   ///
   /// @param PHI           PHINode under consideration.
   /// @param IncomingBlock Some predecessor block.
   /// @param IncomingValue @p PHI's value when coming from @p IncomingBlock.
   /// @param IsExitBlock   When true, uses the .s2a alloca instead of the
   ///                      .phiops one. Required for values escaping through a
   ///                      PHINode in the SCoP region's exit block.
   /// @see addPHIReadAccess()
-  /// @see AccessOrigin
+  /// @see ScopArrayInfo::MemoryKind
   void addPHIWriteAccess(PHINode *PHI, BasicBlock *IncomingBlock,
                          Value *IncomingValue, bool IsExitBlock);
 
   /// @brief Create a MemoryAccess for reading the value of a phi.
   ///
   /// The modeling assumes that all incoming blocks write their incoming value
   /// to the same location. Thus, this access will read the incoming block's
   /// value as instructed by this @p PHI.
   ///
   /// @param PHI PHINode under consideration; the READ access will be added
   /// here.
   /// @see addPHIWriteAccess()
-  /// @see AccessOrigin
+  /// @see ScopArrayInfo::MemoryKind
   void addPHIReadAccess(PHINode *PHI);
 
 public:
   static char ID;
   explicit ScopInfo();
   ~ScopInfo();
 
   /// @brief Try to build the Polly IR of static control part on the current

lib/Analysis/ScopInfo.cpp

static const ScopArrayInfo *identifyBasePtrOriginSAI(Scop *S, Value *BasePtr) {
   if (!OriginBaseSCEV)
     return nullptr;
 
   auto *OriginBaseSCEVUnknown = dyn_cast<SCEVUnknown>(OriginBaseSCEV);
   if (!OriginBaseSCEVUnknown)
     return nullptr;
 
   return S->getScopArrayInfo(OriginBaseSCEVUnknown->getValue(),
-                             ScopArrayInfo::KIND_ARRAY);
+                             ScopArrayInfo::MK_Array);
 }
 
 ScopArrayInfo::ScopArrayInfo(Value *BasePtr, Type *ElementType, isl_ctx *Ctx,
-                             ArrayRef<const SCEV *> Sizes, enum ARRAYKIND Kind,
+                             ArrayRef<const SCEV *> Sizes, enum MemoryKind Kind,
                              const DataLayout &DL, Scop *S)
     : BasePtr(BasePtr), ElementType(ElementType), Kind(Kind), DL(DL), S(*S) {
   std::string BasePtrName =
-      getIslCompatibleName("MemRef_", BasePtr, Kind == KIND_PHI ? "__phi" : "");
+      getIslCompatibleName("MemRef_", BasePtr, Kind == MK_PHI ? "__phi" : "");
   Id = isl_id_alloc(Ctx, BasePtrName.c_str(), this);
 
   updateSizes(Sizes);
   BasePtrOriginSAI = identifyBasePtrOriginSAI(S, BasePtr);
   if (BasePtrOriginSAI)
     const_cast<ScopArrayInfo *>(BasePtrOriginSAI)->addDerivedSAI(this);
 }
 
void MemoryAccess::buildAccessRelation(const ScopArrayInfo *SAI) {
   isl_space_free(Space);
 }
 
 MemoryAccess::MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst,
                            AccessType Type, Value *BaseAddress,
                            unsigned ElemBytes, bool Affine,
                            ArrayRef<const SCEV *> Subscripts,
                            ArrayRef<const SCEV *> Sizes, Value *AccessValue,
-                           AccessOrigin Origin, StringRef BaseName)
-    : Origin(Origin), AccType(Type), RedType(RT_NONE), Statement(Stmt),
+                           ScopArrayInfo::MemoryKind Kind, StringRef BaseName)
+    : Kind(Kind), AccType(Type), RedType(RT_NONE), Statement(Stmt),
       BaseAddr(BaseAddress), BaseName(BaseName), ElemBytes(ElemBytes),
       Sizes(Sizes.begin(), Sizes.end()), AccessInstruction(AccessInst),
       AccessValue(AccessValue), IsAffine(Affine),
       Subscripts(Subscripts.begin(), Subscripts.end()), AccessRelation(nullptr),
       NewAccessRelation(nullptr) {
 
   std::string IdName = "__polly_array_ref";
   Id = isl_id_alloc(Stmt->getParent()->getIslCtx(), IdName.c_str(), this);
void MemoryAccess::print(raw_ostream &OS) const {
   case MUST_WRITE:
     OS.indent(12) << "MustWriteAccess :=\t";
     break;
   case MAY_WRITE:
     OS.indent(12) << "MayWriteAccess :=\t";
     break;
   }
   OS << "[Reduction Type: " << getReductionType() << "] ";
-  OS << "[Scalar: " << isImplicit() << "]\n";
+  OS << "[Scalar: " << isScalarKind() << "]\n";
   OS.indent(16) << getOriginalAccessRelationStr() << ";\n";
   if (hasNewAccessRelation())
     OS.indent(11) << "new: " << getNewAccessRelationStr() << ";\n";
 }
 
 void MemoryAccess::dump() const { print(errs()); }
 
 // Create a map in the size of the provided set domain, that maps from the
void ScopStmt::restrictDomain(__isl_take isl_set *NewDomain) {
   isl_set_free(Domain);
   Domain = NewDomain;
 }
 
 void ScopStmt::buildAccessRelations() {
   for (MemoryAccess *Access : MemAccs) {
     Type *ElementType = Access->getAccessValue()->getType();
 
-    ScopArrayInfo::ARRAYKIND Ty;
-    if (Access->isPHI())
-      Ty = ScopArrayInfo::KIND_PHI;
-    else if (Access->isExitPHI())
-      Ty = ScopArrayInfo::KIND_EXIT_PHI;
-    else if (Access->isScalar())
-      Ty = ScopArrayInfo::KIND_SCALAR;
+    ScopArrayInfo::MemoryKind Ty;
+    if (Access->isPHIKind())
+      Ty = ScopArrayInfo::MK_PHI;
+    else if (Access->isExitPHIKind())
+      Ty = ScopArrayInfo::MK_ExitPHI;
+    else if (Access->isValueKind())
+      Ty = ScopArrayInfo::MK_Value;
     else
-      Ty = ScopArrayInfo::KIND_ARRAY;
+      Ty = ScopArrayInfo::MK_Array;
 
     const ScopArrayInfo *SAI = getParent()->getOrCreateScopArrayInfo(
         Access->getBaseAddr(), ElementType, Access->Sizes, Ty);
 
     Access->buildAccessRelation(SAI);
   }
 }
 
for (ScopStmt &Stmt : *this) {
     // Skip statements with an empty domain as they will never be executed.
     isl_set *StmtDomain = Stmt.getDomain();
     bool StmtDomainEmpty = isl_set_is_empty(StmtDomain);
     isl_set_free(StmtDomain);
     if (StmtDomainEmpty)
       continue;
 
     for (MemoryAccess *MA : Stmt) {
-      if (MA->isImplicit())
+      if (MA->isScalarKind())
         continue;
       if (!MA->isRead())
         HasWriteAccess.insert(MA->getBaseAddr());
       Instruction *Acc = MA->getAccessInstruction();
       PtrToAcc[getPointerOperand(*Acc)] = MA;
       AST.add(Acc);
     }
   }
for (ScopStmt &Stmt : *this) {
     //       generation would otherwise use the old value.
 
     BasicBlock *BB = Stmt.isBlockStmt() ? Stmt.getBasicBlock()
                                         : Stmt.getRegion()->getEntry();
     isl_set *Domain = Stmt.getDomain();
     MemoryAccessList InvMAs;
 
     for (MemoryAccess *MA : Stmt) {
-      if (MA->isImplicit() || MA->isWrite() || !MA->isAffine())
+      if (MA->isScalarKind() || MA->isWrite() || !MA->isAffine())
         continue;
 
       // Skip accesses that have an invariant base pointer which is defined but
       // not loaded inside the SCoP. This can happened e.g., if a readnone call
       // returns a pointer that is used as a base address. However, as we want
       // to hoist indirect pointers, we allow the base pointer to be defined in
       // the region if it is also a memory access. Each ScopArrayInfo object
       // that has a base pointer origin has a base pointer that is loaded and
if (Stmt && Stmt->lookupAccessesFor(LI) != nullptr) {
       return;
     }
   }
 }
 
 const ScopArrayInfo *
 Scop::getOrCreateScopArrayInfo(Value *BasePtr, Type *AccessType,
                                ArrayRef<const SCEV *> Sizes,
-                               ScopArrayInfo::ARRAYKIND Kind) {
+                               ScopArrayInfo::MemoryKind Kind) {
   auto &SAI = ScopArrayInfoMap[std::make_pair(BasePtr, Kind)];
   if (!SAI) {
     auto &DL = getRegion().getEntry()->getModule()->getDataLayout();
     SAI.reset(new ScopArrayInfo(BasePtr, AccessType, getIslCtx(), Sizes, Kind,
                                 DL, this));
   } else {
     // In case of mismatching array sizes, we bail out by setting the run-time
     // context to false.
     if (!SAI->updateSizes(Sizes))
       addAssumption(DELINEARIZATION, isl_set_empty(getParamSpace()),
                     DebugLoc());
   }
   return SAI.get();
 }
 
 const ScopArrayInfo *Scop::getScopArrayInfo(Value *BasePtr,
-                                            ScopArrayInfo::ARRAYKIND Kind) {
+                                            ScopArrayInfo::MemoryKind Kind) {
   auto *SAI = ScopArrayInfoMap[std::make_pair(BasePtr, Kind)].get();
   assert(SAI && "No ScopArrayInfo available for this base pointer");
   return SAI;
 }
 
 std::string Scop::getContextStr() const { return stringFromIslObj(Context); }
 std::string Scop::getAssumedContextStr() const {
   return stringFromIslObj(AssumedContext);
if (auto *GEP = dyn_cast<GetElementPtrInst>(NewAddress)) {
 
       if (AllAffineSubcripts && Sizes.size() > 0) {
         for (auto V : Sizes)
           SizesSCEV.push_back(SE->getSCEV(ConstantInt::get(
               IntegerType::getInt64Ty(BasePtr->getContext()), V)));
         SizesSCEV.push_back(SE->getSCEV(ConstantInt::get(
             IntegerType::getInt64Ty(BasePtr->getContext()), Size)));
 
-        addExplicitAccess(Inst, Type, BasePointer->getValue(), Size, true,
-                          Subscripts, SizesSCEV, Val);
+        addArrayAccess(Inst, Type, BasePointer->getValue(), Size, true,
         return;
       }
     }
   }
 
   auto AccItr = InsnToMemAcc.find(Inst);
   if (PollyDelinearize && AccItr != InsnToMemAcc.end()) {
-    addExplicitAccess(Inst, Type, BasePointer->getValue(), Size, true,
-                      AccItr->second.DelinearizedSubscripts,
-                      AccItr->second.Shape->DelinearizedSizes, Val);
+    addArrayAccess(Inst, Type, BasePointer->getValue(), Size, true,
     return;
   }
 
   // Check if the access depends on a loop contained in a non-affine subregion.
   bool isVariantInNonAffineLoop = false;
   if (BoxedLoops) {
     SetVector<const Loop *> Loops;
     findLoops(AccessFunction, Loops);
void ScopInfo::buildMemoryAccess(
   // FIXME: Size of the number of bytes of an array element, not the number of
   // elements as probably intended here.
   const SCEV *SizeSCEV =
       SE->getConstant(TD->getIntPtrType(Inst->getContext()), Size);
 
   if (!IsAffine && Type == MemoryAccess::MUST_WRITE)
     Type = MemoryAccess::MAY_WRITE;
 
-  addExplicitAccess(Inst, Type, BasePointer->getValue(), Size, IsAffine,
-                    ArrayRef<const SCEV *>(AccessFunction),
-                    ArrayRef<const SCEV *>(SizeSCEV), Val);
+  addArrayAccess(Inst, Type, BasePointer->getValue(), Size, IsAffine,
 }
 
 void ScopInfo::buildAccessFunctions(Region &R, Region &SR) {
 
   if (SD->isNonAffineSubRegion(&SR, &R)) {
     for (BasicBlock *BB : SR.blocks())
       buildAccessFunctions(R, *BB, &SR);
     return;

 }
 
 void ScopInfo::addMemoryAccess(BasicBlock *BB, Instruction *Inst,
                                MemoryAccess::AccessType Type,
                                Value *BaseAddress, unsigned ElemBytes,
                                bool Affine, Value *AccessValue,
                                ArrayRef<const SCEV *> Subscripts,
                                ArrayRef<const SCEV *> Sizes,
-                               MemoryAccess::AccessOrigin Origin) {
+                               ScopArrayInfo::MemoryKind Kind) {
   ScopStmt *Stmt = scop->getStmtForBasicBlock(BB);
 
   // Do not create a memory access for anything not in the SCoP. It would be
   // ignored anyway.
   if (!Stmt)
     return;
 
   AccFuncSetType &AccList = AccFuncMap[BB];
   Value *BaseAddr = BaseAddress;
   std::string BaseName = getIslCompatibleName("MemRef_", BaseAddr, "");
 
   bool isApproximated =
       Stmt->isRegionStmt() && (Stmt->getRegion()->getEntry() != BB);
   if (isApproximated && Type == MemoryAccess::MUST_WRITE)
     Type = MemoryAccess::MAY_WRITE;
 
   AccList.emplace_back(Stmt, Inst, Type, BaseAddress, ElemBytes, Affine,
-                       Subscripts, Sizes, AccessValue, Origin, BaseName);
+                       Subscripts, Sizes, AccessValue, Kind, BaseName);
   Stmt->addAccess(&AccList.back());
 }
 
-void ScopInfo::addExplicitAccess(
-    Instruction *MemAccInst, MemoryAccess::AccessType Type, Value *BaseAddress,
-    unsigned ElemBytes, bool IsAffine, ArrayRef<const SCEV *> Subscripts,
-    ArrayRef<const SCEV *> Sizes, Value *AccessValue) {
+void ScopInfo::addArrayAccess(Instruction *MemAccInst,
+                              MemoryAccess::AccessType Type, Value *BaseAddress,
+                              unsigned ElemBytes, bool IsAffine,
+                              ArrayRef<const SCEV *> Subscripts,
+                              ArrayRef<const SCEV *> Sizes,
+                              Value *AccessValue) {
   assert(isa<LoadInst>(MemAccInst) || isa<StoreInst>(MemAccInst));
   assert(isa<LoadInst>(MemAccInst) == (Type == MemoryAccess::READ));
   addMemoryAccess(MemAccInst->getParent(), MemAccInst, Type, BaseAddress,
                   ElemBytes, IsAffine, AccessValue, Subscripts, Sizes,
-                  MemoryAccess::EXPLICIT);
+                  ScopArrayInfo::MK_Array);
 }
 void ScopInfo::addScalarWriteAccess(Instruction *Value) {
   addMemoryAccess(Value->getParent(), Value, MemoryAccess::MUST_WRITE, Value, 1,
                   true, Value, ArrayRef<const SCEV *>(),
-                  ArrayRef<const SCEV *>(), MemoryAccess::SCALAR);
+                  ArrayRef<const SCEV *>(), ScopArrayInfo::MK_Value);
 }
 void ScopInfo::addScalarReadAccess(Value *Value, Instruction *User) {
   assert(!isa<PHINode>(User));
   addMemoryAccess(User->getParent(), User, MemoryAccess::READ, Value, 1, true,
                   Value, ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
-                  MemoryAccess::SCALAR);
+                  ScopArrayInfo::MK_Value);
 }
 void ScopInfo::addScalarReadAccess(Value *Value, PHINode *User,
                                    BasicBlock *UserBB) {
   addMemoryAccess(UserBB, User, MemoryAccess::READ, Value, 1, true, Value,
                   ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
-                  MemoryAccess::SCALAR);
+                  ScopArrayInfo::MK_Value);
 }
 void ScopInfo::addPHIWriteAccess(PHINode *PHI, BasicBlock *IncomingBlock,
                                  Value *IncomingValue, bool IsExitBlock) {
   addMemoryAccess(IncomingBlock, IncomingBlock->getTerminator(),
                   MemoryAccess::MUST_WRITE, PHI, 1, true, IncomingValue,
                   ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
-                  IsExitBlock ? MemoryAccess::EXIT_PHI : MemoryAccess::PHI);
+                  IsExitBlock ? ScopArrayInfo::MK_ExitPHI
+                              : ScopArrayInfo::MK_PHI);
 }
 void ScopInfo::addPHIReadAccess(PHINode *PHI) {
   addMemoryAccess(PHI->getParent(), PHI, MemoryAccess::READ, PHI, 1, true, PHI,
                   ArrayRef<const SCEV *>(), ArrayRef<const SCEV *>(),
-                  MemoryAccess::PHI);
+                  ScopArrayInfo::MK_PHI);
 }
 
 void ScopInfo::buildScop(Region &R, DominatorTree &DT, AssumptionCache &AC) {
   unsigned MaxLoopDepth = getMaxLoopDepthInRegion(R, *LI, *SD);
   scop = new Scop(R, AccFuncMap, *SD, *SE, DT, *LI, ctx, MaxLoopDepth);
 
   buildStmts(R);
   buildAccessFunctions(R, R);

lib/CodeGen/BlockGenerators.cpp

Value *BlockGenerator::getOrCreateAlloca(Value *ScalarBase,
 
   if (GlobalMap.count(Addr))
     return GlobalMap[Addr];
 
   return Addr;
 }
 
 Value *BlockGenerator::getOrCreateAlloca(MemoryAccess &Access) {
-  if (Access.isPHI())
+  if (Access.isPHIKind())
     return getOrCreatePHIAlloca(Access.getBaseAddr());
   else
     return getOrCreateScalarAlloca(Access.getBaseAddr());
 }
 
 Value *BlockGenerator::getOrCreateAlloca(const ScopArrayInfo *Array) {
-  if (Array->isPHI())
+  if (Array->isPHIKind())
     return getOrCreatePHIAlloca(Array->getBasePtr());
   else
     return getOrCreateScalarAlloca(Array->getBasePtr());
 }
 
 Value *BlockGenerator::getOrCreateScalarAlloca(Value *ScalarBase) {
   return getOrCreateAlloca(ScalarBase, ScalarMap, ".s2a");
 }
void BlockGenerator::handleOutsideUsers(const Region &R, Instruction *Inst,
   auto *ScalarAddr = Address ? Address : getOrCreateScalarAlloca(Inst);
 
   // Remember that this instruction has escape uses and the escape alloca.
   EscapeMap[Inst] = std::make_pair(ScalarAddr, std::move(EscapeUsers));
 }
 
 void BlockGenerator::generateScalarLoads(ScopStmt &Stmt, ValueMapT &BBMap) {
   for (MemoryAccess *MA : Stmt) {
-    if (MA->isExplicit() || MA->isWrite())
+    if (MA->isArrayKind() || MA->isWrite())
       continue;
 
     auto *Address = getOrCreateAlloca(*MA);
     BBMap[MA->getBaseAddr()] =
         Builder.CreateLoad(Address, Address->getName() + ".reload");
   }
 }
 
void BlockGenerator::generateScalarStores(ScopStmt &Stmt, LoopToScevMapT &LTS,
                                           ValueMapT &BBMap) {
   const Region &R = Stmt.getParent()->getRegion();
 
   assert(Stmt.isBlockStmt() && "Region statements need to use the "
                                "generateScalarStores() function in the "
                                "RegionGenerator");
 
   for (MemoryAccess *MA : Stmt) {
-    if (MA->isExplicit() || MA->isRead())
+    if (MA->isArrayKind() || MA->isRead())
       continue;
 
     Value *Val = MA->getAccessValue();
     auto *Address = getOrCreateAlloca(*MA);
 
     Val = getNewScalarValue(Val, R, Stmt, LTS, BBMap);
     Builder.CreateStore(Val, Address);
   }
if (StartBB == R.getEntry())
     StartBB = SplitBBTerm->getSuccessor(1);
 
   Builder.SetInsertPoint(StartBB->getTerminator());
 
   for (auto &Pair : S.arrays()) {
     auto &Array = Pair.second;
     if (Array->getNumberOfDimensions() != 0)
       continue;
-    if (Array->isPHI()) {
+    if (Array->isPHIKind()) {
       // For PHI nodes, the only values we need to store are the ones that
       // reach the PHI node from outside the region. In general there should
       // only be one such incoming edge and this edge should enter through
       // 'SplitBB'.
       auto PHI = cast<PHINode>(Array->getBasePtr());
 
       for (auto BI = PHI->block_begin(), BE = PHI->block_end(); BI != BE; BI++)
         if (!R.contains(*BI) && *BI != SplitBB)

 void BlockGenerator::findOutsideUsers(Scop &S) {
   auto &R = S.getRegion();
   for (auto &Pair : S.arrays()) {
     auto &Array = Pair.second;
 
     if (Array->getNumberOfDimensions() != 0)
       continue;
 
-    if (Array->isPHI())
+    if (Array->isPHIKind())
       continue;
 
     auto *Inst = dyn_cast<Instruction>(Array->getBasePtr());
 
     if (!Inst)
       continue;
 
     // Scop invariant hoisting moves some of the base pointers out of the scop.
void RegionGenerator::generateScalarStores(ScopStmt &Stmt, LoopToScevMapT &LTS,
                                            ValueMapT &BBMap) {
   const Region &R = Stmt.getParent()->getRegion();
 
   assert(Stmt.getRegion() &&
          "Block statements need to use the generateScalarStores() "
          "function in the BlockGenerator");
 
   for (MemoryAccess *MA : Stmt) {
-    if (MA->isExplicit() || MA->isRead())
+    if (MA->isArrayKind() || MA->isRead())
       continue;
 
     Instruction *ScalarInst = MA->getAccessInstruction();
     Value *Val = MA->getAccessValue();
 
     // In case we add the store into an exiting block, we need to restore the
     // position for stores in the exit node.
     BasicBlock *SavedInsertBB = Builder.GetInsertBlock();
     auto SavedInsertionPoint = Builder.GetInsertPoint();
     ValueMapT *LocalBBMap = &BBMap;
 
-    // Implicit writes induced by PHIs must be written in the incoming blocks.
-    if (MA->isPHI() || MA->isExitPHI()) {
+    // Scalar writes induced by PHIs must be written in the incoming blocks.
+    if (MA->isPHIKind() || MA->isExitPHIKind()) {
       BasicBlock *ExitingBB = ScalarInst->getParent();
       BasicBlock *ExitingBBCopy = BlockMap[ExitingBB];
       Builder.SetInsertPoint(ExitingBBCopy->getTerminator());
 
       // For the incoming blocks, use the block's BBMap instead of the one for
       // the entire region.
       LocalBBMap = &RegionMaps[ExitingBBCopy];
     }
 
     auto Address = getOrCreateAlloca(*MA);
 
     Val = getNewScalarValue(Val, R, Stmt, LTS, *LocalBBMap);
     Builder.CreateStore(Val, Address);
 
     // Restore the insertion point if necessary.
-    if (MA->isPHI() || MA->isExitPHI())
+    if (MA->isPHIKind() || MA->isExitPHIKind())
       Builder.SetInsertPoint(SavedInsertBB, SavedInsertionPoint);
   }
 }
 
 void RegionGenerator::addOperandToPHI(ScopStmt &Stmt, const PHINode *PHI,
                                       PHINode *PHICopy, BasicBlock *IncomingBB,
                                       LoopToScevMapT &LTS) {
   Region *StmtR = Stmt.getRegion();

lib/CodeGen/IslNodeBuilder.cpp

static isl_stat addReferencesFromStmt(const ScopStmt *Stmt, void *UserPtr) {
   else {
     assert(Stmt->isRegionStmt() &&
            "Stmt was neither block nor region statement");
     for (const BasicBlock *BB : Stmt->getRegion()->blocks())
       findReferencesInBlock(References, Stmt, BB);
   }
 
   for (auto &Access : *Stmt) {
-    if (Access->isExplicit()) {
+    if (Access->isArrayKind()) {
       auto *BasePtr = Access->getScopArrayInfo()->getBasePtr();
       if (Instruction *OpInst = dyn_cast<Instruction>(BasePtr))
         if (Stmt->getParent()->getRegion().contains(OpInst))
           continue;
 
       References.Values.insert(BasePtr);
       continue;
     }
bool IslNodeBuilder::preloadInvariantEquivClass(
   // element with the unified execution context. However, we have to map all
   // elements of the class to the one preloaded load as they are referenced
   // during the code generation and therefor need to be mapped.
   const MemoryAccessList &MAs = std::get<1>(IAClass);
   if (MAs.empty())
     return true;
 
   MemoryAccess *MA = MAs.front();
-  assert(MA->isExplicit() && MA->isRead());
+  assert(MA->isArrayKind() && MA->isRead());
 
   // If the access function was already mapped, the preload of this equivalence
   // class was triggered earlier already and doesn't need to be done again.
   if (ValueMap.count(MA->getAccessInstruction()))
     return true;
 
   // Check for recurrsion which can be caused by additional constraints, e.g.,
   // non-finitie loop contraints. In such a case we have to bail out and insert
   // a "false" runtime check that will cause the original code to be executed.
   if (!PreloadedPtrs.insert(std::get<0>(IAClass)).second)
     return false;
 
   // If the base pointer of this class is dependent on another one we have to
   // make sure it was preloaded already.
-  auto *SAI = S.getScopArrayInfo(MA->getBaseAddr(), ScopArrayInfo::KIND_ARRAY);
+  auto *SAI = S.getScopArrayInfo(MA->getBaseAddr(), ScopArrayInfo::MK_Array);
   if (const auto *BaseIAClass = S.lookupInvariantEquivClass(SAI->getBasePtr()))
     if (!preloadInvariantEquivClass(*BaseIAClass))
       return false;
 
   Instruction *AccInst = MA->getAccessInstruction();
   Type *AccInstTy = AccInst->getType();
 
   isl_set *Domain = isl_set_copy(std::get<2>(IAClass));
for (const MemoryAccess *MA : MAs) {
         //       point values we need to reload the value or convert it.
         BasePtr =
             Builder.CreateBitOrPointerCast(PreloadVal, BasePtr->getType());
         DerivedSAI->setBasePtr(BasePtr);
       }
 
       // For scalar derived SAIs we remap the alloca used for the derived value.
       if (BasePtr == MA->getAccessInstruction()) {
-        if (DerivedSAI->isPHI())
+        if (DerivedSAI->isPHIKind())
           PHIOpMap[BasePtr] = Alloca;
         else
           ScalarMap[BasePtr] = Alloca;
       }
     }
   }
 
   const Region &R = S.getRegion();