[Polly] Never add read accesses for synthesizable values

[Meinersbur]

Summary

Before adding a MK_Value READ MemoryAccess, check whether the read is necessary or synthesizable. Synthesizable values are later generated by the SCEVExpander and therefore do not need to be transferred explicitly. This patch is also a requirement for the "cause inversion" extracted from D13762.

[grosser]

Hi Michael,

some of the patches on the way do not apply cleanly. To get a better feeling of the test, I would like to apply it and play with it. For this I wait until the earlier patches are committed.

Here already some comments:

lib/Analysis/ScopInfo.cpp

3980 ↗

(On Diff #43361)

There can be accesses to constants, in case the constant is an externally defined _constant_ global. Such constants are really just globals from which we load values.
To handle these you want to use ConstantInt, ConstantFP.

Also, I wonder which test case requires the isa<BasicBlock>(Value).

Also, I still need to understand if all pieces of the code are actually needed (and tested) at the moment. My feeling is that some of these simplifications may currently be never triggered as they are already covered by the code that inserts the memory accesses. (For this I wait until I can actually run the code).

[Meinersbur]

lib/Analysis/ScopInfo.cpp

3980 ↗

(On Diff #43361)

Also, I wonder which test case requires the isa<BasicBlock>(Value).

Any branching instruction "uses" a BasicBlock. It iterates over the terminators because conditional branches uses predicates (of type i1) that might be defined in a different ScopStmt.

[Meinersbur]

Rebase; adressing Tobias comments

It is actually this patch blocked by D16522, not the others. Sorry for the confusion.

[grosser]

Hi Michael,

in this patch only the isSynthesisable change seems to actually affect the output, everything else appears to not yet affect anything.
My feeling is that some of the statements added here will be removed in your later patch at a different location. I would prefer to keep them in the same patch to better see that they are just moved around.

Regarding the isSynthesable change itself. It is touching an area that is a little fishy. Specifically, it will disable (all?) integer read-only memory access modeling as most (all?)l read-only memory accesses are synthesis-able. I need to think about this a little bit to understand if/what that means, to which extend we do this today and how we can correctly model read-only memory accesses then.

Is the isSynthesisable part of this patch blocking subsequent patches?

Best,
Tobias

[Meinersbur]

In D15687#336428, @grosser wrote:

Hi Michael,

in this patch only the isSynthesisable change seems to actually affect the output, everything else appears to not yet affect anything.
My feeling is that some of the statements added here will be removed in your later patch at a different location. I would prefer to keep them in the same patch to better see that they are just moved around.

As a reminder, I extracted out this patch out of D15706 on your request. Nothing will be removed again, it is even here because of the later patch.

Regarding the isSynthesable change itself. It is touching an area that is a little fishy.

This and D15706 are intended to reduce the fishyness. This is a good thing, isn't it?

Specifically, it will disable (all?) integer read-only memory access modeling as most (all?)l read-only memory accesses are synthesis-able. I need to think about this a little bit to understand if/what that means, to which extend we do this today and how we can correctly model read-only memory accesses then.

The idea is simple: Everything that is synthesizable (depending only on SCoP parameters and induction variables) can be inserted directly into the code and therefore does not require reading anything. You are right, since integer definitions defined before the scop are added as parameter, there is no reason to model them as accesses. Why should it? Why model those as parameter _and_ pass them using allocas? This is to my understanding the intention from the beginning. If not, please tell me the rules when read-only accesses are needed.

This should also exactly be what's required for OpenMP kernels. The SCoP parameters need to be passed to the kernel in any case because there might be (other) synthesizable SCEVs/isl_pw_aff in there that depend on these params. Passing a parameter a second time via a kernel function argument is redundant.

Is the isSynthesisable part of this patch blocking subsequent patches?

Yes, blocks D15706 and D12975; I am unable to understand the idea of read-only accesses in the current implementation. There seems to be no consistency. Eg. there is a difference whether it is used by an MK_Value, MK_PHI, or MK_PHI incoming value that is defined in a different statement. D15706 and D12975 modify the creation of MemoryAccesses and I cannot change it accurately if I can't even tell whether it is a bug or by design.

[grosser]

In D15687#336706, @Meinersbur wrote:

In D15687#336428, @grosser wrote:

Hi Michael,

in this patch only the isSynthesisable change seems to actually affect the output, everything else appears to not yet affect anything.
My feeling is that some of the statements added here will be removed in your later patch at a different location. I would prefer to keep them in the same patch to better see that they are just moved around.

As a reminder, I extracted out this patch out of D15706 on your request. Nothing will be removed again, it is even here because of the later patch.

Sure. I remember that I asked for it. We just need to make sure the patches are split in a way that everything is tested, otherwise it is difficult to distinguish between dead code, code that is used and tested later and code for which we do not add more test coverage.

In this very patch it seems only isSynthesisable is tested. All other additions can be removed without any test failures. My feeling is that they current code will never call ensureValueRead with arguments that trigger the code that can be removed. If this is indeed the case, these changes (with the exception of isSynthesisable) can not be split off from the next patch. In case they can be reached even today, it would be good to add appropriate test cases.

Regarding the isSynthesable change itself. It is touching an area that is a little fishy.

This and D15706 are intended to reduce the fishyness. This is a good thing, isn't it?

Specifically, it will disable (all?) integer read-only memory access modeling as most (all?)l read-only memory accesses are synthesis-able. I need to think about this a little bit to understand if/what that means, to which extend we do this today and how we can correctly model read-only memory accesses then.

The idea is simple: Everything that is synthesizable (depending only on SCoP parameters and induction variables) can be inserted directly into the code and therefore does not require reading anything. You are right, since integer definitions defined before the scop are added as parameter, there is no reason to model them as accesses. Why should it? Why model those as parameter _and_ pass them using allocas? This is to my understanding the intention from the beginning. If not, please tell me the rules when read-only accesses are needed.

This should also exactly be what's required for OpenMP kernels. The SCoP parameters need to be passed to the kernel in any case because there might be (other) synthesizable SCEVs/isl_pw_aff in there that depend on these params. Passing a parameter a second time via a kernel function argument is redundant.

Just to explain the fishiness a little bit. The issue is that we only introduce parameters for SCEVs that are part of loop bounds or array indexes, but not for non-affine index expressions or scalar dependences that are e.g. just compute a value that is stored to memory. We do not introduce parameters for two reasons: First, we do not need them to model iteration domains, so not adding them keeps the dimensionality of the integer sets low. Second, we can not identify parameters the way we do this for affine expressions as some of the scalar evolution expressions used outside of affine index expressions and loop bounds are non-affine. This means not all the information is modeled/carried by our set of parameters, which is why e.g. the OpenMP code generation is required to scan the SCEVs of a ScopStmt for additional values that need to be transferred (See: getReferencesInSubtree).

Now, I think we should probably model some of these "hidden" scalar dependences more explicitly in the ScopStmt, but I agree that this probably nothing we should block this patch on. In fact, the immediate issue is already taken care of as the OpenMP code generation already scan's the SCEVs again.

It just took me one day to reason about this issue. I think the isSynthesisable part of this patch is fine.

Is the isSynthesisable part of this patch blocking subsequent patches?

Yes, blocks D15706 and D12975; I am unable to understand the idea of read-only accesses in the current implementation. There seems to be no consistency. Eg. there is a difference whether it is used by an MK_Value, MK_PHI, or MK_PHI incoming value that is defined in a different statement. D15706 and D12975 modify the creation of MemoryAccesses and I cannot change it accurately if I can't even tell whether it is a bug or by design.

I hoped to have explained the issue a little bit higher up. I don't think your patch can/will fix the issue I just explained, but we should probably sit down and reason about this in a separate patch. Within the model we use today, your patch is clearly an improvement and it does not regress any existing code.

I have two last requests/questions:

• As written earlier, I think we should make this just about the isSynthesisable()
• I wonder why we did not catch this earlier. We already check canSynthesize() in both buildPHIAccesses and in buildScalarDependences. Still, it seems we add unnecessary reads. Did you understand where these still sneaked through?

Best,
Tobias

[Meinersbur]

In D15687#337230, @grosser wrote:

Just to explain the fishiness a little bit. The issue is that we only introduce parameters for SCEVs that are part of loop bounds or array indexes, but not for non-affine index expressions or scalar dependences that are e.g. just compute a value that is stored to memory. We do not introduce parameters for two reasons: First, we do not need them to model iteration domains, so not adding them keeps the dimensionality of the integer sets low. Second, we can not identify parameters the way we do this for affine expressions as some of the scalar evolution expressions used outside of affine index expressions and loop bounds are non-affine. This means not all the information is modeled/carried by our set of parameters, which is why e.g. the OpenMP code generation is required to scan the SCEVs of a ScopStmt for additional values that need to be transferred (See: getReferencesInSubtree).

Now, I think we should probably model some of these "hidden" scalar dependences more explicitly in the ScopStmt, but I agree that this probably nothing we should block this patch on. In fact, the immediate issue is already taken care of as the OpenMP code generation already scan's the SCEVs again.

If this is the rationale, we should modify canSynthesize() to return false for values that are not in the SCoP's params.

Note that synthesizing is useful to remove scalar dependences:

void func(i32 %x)

Stmt1:
  %1 = add i32 %x, 5

Stmt2:
  use(%1)

canSynthesize() returning true causes the add to be %1 to disappear, because it will be synthesized into Stmt2.

• As written earlier, I think we should make this just about the isSynthesisable()

OK, I will update this patch.

• I wonder why we did not catch this earlier. We already check canSynthesize() in both buildPHIAccesses and in buildScalarDependences. Still, it seems we add unnecessary reads. Did you understand where these still sneaked through?

Because there is no check for canSynthesize() in buildPHIAccesses() when handling the case where the incoming value is not defined within the same Stmt.

[grosser]

Meinersbur added a comment.

In http://reviews.llvm.org/D15687#337230, @grosser wrote:

Just to explain the fishiness a little bit. The issue is that we only introduce parameters for SCEVs that are part of loop bounds or array indexes, but not for non-affine index expressions or scalar dependences that are e.g. just compute a value that is stored to memory. We do not introduce parameters for two reasons: First, we do not need them to model iteration domains, so not adding them keeps the dimensionality of the integer sets low. Second, we can not identify parameters the way we do this for affine expressions as some of the scalar evolution expressions used outside of affine index expressions and loop bounds are non-affine. This means not all the information is modeled/carried by our set of parameters, which is why e.g. the OpenMP code generation is required to scan the SCEVs of a ScopStmt for additional values that need to be transferred (See: getReferencesInSubtree).

Now, I think we should probably model some of these "hidden" scalar dependences more explicitly in the ScopStmt, but I agree that this probably nothing we should block this patch on. In fact, the immediate issue is already taken care of as the OpenMP code generation already scan's the SCEVs again.

If this is the rationale, we should modify canSynthesize() to return false for values that are not in the SCoP's params.

Note that synthesizing is useful to remove scalar dependences:

void func(i32 %x)

Stmt1:
  %1 = add i32 %x, 5

Stmt2:
  use(%1)

canSynthesize() returning true causes the add to be %1 to disappear, because it will be synthesized into Stmt2.

Right. That's one of the reasons it exists. So no, I do not think we
want it to return false either, but probably want to find a way to keep
track of these additional scalar references while still being able to
look through SCEVs.

Anyhow, let's just keep this in mind.

• As written earlier, I think we should make this just about the isSynthesisable()

OK, I will update this patch.

• I wonder why we did not catch this earlier. We already check canSynthesize() in both buildPHIAccesses and in buildScalarDependences. Still, it seems we add unnecessary reads. Did you understand where these still sneaked through?

Because there is no check for canSynthesize() in buildPHIAccesses() when handling the case where the incoming value is not defined within the same Stmt.

Perfect. I think this info will be great in the commit message. In fact,
it would probably be more educational to add the canSynthesize precisely
at this spot. Then your next patch will show nicely that multiple
canSynthesize() calls will be replaced by just one.

Best,
Tobias

[Meinersbur]

remove all conditions except canSynthesize

[grosser]

test/Isl/CodeGen/synthesizable_phi_write_after_loop.ll

11 ↗

(On Diff #46141)

typo: the the

polly/trunk/lib/Analysis/ScopInfo.cpp

void ScopInfo::ensureValueWrite(Instruction *Value) {
   if (Stmt->lookupValueWriteOf(Value))
     return;
 
   addMemoryAccess(Value->getParent(), Value, MemoryAccess::MUST_WRITE, Value, 1,
                   true, Value, ArrayRef<const SCEV *>(),
                   ArrayRef<const SCEV *>(), ScopArrayInfo::MK_Value);
 }
 void ScopInfo::ensureValueRead(Value *Value, BasicBlock *UserBB) {
+
+  // If the instruction can be synthesized and the user is in the region we do
+  // not need to add a value dependences.
+  Region &ScopRegion = scop->getRegion();
+  if (canSynthesize(Value, LI, SE, &ScopRegion))
+    return;
+
   ScopStmt *UserStmt = scop->getStmtForBasicBlock(UserBB);
 
   // We do not model uses outside the scop.
   if (!UserStmt)
     return;
 
   // Do not create another MemoryAccess for reloading the value if one already
   // exists.

polly/trunk/test/Isl/CodeGen/phi-defined-before-scop.ll

 ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
 
 ; CHECK-LABEL: polly.merge_new_and_old:
 ; CHECK-NEXT: %tmp7.ph.merge = phi %struct.wibble* [ %tmp7.ph.final_reload, %polly.exiting ], [ %tmp7.ph, %bb6.region_exiting ]
 
 ; CHECK-LABEL: polly.stmt.bb3:
-; CHECK-NEXT: %tmp2.s2a.reload = load %struct.wibble*, %struct.wibble** %tmp2.s2a
-; CHECK-NEXT: store %struct.wibble* %tmp2.s2a.reload, %struct.wibble** %tmp7.s2a
+; CHECK-NEXT: store %struct.wibble* %tmp2, %struct.wibble** %tmp7.s2a
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 %struct.blam = type { i32, i32, i32, i32, i32, i32, i32, i32, i32, i32 }
 %struct.wibble = type { i32, %struct.wibble*, %struct.wibble* }
 
 @global = external global %struct.blam*, align 8
 

polly/trunk/test/Isl/CodeGen/synthesizable_phi_write_after_loop.ll

 ; RUN: opt %loadPolly -polly-codegen -S < %s | FileCheck %s
 ;
 ; Check for the correct written value of a scalar phi write whose value is
 ; defined within the loop, but its effective value is its last definition when
 ; leaving the loop (in this test it is the value 2 for %i.inc). This can be
 ; either computed:
 ; - Using SCEVExpander:
 ;         In this case the Loop passed to the expander must NOT be the loop
 ; - Overwriting the same alloca in each iteration s.t. the last value will
 ;         retain in %i.inc.s2a
-; The latter is currently generated by Polly and tested here.
+; The first is currently generated by Polly and tested here.
 
 ; CHECK:      polly.stmt.next:
-; CHECK-NEXT:   %i.inc.s2a.reload = load i32, i32* %i.inc.s2a
-; CHECK-NEXT:   store i32 %i.inc.s2a.reload, i32* %phi.phiops
+; CHECK-NEXT:   store i32 2, i32* %phi.phiops
 ; CHECK-NEXT:   br label %polly.stmt.join
-;
-; CHECK:      polly.stmt.loop:
-; CHECK:        %0 = trunc i64 %polly.indvar to i32
-; CHECK:        %1 = add i32 %0, 1
-; CHECK:        store i32 %1, i32* %i.inc.s2a
 
 define i32 @func() {
 entry:
   br label %start
 
 start:
   br i1 true, label %loop, label %join
 

polly/trunk/test/Isl/CodeGen/uninitialized_scalar_memory.ll

 ; RUN: opt %loadPolly -S -polly-codegen < %s | FileCheck %s
 ;
 ; Verify we initialize the scalar locations reserved for the incoming phi
 ; values.
 ;
 ; CHECK:      polly.start:
 ; CHECK-NEXT:   store float %ebig.0, float* %ebig.0.s2a
-; CHECK-NEXT:   store i32 %iebig.0, i32* %iebig.0.s2a
 ; CHECK-NEXT:   br label %polly.stmt.if.end.entry
 ;
 ;    int g(void);
 ;    float M;
 ;    int max(float *restrict xbig, int eres, int bres, float *restrict indx) {
 ;      int i, iebig;
 ;      float ebig;
 ;      for (i = 0; i < 4 + eres; i++) {

polly/trunk/test/ScopInfo/NonAffine/non_affine_loop_used_later.ll

 ; CHECK-NEXT: [N] -> {  :  }
 ; CHECK-NEXT: Boundary Context:
 ; CHECK-NEXT: [N] -> {  :  }
 ; CHECK-NEXT: p0: %N
 ; CHECK-NEXT: Arrays {
 ; CHECK-NEXT:     i32 MemRef_j_0__phi; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_j_0; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_A[*]; // Element size 4
-; CHECK-NEXT:     i32 MemRef_smax; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_j_2__phi; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_j_2; // Element size 4
 ; CHECK-NEXT: }
 ; CHECK-NEXT: Arrays (Bounds as pw_affs) {
 ; CHECK-NEXT:     i32 MemRef_j_0__phi; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_j_0; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_A[*]; // Element size 4
-; CHECK-NEXT:     i32 MemRef_smax; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_j_2__phi; // Element size 4
 ; CHECK-NEXT:     i32 MemRef_j_2; // Element size 4
 ; CHECK-NEXT: }
 ; CHECK-NEXT: Alias Groups (0):
 ; CHECK-NEXT:     n/a
 ; CHECK-NEXT: Statements {
 ; CHECK-NEXT:     Stmt_bb2
 ; CHECK-NEXT:         Domain :=

 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [N] -> { Stmt_bb4__TO__bb18[i0] -> [i0, 1] };
 ; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:         MayWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_A[i0] };
-; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:             [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_smax[] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:             [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_2__phi[] };
 ; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:             [N] -> { Stmt_bb4__TO__bb18[i0] -> MemRef_j_0[] };
 ; CHECK-NEXT:     Stmt_bb18
 ; CHECK-NEXT:         Domain :=
 ; CHECK-NEXT:             [N] -> { Stmt_bb18[i0] : 0 <= i0 < N };
 ; CHECK-NEXT:         Schedule :=

polly/trunk/test/ScopInfo/non_affine_region_1.ll

 ; CHECK-NEXT:             [b] -> { Stmt_bb7[i0] -> [i0, 1] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:             [b] -> { Stmt_bb7[i0] -> MemRef_x_1__phi[] };
 ; CHECK-NEXT:     Stmt_bb8
 ; CHECK-NEXT:         Domain :=
 ; CHECK-NEXT:             [b] -> { Stmt_bb8[0] : b = 0 };
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [b] -> { Stmt_bb8[i0] -> [0, 0] };
-; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:             [b] -> { Stmt_bb8[i0] -> MemRef_b[] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:             [b] -> { Stmt_bb8[i0] -> MemRef_x_1__phi[] };
 ; CHECK-NEXT:     Stmt_bb10__TO__bb18
 ; CHECK-NEXT:         Domain :=
 ; CHECK-NEXT:             [b] -> { Stmt_bb10__TO__bb18[i0] : 0 <= i0 <= 1023 and (i0 < b or (i0 >= b and 2i0 > b)); Stmt_bb10__TO__bb18[0] : b = 0 };
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [b] -> { Stmt_bb10__TO__bb18[i0] -> [i0, 3] : i0 < b or (i0 >= b and 2i0 > b); Stmt_bb10__TO__bb18[0] -> [0, 3] : b = 0 };
 ; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]

polly/trunk/test/ScopInfo/non_affine_region_3.ll

 ; CHECK-NEXT:          Domain :=
 ; CHECK-NEXT:              { Stmt_bb3__TO__bb18[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:          Schedule :=
 ; CHECK-NEXT:              { Stmt_bb3__TO__bb18[i0] -> [i0, 0] };
 ; CHECK-NEXT:          ReadAccess :=    [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:              { Stmt_bb3__TO__bb18[i0] -> MemRef_A[i0] };
 ; CHECK-NEXT:          MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:              { Stmt_bb3__TO__bb18[i0] -> MemRef_x_2__phi[] };
-; CHECK-NEXT:          ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:              { Stmt_bb3__TO__bb18[i0] -> MemRef_b[] };
 ; CHECK-NEXT:      Stmt_bb18
 ; CHECK-NEXT:          Domain :=
 ; CHECK-NEXT:              { Stmt_bb18[i0] : 0 <= i0 <= 1023 };
 ; CHECK-NEXT:          Schedule :=
 ; CHECK-NEXT:              { Stmt_bb18[i0] -> [i0, 1] };
 ; CHECK-NEXT:          ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:              { Stmt_bb18[i0] -> MemRef_x_2__phi[] };
 ; CHECK-NEXT:          MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]

polly/trunk/test/ScopInfo/pointer-used-as-base-pointer-and-scalar-read.ll

 ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
 
 ; In this test case we pass a pointer %A into a PHI node and also use this
 ; pointer as base pointer of an array store. As a result, we get both scalar
 ; and array memory accesses to A[] and A[0].
 
 ; CHECK:      Arrays {
 ; CHECK-NEXT:     float MemRef_A[*]; // Element size 4
-; CHECK-NEXT:     float* MemRef_A; // Element size 8
 ; CHECK-NEXT:     float* MemRef_x__phi; // Element size 8
-; CHECK-NEXT:     float* MemRef_B; // Element size 8
 ; CHECK-NEXT:     float* MemRef_C[*]; // Element size 8
 ; CHECK-NEXT: }
 ; CHECK:      Arrays (Bounds as pw_affs) {
 ; CHECK-NEXT:     float MemRef_A[*]; // Element size 4
-; CHECK-NEXT:     float* MemRef_A; // Element size 8
 ; CHECK-NEXT:     float* MemRef_x__phi; // Element size 8
-; CHECK-NEXT:     float* MemRef_B; // Element size 8
 ; CHECK-NEXT:     float* MemRef_C[*]; // Element size 8
 ; CHECK-NEXT: }
 ; CHECK:      Alias Groups (0):
 ; CHECK-NEXT:     n/a
 ; CHECK:      Statements {
 ; CHECK-NEXT:     Stmt_then
 ; CHECK-NEXT:         Domain :=
 ; CHECK-NEXT:             [p] -> { Stmt_then[i0] : p = 32 and 0 <= i0 <= 999 };
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [p] -> { Stmt_then[i0] -> [i0, 1] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [p] -> { Stmt_then[i0] -> MemRef_A[0] };
-; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:             [p] -> { Stmt_then[i0] -> MemRef_A[] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:             [p] -> { Stmt_then[i0] -> MemRef_x__phi[] };
 ; CHECK-NEXT:     Stmt_else
 ; CHECK-NEXT:         Domain :=
 ; CHECK-NEXT:             [p] -> { Stmt_else[i0] : 0 <= i0 <= 999 and (p >= 33 or p <= 31) };
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [p] -> { Stmt_else[i0] -> [i0, 0] : p >= 33 or p <= 31 };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:             [p] -> { Stmt_else[i0] -> MemRef_A[0] };
-; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]
-; CHECK-NEXT:             [p] -> { Stmt_else[i0] -> MemRef_B[] };
 ; CHECK-NEXT:         MustWriteAccess :=    [Reduction Type: NONE] [Scalar: 1]
 ; CHECK-NEXT:             [p] -> { Stmt_else[i0] -> MemRef_x__phi[] };
 ; CHECK-NEXT:     Stmt_bb8
 ; CHECK-NEXT:         Domain :=
 ; CHECK-NEXT:             [p] -> { Stmt_bb8[i0] : 0 <= i0 <= 999 and (p >= 33 or p <= 32) };
 ; CHECK-NEXT:         Schedule :=
 ; CHECK-NEXT:             [p] -> { Stmt_bb8[i0] -> [i0, 2] };
 ; CHECK-NEXT:         ReadAccess :=    [Reduction Type: NONE] [Scalar: 1]

polly/trunk/test/ScopInfo/same-base-address-scalar-and-array.ll

 ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
 ;
 ; Verify we introduce two ScopArrayInfo objects (or virtual arrays) for the %out variable
 ; as it is used as a memory base pointer (%0) but also as a scalar (%out.addr.0.lcssa).
 ;
 ; CHECK:         Arrays {
-; CHECK-NEXT:        float* MemRef_out; // Element size 8
 ; CHECK-NEXT:        float* MemRef_out_addr_0_lcssa; // Element size 8
 ; CHECK-NEXT:        float MemRef_out[*]; // Element size 4
 ; CHECK-NEXT:    }
 ;
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @ff_celp_lp_synthesis_filterf(float* %out) #0 {