[LAA] Add Memory dependence remarks.

[malharJ]

Summary

Adds new optimization remarks when vectorization fails.

More specifically, new remarks are added for following 4 cases:

• Backward dependency
• Backward dependency that prevents Store-to-load forwarding
• Forward dependency that prevents Store-to-load forwarding
• Unknown dependency

It is important to note that only one of the sources
of failures (to vectorize) is reported by the remarks.
This source of failure may not be first in program order.

A regression test has been added to test the following cases:

a) Loop can be vectorized: No optimization remark is emitted
b) Loop can not be vectorized: In this case an optimization
remark will be emitted for one source of failure.

[alban.bridonneau]

llvm/test/Transforms/LoopVectorize/loopvectorize-opt-remarks.ll

27 ↗

(On Diff #368011)

Your tests all use the same types, I believe tbaa is not how the aliasing issues are detected, and you can remove those nodes

37 ↗

(On Diff #368011)

I am not sure i understand this test. The description says the loop contains only reads, but the IR has stores in it.
Also, the IR is already vectorized, so it's not really a useful test case

179 ↗

(On Diff #368011)

same here, the IR is already vectorized. For such a patch i would have expected all loops to be scalar, as before entering the Loop Vectorizer

13 ↗

(On Diff #367580)

I am not aware of any tool to do this cleanup

[malharJ]

1. Added a standardized method of outputting the debug location.

Also changed the output format accordingly.

2. Simplified the regression test:
   • Corrected bug by changing vectorized IR to scalar IR
   • removed as much debug info as possible

llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

960–966 ↗

(On Diff #367580)

Ok, I've used something more standardized now to print out the debug location.

llvm/test/Transforms/LoopVectorize/loopvectorize-opt-remarks.ll

37 ↗

(On Diff #368011)

My bad here.
Updated the patch with the scalar version for the three cases (nodep, forward, backwardVectorizable)

[alban.bridonneau]

Thanks Malhar. Code looks good to me. I'll need to take another look at the unit tests.
I'm going away for a week, so either someone else picks up the review in the meantime, or we can resume working on this when I come back.

[malharJ]

ping.

(Can someone else please review the patch as well ?)

[fhahn]

Rather than interpreting the LoopAccessAnalysis result in LV, can LAA directly generate the reports? Then other users of LAA could also benefit.

[malharJ]

@fhahn , but these remarks are specific to vectorization (ie. scenarios where loop does not get vectorized) ...
are there any passes (other than LV) which would require this information ?

[david-arm]

In D108371#2976665, @malharJ wrote:

@fhahn , but these remarks are specific to vectorization (ie. scenarios where loop does not get vectorized) ...
are there any passes (other than LV) which would require this information ?

Hi @malharJ, lots of passes actually use LoopAccessAnalysis, not just LoopVectorize.cpp, i.e. LoopLoadElimination.cpp, LoopVersioningLICM.cpp, etc. I agree they aren't strictly concerned about vectorisation, but they will execute the same code paths, i.e. LoopAccessInfo::analyzeLoop -> MemoryDepChecker::areDepsSafe. Maybe it does make sense for elaborateMemoryReport to live in LoopAccessAnalysis.cpp, especially since all the data used to generate the report actually lives in LoopAccessInfo anyway?

llvm/lib/Analysis/LoopAccessAnalysis.cpp

589

Remark instead of 'insight'?

1728

Remark instead of 'insight'?

[malharJ]

• Moved remark generating function (elaborateMemoryReport()) and some related functions from LoopVectorizationLegality to the class LoopAccessInfo (inside the file LoopAccessAnalysis).

• Deleted a redundant function createMissedAnalysis() and replaced it's usage with that of recordAnalysis().

• elaborateMemoryReport() could not be placed within CanVectorizeMemory() as the latter is a const function and recordAnalysis() (which is used by elaborateMemoryReport()) cannot be a const function as it modifies a member variable (Report)
  
  Hence elaborateMemoryReport was placed after the call to analyzeLoop().

• A direct consequence of moving the reporting code to LoopAccessAnalysis meant that some memory dependence related remarks from earlier became redundant. These have been removed since elaborateMemoryReport() will take care of such remarks.

• Moving code to LoopAccessAnalysis meant that it would make more sense for the remarks are to be emitted when "-Rpass-analysis=loop-accesses" is used (and not "-Rpass-analysis=loop-vectorize")
  
  Hence the LIT test is also updated to reflect the same.

[alban.bridonneau]

I quite like the way it looks with the code moved from the vectorizer to loop access analysis. I'll do a more in-depth review after the unit tests are fixed, but i left a couple of simple comments for now.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2083

why was this remark removed? As far as i can see, this message is not covered by the new memory report

llvm/lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

889 ↗

(On Diff #370670)

these braces can now be removed

[fhahn]

In D108371#2976665, @malharJ wrote:

@fhahn , but these remarks are specific to vectorization (ie. scenarios where loop does not get vectorized) ...
are there any passes (other than LV) which would require this information ?

Thanks for the update. As David already said, other passes also use LAA and also there's nothing vectorisation specific about the remark you added.

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

261

There's no need to return a SmallVector with the length encoded, the callers should not care about that. You can use ArrayRef if the callers do not add to the vector or SmalLVectorImpl if they need to add elements.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

589

Use /// for all comments. Also, does this need to be public after the recent changes?

1723

Why call it UnsafeDependences if it is supposed to only contain unknown dependences?

llvm/test/Transforms/LoopVectorize/loopvectorize-opt-remarks.ll

1 ↗

(On Diff #370670)

please avoid adding tests with -enable-new-pm=0. You should be able to move that one to the LoopAccessAnalysis directory.

6 ↗

(On Diff #370670)

Instead of having the C code here, I think it would be more helpful if you explain what this tests in a sentence or 2 with references to the IR, e.g. which memory instruction/GEP has the uncomputable bound and *why*.

[malharJ]

1. Fixed the unit tests:
   
   This required initializing the ORE object using one of the constructors: OptimizationRemarkEmitter(const Function& F)
   
   Previously several of the unit tests were hitting memory errors and they seem to have been fixed by this change.
   
   There are also some minor formatting updates to the remark emitted.

2. Removed checks for loop distribution pragma remark from LIT tests. This is because there is no analysis being done to support it.

3. Updated recordAnalysis() to allow generating multiple reports when they are of the same type. This seems like a logical thing to do, for example if you have multiple instances of unbound array index case in a loop, it would be good for a user to view (in the report) similar types of errors and then correct them.

4. Updated LIT test to use new Pass Manager syntax

5. Minor formatting updates

[malharJ]

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

261

Currently the code uses "auto" when accessing the. value returned by this getter
so there isn't a need for the user to know the size used in the template ...

regardless, I've changed it to use SmallVector<T> instead if that's ok.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

589

It was being accessed from outside the class on line 2045.

I've moved it to private now and added a public getter instead.

1723

I think UnsafeDependences contains both unknown and known unsafe dependences.
I think the comment is unclear so I'm removing it.

[malharJ]

This is to correct a mistake made in the previous patch.

"loop not vectorized" should not be emitted from loop-access analysis.
(the loop-vectorize takes care of adding 'loop not vectorized')

[alban.bridonneau]

llvm/test/Transforms/LoopVectorize/diag-with-hotness-info-2.ll

25

This hint is a useful one, and it was added purposefully. It should remain unchanged. I would suggest that you add a case in elaborateMemoryReport to recreate this hint.

[malharJ]

Re-added the remark/note about using pragma loop distribute.

[alban.bridonneau]

Just one small comment. Otherwise the patch looks good to me

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

555

Nit: Missing a slash

[malharJ]

Trivial formatting update.

[alban.bridonneau]

Thanks Malhar. The patch looks good to me

[sdesmalen]

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

261

If there is no need to modify the array returned by getUnsafeDependences (which there isn't, because the returned value is const), ArrayRef seems the better class to use, because it has all sorts of convenient utilities and is similarly just a (immutable) reference to the array.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2072

Is this case not already covered by the recordAnalysis call above?

It seems like a mechanism for doing this already exists (recordAnalysis), it may be worth extending that to handle multiple reports (there is currently a limitation that it uses a single Report variable, but perhaps that could be made into a vector of reports which can be appended to).

2118

nit: single-use variable, can be inlined in the next statement.

2175–2176

nit: please start your comments with capitalisation and end with a period.

llvm/test/Analysis/LoopAccessAnalysis/memory-dep-remarks.ll

13

Would a prefix like "Loop cannot be vectorized: " be useful?

I think the message is a bit cryptic, how about:

Unable to determine aliasing information because the bounds of this access cannot be computed.

[malharJ]

• Updated remark for unknown array bounds case

• Moved call to recordAnalysis() inside elaborateMemoryReport() for the UnsafeDataDependenceTriedRT case

• Changed getUnsafeDependences() to return an ArrayRef since return value is only read.

• Minor formatting updates

[malharJ]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2072

I agree it has been covered by the call to recordAnalysis() at line 2070 ...
I've now moved that call to recordAnalysis() to inside elaborateMemoryReport().

Regarding the second issue, I'm not sure myself why recordAnalysis has Report as scalar and not a vector but that is not really a part of my change ... I just tried to re-use it.

llvm/test/Analysis/LoopAccessAnalysis/memory-dep-remarks.ll

13

If you see the earlier version/diffs of the patch, the reporting was being done in LoopVectorizer.
That time I had added "loop not vectorized" in the tests.

But now that it has moved to LoopAccessAnalysis, we are no longer emitting "loop not vectorized" here.
That prefix is prepended by the function reportVectorizationFailure() in LoopVectorize.cpp

For the latter part, I have made the change.

[malharJ]

corrected trivial typo in LIT test.

[malharJ]

minor formatting update for fixing a failing test.

[malharJ]

Are there any other review comments ?

[david-arm]

LGTM! It looks like you've addressed all the other reviewer's comments and I think the patch looks good now. Thanks!

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2179

nit: Maybe it's worth moving the recordAnalysis call to before the for loop, i.e.

OptimizationRemarkAnalysis R = recordAnalysis("UnknownArrayBounds", I);
for (...)

[fhahn]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

779

If computing the bounds fails here, we may retry creating checks by adding assumptions below (see line 806).

I think it could happen that we have multiple uncomputable pointer bounds here, but for some of them we may be able to actually compute bounds below. Should we remove the ones we can compute bounds below from the set?

llvm/test/Analysis/LoopAccessAnalysis/memory-dep-remarks.ll

13

Unable to determine aliasing information because the bounds of this access cannot be computed.

I'm not sure this is entirely accurate. AFAIK uncomputable bounds here mean we cannot generate runtime checks.

'aliasing information' seems ambiguous here, because at the point where we check whether the bounds are computable, we already determined that the access may alias another access, independent of whether the bounds can be computed or not (like the underlying objects may alias).

[malharJ]

1. Updated format of remark
2. Removed pointers from UncomputablePtrs Set if it's bound can be computed on a retry (with Assumptions).

[malharJ]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

779

Done. thanks for that suggestion.

2179

Unfortunately that can't be done because Instruction* I is being declared inside the for-loop.

llvm/test/Analysis/LoopAccessAnalysis/memory-dep-remarks.ll

13

Ok I agree.

I have changed the remark accordingly.

[malharJ]

Are there any further review comments ?

[malharJ]

• Removed the mechanism that collected the remarks (enum "FailureReason" and function "elaborateMemoryReport()") and emitted them at the end.
  
  Instead, now the remarks are emitted inside LoopAccessInfo::analyzeLoop(), ie. while the loop is being analyzed.

• Only one remark is emitted, at the point it is found.

[malharJ]

• Removed remark emission (OptimizationRemarkEmitter) to outside LoopAccessAnalysis. LAA generates a "Report" which can be used by other passes to emit remarks.

This also fixes the issue with emission of the same/similar remark twice (once by LAA, and once by a parent pass, eg: LV)

• Updated the tests accordingly.

[malharJ]

Fixed minor typos and one LIT test (vectorization-remarks-missed.ll)

[malharJ]

@sdesmalen , can you please review the latest updates ?

[sdesmalen]

Hi @malharJ, thanks for cleaning up the patch and making changes based on what we discussed offline, it's a bit more manageable to review now.
There are still some changes that I think are unnecessary, and I found that the patch needs to be rebased (this is how I found some confusing output test/Analysis/LoopAccessAnalysis/pointer-phis.ll).

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

652

This seems unused?

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2041

UncomputablePtr and the mechanism around it seems entirely redundant, because it doesn't add any information that is used anywhere. The only reason that UncomputablePtr is collected is to avoid printing "Cannot identify array bounds" when it gets to the then-block of if (!CanDoRTIfNeeded) { ... }. The information is redundant, because when UncomputablePtr is set, then CanDoRT is false, and vice-versa.

2044

nit: The capitalisation of cannot -> Cannot seems unnecessary.

[sdesmalen]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

1726

Can there only be a single unsafe/unknown dependence? Or can there be more?

2072

unnecessary change.

2100

These changes here obfuscate the report that's generated by LAA when running loop(print-access-info). The information printed was:

Loop access info in function 'store_with_pointer_phi_incoming_phi':
  loop.header:
 The compiler can't determine the cause of the issue.
    Dependences:
      Unknown:
          %v8 = load double, double* %arrayidx, align 8 ->
          store double %mul16, double* %ptr.2, align 8

The information that is added by the remark is:

Loop access info in function 'store_with_pointer_phi_incoming_phi':
  loop.header:
    Report: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
Unknown data dependence. Memory location is the same as accessed at <UNKNOWN LOCATION>. 
 The compiler can't determine the cause of the issue.
    Dependences:
      Unknown:
          %v8 = load double, double* %arrayidx, align 8 ->  
          store double %mul16, double* %ptr.2, align 8

The extra information here isn't particularly useful, especially because it doesn't have any line information. Perhaps the code should disable the extra info if the location is unknown/unavailable.

2102

nit: Please remove the newline.

2102

Instead of using + to concatenate two strings, let this be handled by raw_ostream using << .

llvm/test/Analysis/LoopAccessAnalysis/stride-access-dependence.ll

122 ↗

(On Diff #384037)

Please CHECK-NEXT for the full line that is printed.

[malharJ]

• Rebased patch onto main
• Updated code to avoid printing <unknown> when no debug info is present
• minor formatting updates

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

652

thanks for pointing it out. Removed it.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

1726

There can be more.

But we are only emitting (as a remark) the first one found.

2041

Ok, I agree but there's an issue here ..

LoopAccessInfo::recordAnalysis() cant be called from within the function ( AccessAnalysis::canCheckPtrAtRT() ).
as it's not a member of AccessAnalysis class.

Perhaps one way to do it would be for AccessAnalysis::canCheckPtrAtRT() to accept a parameter
by reference and then we can use the value after the call as input to recordAnalysis() here.
But I'm afraid this approach is not much less verbose than current approach pf having UncomputablePtr as a member variable.

2100

Thanks for pointing this out. Done.

2102

can we keep this newline ?

The current text (Note: it was not introduced by this patch) is too long already:

unsafe dependent memory operations in loop. Use "#pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop

llvm/test/Analysis/LoopAccessAnalysis/stride-access-dependence.ll

122 ↗

(On Diff #384037)

Agreed.

But now the code will only print the remaining text: "Memory location is the same as ...etc"
when debug info is available.

so this is no longer an issue (since this test does not contain any debug info/metadata).

[malharJ]

ping,

[sdesmalen]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

587

UncomputablePtr doesn't really need a separate variable in AccessAnalysis, since it's only set by one function, and used directly by the function that calls it.

You can change canCheckPtrAtRT to take Value **UncomputablePtr = nullptr, and in canCheckPtrAtRT assign the value if the value is requested:

if (UncomputablePtr)
  *UncomputablePtr = Access.getPointer();

Where you call it, you can have:

Value *UncomputablePtr = nullptr;
bool CanDoRTIfNeeded =
    Accesses.canCheckPtrAtRT(*PtrRtChecking, PSE->getSE(), TheLoop,
                             SymbolicStrides, false, &UncomputablePtr);

if (!CanDoRTIfNeeded) {
  if (auto *I = dyn_cast_or_null<Instruction>(UncomputablePtr))
    recordAnalysis("UnknownArrayBounds", I)
}

Can you split this change out into a separate patch with a test that demonstrates the change?

1732

It shows here that the dependences are already collected. You can iterate Dependences to find the dependence that isn't safe, so that you don't have to add UnsafeDependence and maintain that separately.

1814

I guess this can be more briefly written as:

Loc = I->getDebugLoc();
if (auto *PtrI = dyn_cast_or_null<Instruction>(getPointerOperand(I)))
  Loc = PtrI->getDebugLoc();

(at which point it probably doesn't require a separate function anymore, especially since it has only one use).

1817–1819

This seems like a case that should be added to getPointerOperand ?

2042

It now passes in I as the instruction, but the debug location of the remark seems unchanged in the test. What value is this adding?

2043

Just leave the name as CantIdentifyArrayBounds ?

[RKSimon]

Sorry this is not an area I known enough about to review

[fhahn]

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

313

Does this need to be a shared_ptr? If you want to encode the fact that it may not be set, using Optional may be a better choice. Or you could initialize it to NoDep in case there is no unsafe dependence.

[malharJ]

• Moved the changes for testing unknown array bounds to new patch: D115873
• addressed review comments

[malharJ]

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

313

I've removed it now based on review comment by sdesmalen, so this is no longer an issue.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

587

Done, new patch: https://reviews.llvm.org/D115873

1732

Done.
That's a good point, thanks !

1814

I've removed this function and inlined the code since there is only one usage.

2042

This was essentially an issue in the original test,
The debug info (!35) used by the loop was incorrect.
I've changed it to use !32 now.

I have corrected the issue in my new patch:
https://reviews.llvm.org/D115873

[malharJ]

• rebased patch

Premerge îs failing due to (a possible bug introduced by) recent changes:
https://github.com/google/llvm-premerge-checks/pull/374

[malharJ]

• Updated unit test

[fhahn]

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

19

This change is unnecessary, keep the include in the .cpp

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2095

It seems like it would make things easier to read if the logic would be in a separate function, with proper documentation what it is supposed to do?

2097

nit: variable names here start with upper cases

2100

nit: dependence instead of dependency, to be in line with the terminology used elsewhere in the file?

2108

Is this true? Unless I miss something, this emits a remark for the first unsafe dependence?

llvm/test/Transforms/LoopVectorize/memory-dep-remarks.ll

1 ↗

(On Diff #394998)

For remarks, it might be good to check the full yaml generated, as in llvm/test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll

16 ↗

(On Diff #394998)

nit: check here not needed?

19 ↗

(On Diff #394998)

nit: easier to read if this is the last block

121 ↗

(On Diff #394998)

Is this needed? Same for other tests.

126 ↗

(On Diff #394998)

is this needed?

264 ↗

(On Diff #394998)

can the debug lock be trimmed down a bit?

[malharJ]

• minor formatting updates
• moved remark emission code for unsafe mem dependences into a function
• got rid of some more debuginfo in the LIT test.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2108

you are correct, the comment is no longer correct. I've updated it now in the new function.

llvm/test/Transforms/LoopVectorize/memory-dep-remarks.ll

121 ↗

(On Diff #394998)

Can you please explain why this is not needed ?

126 ↗

(On Diff #394998)

thanks. removed it now. changed the type of %n from i32 to i64.

264 ↗

(On Diff #394998)

Done.

• Changed functions to use same parameters (and same ordering). This helped reduce !DISubroutineType metadata.

• Also reduced some !DILocation (that were not required) from test_forwardButPreventsForwarding_dep()

[malharJ]

• Added YAML to the LIT test

[malharJ]

ping.

[sdesmalen]

Hi @malharJ thanks for splitting up and simplifying this patch, this is an improvement. I left a few more comments, and also found that the remark itself needs a bit of work to separate it from the original message. Maybe you can also update the tests to check the full context, to ensure this no longer happens?

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2101

Can this be an assert?

2108

Can this be an assert?

2114

nit: please move this code below the switch

2118

This dyn_cast will cause a segfault if the value returned by getPointerOperand is a nullptr. This needs to be dyn_cast_or_null. It would be good to have a test for this case.

Also, there is no test for the MemSetInst either. Can you add one?

llvm/test/Transforms/LoopVectorize/memory-dep-remarks.ll

120 ↗

(On Diff #397552)

When I try this out with Clang, I see:

Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loopBackward loop carried data dependence

The issue here is the loopBackward (no period and space between remarks)

[malharJ]

• Rebased patch.
• Addressed review comments.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2101

I guess not ...

Looking at the definition of MemoryDepChecker::getDependences(),
it can return a nullptr if RecordDependences is false.
and that happens when number of dependences exceeds MaxDependences.
Given that max-dependences is a command line option, it could have any value.

2108

I dont think so ...

We will still need the check to see if we can find a dependency type that is unsafe for vectorization.

Just the presence of Deps is not sufficient to say above will be satisfied, because it can contain
Forward or Backwardvectorizable dependencies too (but we dont care about emitting any remark for them as they can be vectorized)

2118

Ok, I've changed it to dyn_cast_or_null (I think you had already mentioned it an earlier review comment but I missed it).
Can we please avoid adding more tests, from what I understand it may not be very crucial to test getPointerOperand()
as we just avoid emitting debug location information if it returns null pointer.

Also, I tried writing a test case for memset case and I found that it doesnt even make sense to have a case here for memset.
Apparently LAA does not consider any instruction that is not a load/store
I see this code in LoopAccessInfo::analyzeLoop()

if (!St) {
  recordAnalysis("CantVectorizeInstruction", St)
      << "instruction cannot be vectorized";
  HasComplexMemInst = true;
  continue;
}

So it looks like a different remark is emitted and an early exit is taken because memset is considered as a "complex" memory instruction.

considering the above, I have removed the memset part from the patch.

llvm/test/Transforms/LoopVectorize/memory-dep-remarks.ll

120 ↗

(On Diff #397552)

I'm not very clear on the issue here .. they are already printed on separate lines ?

Regardless I've updated the tests to print the entire message.
(The reason I was avoiding it earlier was because it was too long a message, and didn't appeal to me as part of the remark.
However, it was not added by my patch so I will not be changing it.)

[malharJ]

• minor update to commit message to trigger phabricator builds.

Update:
Build has failed but test failures are unrelated to this patch.

[sdesmalen]

LGTM with the nits addressed.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2101

nit: can be removed if you address my comment below.

2103–2111

nit:

if (!Deps || 
    llvm::find_if(Deps, [](const MemoryDepChecker::Dependence &D) { .. }) == Deps->end())
  return;

2145–2152

nit: this is more concisely written as:

if (Instruction *I = Dep.getSource(*this)) {
  DebugLoc SourceLoc = I->getDebugLoc();
  if (auto *DD = dyn_cast_or_null<Instruction>(getPointerOperand(I)))
    SourceLoc = DD->getDebugLoc();
  R << " Memory location is the same as accessed at "
    << ore::NV("Location", SourceLoc);
}

llvm/include/llvm/Analysis/LoopAccessAnalysis.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ANALYSIS_LOOPACCESSANALYSIS_H
 #define LLVM_ANALYSIS_LOOPACCESSANALYSIS_H
 
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"
+#include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 
 class AAResults;
 class DataLayout;
 class Loop;
 class LoopAccessInfo;
-class OptimizationRemarkEmitter;
 class raw_ostream;
 class SCEV;
 class SCEVUnionPredicate;
 class Value;
 
 /// Collection of parameters shared beetween the Loop Vectorizer and the
 /// Loop Access Analysis.
 struct VectorizerParams {
DenseMap<Instruction *, unsigned> generateInstructionOrderMap() const {
 
     return OrderMap;
   }
 
   /// Find the set of instructions that read or write via \p Ptr.
   SmallVector<Instruction *, 4> getInstructionsForAccess(Value *Ptr,
                                                          bool isWrite) const;
 
+  ArrayRef<Dependence> getUnsafeDependences() const {
+    return UnsafeDependences;
+  }
+
 private:
   /// A wrapper around ScalarEvolution, used to add runtime SCEV checks, and
   /// applies dynamic knowledge to simplify SCEV expressions and convert them
   /// to a more usable form. We need this in case assumptions about SCEV
   /// expressions need to be made in order to avoid unknown dependences. For
   /// example we might assume a unit stride for a pointer in order to prove
   /// that a memory access is strided and doesn't wrap.
   PredicatedScalarEvolution &PSE;
private:
   //// loop.  If false we exceeded MaxDependences and
   //// Dependences is invalid.
   bool RecordDependences;
 
   /// Memory dependences collected during the analysis.  Only valid if
   /// RecordDependences is true.
   SmallVector<Dependence, 8> Dependences;
 
+  /// Unsafe memory dependences collected during the analysis.
+  /// Used for generating optimization remarks.
+  SmallVector<Dependence> UnsafeDependences;
+
   /// Check whether there is a plausible dependence between the two
   /// accesses.
   ///
   /// Access \p A must happen before \p B in program order. The two indices
   /// identify the index into the program order map.
   ///
   /// This function checks  whether there is a plausible dependence (or the
   /// absence of such can't be proved) between the two accesses. If there is a

 /// If pointers can wrap or can't be expressed as affine AddRec expressions by
 /// ScalarEvolution, we will generate run-time checks by emitting a
 /// SCEVUnionPredicate.
 ///
 /// Checks for both memory dependences and the SCEV predicates contained in the
 /// PSE must be emitted in order for the results of this analysis to be valid.
 class LoopAccessInfo {
 public:
+  /// Reasons why memory accesses cannot be vectorized (used for OptRemarks)
+  enum class FailureReason {
+    UnsafeDataDependence,
+    UnsafeDataDependenceTriedRT,
+    UnknownArrayBounds,
+    Unknown
+  };
+
   LoopAccessInfo(Loop *L, ScalarEvolution *SE, const TargetLibraryInfo *TLI,
                  AAResults *AA, DominatorTree *DT, LoopInfo *LI);
 
+  /// Elaborate on the analyses collected to generate
+  /// remarks based on the failure reasons.
+  void elaborateMemoryReport();
+
   /// Return true we can analyze the memory accesses in the loop and there are
   /// no memory dependence cycles.
   bool canVectorizeMemory() const { return CanVecMem; }
 
+  /// Return reason describing why memory access cannot be vectorized.
+  /// Used for the OptRemark generation.
+  FailureReason getFailureReason() const { return FailReason; }
+
   /// Return true if there is a convergent operation in the loop. There may
   /// still be reported runtime pointer checks that would be required, but it is
   /// not legal to insert them.
   bool hasConvergentOp() const { return HasConvergentOp; }
 
   const RuntimePointerChecking *getRuntimePointerChecking() const {
     return PtrRtChecking.get();
   }
public:
   void print(raw_ostream &OS, unsigned Depth = 0) const;
 
   /// If the loop has memory dependence involving an invariant address, i.e. two
   /// stores or a store and a load, then return true, else return false.
   bool hasDependenceInvolvingLoopInvariantAddress() const {
     return HasDependenceInvolvingLoopInvariantAddress;
   }
 
+  const SmallPtrSet<Value *, 4> &getUncomputablePtrs() const {
+    return UncomputablePtrs;
+  }
+
   /// Used to add runtime SCEV checks. Simplifies SCEV expressions and converts
   /// them to a more usable form.  All SCEV expressions during the analysis
   /// should be re-written (and therefore simplified) according to PSE.
   /// A user of LoopAccessAnalysis will need to emit the runtime checks
   /// associated with this predicate.
   const PredicatedScalarEvolution &getPSE() const { return *PSE; }
 
 private:
private:
   /// Collect memory access with loop invariant strides.
   ///
   /// Looks for accesses like "a[i * StrideA]" where "StrideA" is loop
   /// invariant.
   void collectStridedAccess(Value *LoadOrStoreInst);
 
   std::unique_ptr<PredicatedScalarEvolution> PSE;
 
+  std::unique_ptr<OptimizationRemarkEmitter> ORE;
+
   /// We need to check that all of the pointers in this list are disjoint
   /// at runtime. Using std::unique_ptr to make using move ctor simpler.
   std::unique_ptr<RuntimePointerChecking> PtrRtChecking;
 
   /// the Memory Dependence Checker which can determine the
   /// loop-independent and loop-carried dependences between memory accesses.
   std::unique_ptr<MemoryDepChecker> DepChecker;
 
private:
   std::unique_ptr<OptimizationRemarkAnalysis> Report;
 
   /// If an access has a symbolic strides, this maps the pointer value to
   /// the stride symbol.
   ValueToValueMap SymbolicStrides;
 
   /// Set of symbolic strides values.
   SmallPtrSet<Value *, 8> StrideSet;
+
+  /// Reason why memory accesses cannot be vectorized (used for OptRemarks)
+  FailureReason FailReason;
+
+  /// Set of uncomputable pointers.
+  /// Used when emitting OptRemarks
+  SmallPtrSet<Value *, 4> UncomputablePtrs;
 };
 
 Value *stripIntegerCast(Value *V);
 
 /// Return the SCEV corresponding to a pointer with the symbolic stride
 /// replaced with constant one, assuming the SCEV predicate associated with
 /// \p PSE is true.
 ///

llvm/lib/Analysis/LoopAccessAnalysis.cpp

 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/LoopAnalysisManager.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/MemoryLocation.h"
-#include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
public:
   /// We decided that no dependence analysis would be used.  Reset the state.
   void resetDepChecks(MemoryDepChecker &DepChecker) {
     CheckDeps.clear();
     DepChecker.clearDependences();
   }
 
   MemAccessInfoList &getDependenciesToCheck() { return CheckDeps; }
 
+  const SmallPtrSet<Value *, 4> &getUncomputablePtrs() const {
+    return UncomputablePtrs;
+  }
+
 private:
   typedef SetVector<MemAccessInfo> PtrAccessSet;
 
+  /// Set of uncomputable pointers.
+  /// Used when emitting unknown array bounds remark
+  SmallPtrSet<Value *, 4> UncomputablePtrs;
+
   /// Go over all memory access and check whether runtime pointer checks
   /// are needed and build sets of dependency check candidates.
   void processMemAccesses();
 
   /// Set of all accesses.
   PtrAccessSet Accesses;
 
   /// The loop being checked.
if (NumWritePtrChecks == 0 ||
              "Can only skip updating CanDoRT below, if all entries in AS "
              "are reads or there is at most 1 entry");
       continue;
     }
 
     for (auto &Access : AccessInfos) {
       if (!createCheckForAccess(RtCheck, Access, StridesMap, DepSetId, TheLoop,
                                 RunningDepId, ASId, ShouldCheckWrap, false)) {
+        UncomputablePtrs.insert(Access.getPointer());
         LLVM_DEBUG(dbgs() << "LAA: Can't find bounds for ptr:"
                           << *Access.getPointer() << '\n');
         Retries.push_back(Access);
         CanDoAliasSetRT = false;
       }
     }
 
     // Note that this function computes CanDoRT and MayNeedRTCheck
while (AI != AE) {
             assert(*I1 != *I2);
             if (*I1 > *I2)
               std::swap(A, B);
 
             Dependence::DepType Type =
                 isDependent(*A.first, A.second, *B.first, B.second, Strides);
             mergeInStatus(Dependence::isSafeForVectorization(Type));
 
+            if (!isSafeForVectorization())
+              UnsafeDependences.push_back(Dependence(A.second, B.second, Type));
+
             // Gather dependences unless we accumulated MaxDependences
             // dependences.  In that case return as soon as we find the first
             // unsafe dependence.  This puts a limit on this quadratic
             // algorithm.
             if (RecordDependences) {
               if (Type != Dependence::NoDep)
                 Dependences.push_back(Dependence(A.second, B.second, Type));
 
               if (Dependences.size() >= MaxDependences) {
                 RecordDependences = false;
                 Dependences.clear();
                 LLVM_DEBUG(dbgs()
                            << "Too many dependences, stopped recording\n");
               }
             }
if (isa<SCEVCouldNotCompute>(ExitCount)) {
     return false;
   }
 
   return true;
 }
 
 void LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
                                  const TargetLibraryInfo *TLI,
                                  DominatorTree *DT) {
   typedef SmallPtrSet<Value*, 16> ValueSet;
 
   // Holds the Load and Store instructions.
   SmallVector<LoadInst *, 16> Loads;
   SmallVector<StoreInst *, 16> Stores;
 
   // Holds all the different accesses in the loop.
   unsigned NumReads = 0;
   unsigned NumReadWrites = 0;
 
   bool HasComplexMemInst = false;
 
   // A runtime check is only legal to insert if there are no convergent calls.
void LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
   // check.
   Accesses.buildDependenceSets();
 
   // Find pointers with computable bounds. We are going to use this information
   // to place a runtime bound check.
   bool CanDoRTIfNeeded = Accesses.canCheckPtrAtRT(*PtrRtChecking, PSE->getSE(),
                                                   TheLoop, SymbolicStrides);
   if (!CanDoRTIfNeeded) {
-    recordAnalysis("CantIdentifyArrayBounds") << "cannot identify array bounds";
     LLVM_DEBUG(dbgs() << "LAA: We can't vectorize because we can't find "
                       << "the array bounds.\n");
     CanVecMem = false;
+    FailReason = FailureReason::UnknownArrayBounds;
+    UncomputablePtrs = std::move(Accesses.getUncomputablePtrs());
     return;
   }
 
   LLVM_DEBUG(
     dbgs() << "LAA: May be able to perform a memory runtime check if needed.\n");
 
   CanVecMem = true;
   if (Accesses.isDependencyCheckNeeded()) {
     LLVM_DEBUG(dbgs() << "LAA: Checking memory dependencies\n");
     CanVecMem = DepChecker->areDepsSafe(
         DependentAccesses, Accesses.getDependenciesToCheck(), SymbolicStrides);
if (!CanVecMem && DepChecker->shouldRetryWithRuntimeCheck()) {
       PtrRtChecking->Need = true;
 
       auto *SE = PSE->getSE();
       CanDoRTIfNeeded = Accesses.canCheckPtrAtRT(*PtrRtChecking, SE, TheLoop,
                                                  SymbolicStrides, true);
 
       // Check that we found the bounds for the pointer.
       if (!CanDoRTIfNeeded) {
-        recordAnalysis("CantCheckMemDepsAtRunTime")
-            << "cannot check memory dependencies at runtime";
         LLVM_DEBUG(dbgs() << "LAA: Can't vectorize with memory checks\n");
         CanVecMem = false;
+        FailReason = FailureReason::UnsafeDataDependenceTriedRT;
         return;
       }
 
       CanVecMem = true;
     }
   }
 
   if (HasConvergentOp) {
     recordAnalysis("CantInsertRuntimeCheckWithConvergent")
       << "cannot add control dependency to convergent operation";
     LLVM_DEBUG(dbgs() << "LAA: We can't vectorize because a runtime check "
                          "would be needed with a convergent operation\n");
     CanVecMem = false;
     return;
   }
 
   if (CanVecMem)
     LLVM_DEBUG(
         dbgs() << "LAA: No unsafe dependent memory operations in loop.  We"
                << (PtrRtChecking->Need ? "" : " don't")
                << " need runtime memory checks.\n");
   else {
-    recordAnalysis("UnsafeMemDep")
+    LLVM_DEBUG(dbgs() << "LAA: unsafe dependent memory operations in loop\n");
+    FailReason = FailureReason::UnsafeDataDependence;
+  }
+}
+
+static DebugLoc getDebugLocFromInstruction(Instruction *I) {
+  DebugLoc Loc;
+  if (auto *D = dyn_cast<Instruction>(I)) {
+    Loc = D->getDebugLoc();
+
+    if (auto *DD = dyn_cast<Instruction>(isa<MemSetInst>(D)
+                                             ? cast<MemSetInst>(D)->getRawDest()
+                                             : getPointerOperand(D)))
+      Loc = DD->getDebugLoc();
+  }
+  return Loc;
+}
+
+/// Add memory access related remarks for TheLoop.
+void LoopAccessInfo::elaborateMemoryReport() {
+  switch (getFailureReason()) {
+  case FailureReason::UnsafeDataDependence: {
+    auto UnsafeDependences = getDepChecker().getUnsafeDependences();
+    assert(UnsafeDependences.size() > 0 &&
+           "expected unsafe dependencies but found none");
+
+    // Emit detailed remarks for each unsafe dependence
+    for (const auto &Dep : UnsafeDependences) {
+      switch (Dep.Type) {
+      case MemoryDepChecker::Dependence::NoDep:
+      case MemoryDepChecker::Dependence::Forward:
+      case MemoryDepChecker::Dependence::BackwardVectorizable:
+        // Don't emit a remark for dependences that don't block vectorization.
+        continue;
+      default:
+        break;
+      }
+
+      DebugLoc SourceLoc = getDebugLocFromInstruction(Dep.getSource(*this));
+
+      OptimizationRemarkAnalysis R =
+          recordAnalysis("UnsafeDep", Dep.getDestination(*this))
           << "unsafe dependent memory operations in loop. Use "
              "#pragma loop distribute(enable) to allow loop distribution "
              "to attempt to isolate the offending operations into a separate "
              "loop";
-    LLVM_DEBUG(dbgs() << "LAA: unsafe dependent memory operations in loop\n");
+      std::string MemlocText = "Memory location is the same as accessed at ";
+      switch (Dep.Type) {
+      case MemoryDepChecker::Dependence::NoDep:
+      case MemoryDepChecker::Dependence::Forward:
+      case MemoryDepChecker::Dependence::BackwardVectorizable:
+        llvm_unreachable("Unexpected dependency");
+      case MemoryDepChecker::Dependence::Backward:
+        ORE->emit(R << "\nBackward loop carried data dependence. " + MemlocText
+                    << ore::NV("Location", SourceLoc));
+        break;
+      case MemoryDepChecker::Dependence::ForwardButPreventsForwarding:
+        ORE->emit(R << "\nForward loop carried data dependence that prevents "
+                       "store-to-load forwarding. " +
+                           MemlocText
+                    << ore::NV("Location", SourceLoc));
+        break;
+      case MemoryDepChecker::Dependence::
+          BackwardVectorizableButPreventsForwarding:
+        ORE->emit(R << "\nBackward loop carried data dependence that prevents "
+                       "store-to-load forwarding. " +
+                           MemlocText
+                    << ore::NV("Location", SourceLoc));
+        break;
+      case MemoryDepChecker::Dependence::Unknown:
+        ORE->emit(
+            R << "\nUnknown data dependence. " + MemlocText
+              << ore::NV("Location", SourceLoc)
+              << ". \n The compiler can't determine the cause of the issue.");
+        break;
+      }
+    }
+    break;
+  }
+  case FailureReason::UnknownArrayBounds: {
+    // Add detailed remarks at locations of pointers where bound cannot
+    // be computed.
+    for (Value *Ptr : getUncomputablePtrs())
+      if (auto *I = dyn_cast<Instruction>(Ptr))
+        ORE->emit(recordAnalysis("UnknownArrayBounds", I)
+                  << "Unable to determine aliasing information because the "
+                     "bounds of this access cannot be computed.");
+    break;
+  }
+  case FailureReason::UnsafeDataDependenceTriedRT:
+    ORE->emit(recordAnalysis("CantCheckMemDepsAtRunTime")
+              << "cannot check memory dependencies at runtime");
+    break;
+  case FailureReason::Unknown:
+    break;
   }
 }
 
 bool LoopAccessInfo::blockNeedsPredication(BasicBlock *BB, Loop *TheLoop,
                                            DominatorTree *DT)  {
   assert(TheLoop->contains(BB) && "Unknown block used");
 
   // Blocks that do not dominate the latch need predication.
   BasicBlock* Latch = TheLoop->getLoopLatch();
   return !DT->dominates(BB, Latch);
 }
 
 OptimizationRemarkAnalysis &LoopAccessInfo::recordAnalysis(StringRef RemarkName,
                                                            Instruction *I) {
-  assert(!Report && "Multiple reports generated");
+  // Check that multiple reports are not generated,
+  // but allow multiple reports of the same type to be reported.
+  assert((!Report || RemarkName == Report->getRemarkName()) &&
+         "Multiple reports generated");
 
   Value *CodeRegion = TheLoop->getHeader();
   DebugLoc DL = TheLoop->getStartLoc();
 
   if (I) {
     CodeRegion = I->getParent();
     // If there is no debug location attached to the instruction, revert back to
     // using the loop's.

 
 LoopAccessInfo::LoopAccessInfo(Loop *L, ScalarEvolution *SE,
                                const TargetLibraryInfo *TLI, AAResults *AA,
                                DominatorTree *DT, LoopInfo *LI)
     : PSE(std::make_unique<PredicatedScalarEvolution>(*SE, *L)),
       PtrRtChecking(std::make_unique<RuntimePointerChecking>(SE)),
       DepChecker(std::make_unique<MemoryDepChecker>(*PSE, L)), TheLoop(L),
       NumLoads(0), NumStores(0), MaxSafeDepDistBytes(-1), CanVecMem(false),
-      HasConvergentOp(false),
-      HasDependenceInvolvingLoopInvariantAddress(false) {
-  if (canAnalyzeLoop())
+      HasConvergentOp(false), HasDependenceInvolvingLoopInvariantAddress(false),
+      FailReason(FailureReason::Unknown) {
+  if (canAnalyzeLoop()) {
     analyzeLoop(AA, LI, TLI, DT);
+    ORE = std::make_unique<OptimizationRemarkEmitter>(
+        L->getHeader()->getParent());
+    elaborateMemoryReport();
+  }
 }
 
 void LoopAccessInfo::print(raw_ostream &OS, unsigned Depth) const {
   if (CanVecMem) {
     OS.indent(Depth) << "Memory dependences are safe";
     if (MaxSafeDepDistBytes != -1ULL)
       OS << " with a maximum dependence distance of " << MaxSafeDepDistBytes
          << " bytes";

llvm/test/Analysis/LoopAccessAnalysis/memory-dep-remarks.ll

+; RUN: opt -passes='loop(require<access-info>)' -disable-output -pass-remarks-analysis=loop-accesses < %s 2>&1 | FileCheck %s
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+
+; // Loop has an array element B[i] (%arrayidx in IR) being used as index to
+; // another array (A), and since the value of B[i] is unknown,
+; // the bound for array A is unknown.
+; void test_unknown_bounds(int* A, int* B, int n) {
+;     for(int i = 0; i < n ; ++i)
+;         A[i] = A[B[i]] + 1;
+; }
+
+; CHECK: remark: source.c:4:16: Unable to determine aliasing information because the bounds of this access cannot be computed.
+
+define void @test_unknown_bounds(i32* nocapture %A, i32* nocapture readonly %B, i64 %n) !dbg !13 {
+entry:
+  %cmp10 = icmp sgt i64 %n, 0
+  br i1 %cmp10, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
+  %0 = load i32, i32* %arrayidx, align 4
+  %idxprom1 = sext i32 %0 to i64, !dbg !35
+  %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %idxprom1, !dbg !35
+  %1 = load i32, i32* %arrayidx2, align 4, !dbg !35
+  %add = add nsw i32 %1, 1
+  %arrayidx4 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv
+  store i32 %add, i32* %arrayidx4, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond.not = icmp eq i64 %indvars.iv.next, %n
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !dbg !28
+}
+
+; // a) Dependence::NoDep
+; // Loop containing only reads (here of the array A) does not hinder vectorization
+; void test_nodep(int n, int* A, int* B) {
+;   for(int i = 1; i < n ; ++i) {
+;     B[i] = A[i-1] + A[i+2];
+;   }
+; }
+
+; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:
+
+define void @test_nodep(i64 %n, i32* nocapture readonly %A, i32* nocapture %B) !dbg !44 {
+entry:
+  %cmp12 = icmp sgt i64 %n, 1
+  br i1 %cmp12, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ 1, %entry ], [ %indvars.iv.next, %for.body ]
+  %0 = add nsw i64 %indvars.iv, -1
+  %arrayidx = getelementptr inbounds i32, i32* %A, i64 %0, !dbg !61
+  %1 = load i32, i32* %arrayidx, align 4, !dbg !61
+  %2 = add nuw nsw i64 %indvars.iv, 2
+  %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %2, !dbg !63
+  %3 = load i32, i32* %arrayidx2, align 4, !dbg !63
+  %add3 = add nsw i32 %3, %1
+  %arrayidx5 = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
+  store i32 %add3, i32* %arrayidx5, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond.not = icmp eq i64 %indvars.iv.next, %n
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
+
+
+; // b) Dependence::Forward
+; // Loop gets vectorized since it contains only a forward
+; // dependency between A[i-2] and A[i]
+; void test_forward(int n, int* A, int* B) {
+;   for(int i=1; i < n; ++i) {
+;     A[i] = 10;
+;     B[i] = A[i-2];
+;   }
+; }
+
+; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:
+define dso_local void @test_forward(i64 %n, i32* nocapture %A, i32* nocapture %B) !dbg !70 {
+entry:
+  %cmp11 = icmp sgt i64 %n, 1
+  br i1 %cmp11, label %for.body, label %for.cond.cleanup, !dbg !81
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ 1, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !83
+  store i32 10, i32* %arrayidx, align 4
+  %0 = add nsw i64 %indvars.iv, -2
+  %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %0, !dbg !87
+  %1 = load i32, i32* %arrayidx2, align 4, !dbg !87
+  %arrayidx4 = getelementptr inbounds i32, i32* %B, i64 %indvars.iv, !dbg !88
+  store i32 %1, i32* %arrayidx4, align 4, !dbg !89
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond.not = icmp eq i64 %indvars.iv.next, %n
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body, !dbg !81
+}
+
+
+; // c) Dependence::BackwardVectorizable
+; // Loop gets vectorized since it contains a backward dependency
+; // between A[i] and A[i-4], but the dependency distance (4) is
+; // greater than the minimum possible VF (2 in this case)
+; void test_backwardVectorizable(int n, int* A, int* B) {
+;   for(int i=4; i < n; ++i) {
+;     A[i] = A[i-4] + 1;
+;   }
+; }
+
+; CHECK-NOT: remark: source.c:{{0-9]+}}:{{[0-9]+}}:
+
+define dso_local void @test_backwardVectorizable(i64 %n, i32* nocapture %A, i32* nocapture readnone %B) !dbg !93 {
+entry:
+  %cmp8 = icmp sgt i64 %n, 4
+  br i1 %cmp8, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ 4, %entry ], [ %indvars.iv.next, %for.body ]
+  %0 = add nsw i64 %indvars.iv, -4, !dbg !106
+  %arrayidx = getelementptr inbounds i32, i32* %A, i64 %0, !dbg !108
+  %1 = load i32, i32* %arrayidx, align 4, !dbg !108
+  %add = add nsw i32 %1, 1
+  %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !110
+  store i32 %add, i32* %arrayidx2, align 4, !dbg !111
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond.not = icmp eq i64 %indvars.iv.next, %n
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
+
+; // d) Dependence::Backward
+; // Loop does not get vectorized since it contains a backward
+; // dependency between A[i] and A[i+3].
+; void test_backward_dep(int n, double *A) {
+;   for (int i = 1; i <= n - 3; i += 3) {
+;     A[i] = A[i-1];
+;     A[i+1] = A[i+3];
+;   }
+; }
+
+; CHECK: remark: source.c:48:14: unsafe dependent memory operations in loop.
+; CHECK-NEXT: Backward loop carried data dependence. Memory location is the same as accessed at source.c:47:5
+
+define void @test_backward_dep(i32 %n, double* nocapture %A) {
+entry:
+  %cmp.not19 = icmp slt i32 %n, 4
+  br i1 %cmp.not19, label %for.cond.cleanup, label %for.body.preheader
+
+for.body.preheader:                               ; preds = %entry
+  %sub = add nsw i32 %n, -3
+  %0 = zext i32 %sub to i64
+  br label %for.body
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %for.body.preheader, %for.body
+  %indvars.iv = phi i64 [ 1, %for.body.preheader ], [ %indvars.iv.next, %for.body ]
+  %1 = add nsw i64 %indvars.iv, -1
+  %arrayidx = getelementptr inbounds double, double* %A, i64 %1
+  %2 = load double, double* %arrayidx, align 8
+  %arrayidx3 = getelementptr inbounds double, double* %A, i64 %indvars.iv, !dbg !157
+  store double %2, double* %arrayidx3, align 8
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 3
+  %arrayidx5 = getelementptr inbounds double, double* %A, i64 %indvars.iv.next, !dbg !160
+  %3 = load double, double* %arrayidx5, align 8, !dbg !160
+  %4 = add nuw nsw i64 %indvars.iv, 1
+  %arrayidx8 = getelementptr inbounds double, double* %A, i64 %4
+  store double %3, double* %arrayidx8, align 8
+  %cmp.not = icmp ugt i64 %indvars.iv.next, %0
+  br i1 %cmp.not, label %for.cond.cleanup, label %for.body
+}
+
+; // e) Dependence::ForwardButPreventsForwarding
+; // Loop does not get vectorized despite only having a forward
+; // dependency between A[i] and A[i-3].
+; // This is because the store-to-load forwarding distance (here 3)
+; // needs to be a multiple of vector factor otherwise the
+; // store (A[5:6] in i=5) and load (A[4:5],A[6:7] in i=7,9) are unaligned.
+; void test_forwardPreventsForwarding_dep(int* A, int* B, int n) {
+;   for(int i=3; i < n; ++i) {
+;     A[i] = 10;
+;     B[i] = A[i-3];
+;   }
+; }
+
+; CHECK: remark: source.c:61:12: unsafe dependent memory operations in loop.
+; CHECK-NEXT: Forward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at source.c:60:5
+
+define void @test_forwardPreventsForwarding_dep(i32* nocapture %A, i32* nocapture %B, i64 %n) !dbg !166 {
+entry:
+  %cmp11 = icmp sgt i64 %n, 3
+  br i1 %cmp11, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ 3, %entry ], [ %indvars.iv.next, %for.body ]
+  %arrayidx = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !179
+  store i32 10, i32* %arrayidx, align 4
+  %0 = add nsw i64 %indvars.iv, -3
+  %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %0, !dbg !183
+  %1 = load i32, i32* %arrayidx2, align 4, !dbg !183
+  %arrayidx4 = getelementptr inbounds i32, i32* %B, i64 %indvars.iv
+  store i32 %1, i32* %arrayidx4, align 4
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond.not = icmp eq i64 %indvars.iv.next, %n
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
+
+; // f) Dependence::BackwardVectorizableButPreventsForwarding
+; // Loop does not get vectorized despite having a backward
+; // but vectorizable dependency between A[i] and A[i-15].
+; //
+; // This is because the store-to-load forwarding distance (here 15)
+; // needs to be a multiple of vector factor otherwise
+; // store (A[16:17] in i=16) and load (A[15:16], A[17:18] in i=30,32) are unaligned.
+; void test_backwardVectorizableButPreventsForwarding(int* A, int n) {
+;   for(int i=15; i < n; ++i) {
+;     A[i] = A[i-2] + A[i-15];
+;   }
+; }
+
+; CHECK: remark: source.c:74:5: unsafe dependent memory operations in loop.
+; CHECK: Backward loop carried data dependence that prevents store-to-load forwarding. Memory location is the same as accessed at source.c:74:21
+
+define void @test_backwardVectorizableButPreventsForwarding(i32* nocapture %A, i64 %n) !dbg !189 {
+entry:
+  %cmp13 = icmp sgt i64 %n, 15
+  br i1 %cmp13, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ 15, %entry ], [ %indvars.iv.next, %for.body ]
+  %0 = add nsw i64 %indvars.iv, -2
+  %arrayidx = getelementptr inbounds i32, i32* %A, i64 %0
+  %1 = load i32, i32* %arrayidx, align 4
+  %2 = add nsw i64 %indvars.iv, -15
+  %arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %2, !dbg !207
+  %3 = load i32, i32* %arrayidx3, align 4
+  %add = add nsw i32 %3, %1
+  %arrayidx5 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !209
+  store i32 %add, i32* %arrayidx5, align 4, !dbg !209
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %exitcond.not = icmp eq i64 %indvars.iv.next, %n
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
+
+; // g) Dependence::Unknown
+; // Different stride lengths
+; void test_unknown_dep(int* A, int n) {
+;   for(int i=0; i < n; ++i) {
+;       A[(i+1)*4] = 10;
+;       A[i] = 100;
+;   }
+; }
+
+; CHECK: remark: source.c:83:7: unsafe dependent memory operations in loop.
+; CHECK: Unknown data dependence. Memory location is the same as accessed at source.c:82:7
+; CHECK-NEXT: The compiler can't determine the cause of the issue
+
+define void @test_unknown_dep(i32* nocapture %A, i64 %n) !dbg !214 {
+entry:
+  %cmp8 = icmp sgt i64 %n, 0
+  br i1 %cmp8, label %for.body, label %for.cond.cleanup
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+
+for.body:                                         ; preds = %entry, %for.body
+  %indvars.iv = phi i64 [ 0, %entry ], [ %indvars.iv.next, %for.body ]
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+  %0 = shl nsw i64 %indvars.iv.next, 2
+  %arrayidx = getelementptr inbounds i32, i32* %A, i64 %0, !dbg !229
+  store i32 10, i32* %arrayidx, align 4
+  %arrayidx2 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !231
+  store i32 100, i32* %arrayidx2, align 4, !dbg !231
+  %exitcond.not = icmp eq i64 %indvars.iv.next, %n
+  br i1 %exitcond.not, label %for.cond.cleanup, label %for.body
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!4}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 14.0.0 (https://github.com/llvm/llvm-project.git 54f0f826c5c7d0ff16c230b259cb6aad33e18d97)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "source.c", directory: "")
+!2 = !{}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = distinct !DISubprogram(name: "test_unknown_bounds", scope: !1, file: !1, line: 2, type: !14, scopeLine: 2, unit: !0, retainedNodes: !18)
+!14 = !DISubroutineType(types: !15)
+!15 = !{null, !16, !16, !17}
+!16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !17, size: 64)
+!17 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!18 = !{}
+!23 = distinct !DILexicalBlock(scope: !13, file: !1, line: 3, column: 5)
+!27 = distinct !DILexicalBlock(scope: !23, file: !1, line: 3, column: 5)
+!28 = !DILocation(line: 3, column: 5, scope: !23)
+!35 = !DILocation(line: 4, column: 16, scope: !27)
+!44 = distinct !DISubprogram(name: "test_nodep", scope: !1, file: !1, line: 14, type: !45, scopeLine: 14, unit: !0, retainedNodes: !47)
+!45 = !DISubroutineType(types: !46)
+!46 = !{null, !17, !16, !16}
+!47 = !{}
+!52 = distinct !DILexicalBlock(scope: !44, file: !1, line: 15, column: 3)
+!56 = distinct !DILexicalBlock(scope: !52, file: !1, line: 15, column: 3)
+!60 = distinct !DILexicalBlock(scope: !56, file: !1, line: 15, column: 31)
+!61 = !DILocation(line: 16, column: 12, scope: !60)
+!63 = !DILocation(line: 16, column: 21, scope: !60)
+!70 = distinct !DISubprogram(name: "test_forward", scope: !1, file: !1, line: 24, type: !45, scopeLine: 24, unit: !0, retainedNodes: !71)
+!71 = !{}
+!77 = distinct !DILexicalBlock(scope: !70, file: !1, line: 25, column: 3)
+!80 = distinct !DILexicalBlock(scope: !77, file: !1, line: 25, column: 3)
+!81 = !DILocation(line: 25, column: 3, scope: !77)
+!83 = !DILocation(line: 26, column: 5, scope: !84)
+!84 = distinct !DILexicalBlock(scope: !80, file: !1, line: 25, column: 28)
+!87 = !DILocation(line: 27, column: 12, scope: !84)
+!88 = !DILocation(line: 27, column: 5, scope: !84)
+!89 = !DILocation(line: 27, column: 10, scope: !84)
+!93 = distinct !DISubprogram(name: "test_backwardVectorizable", scope: !1, file: !1, line: 36, type: !45, scopeLine: 36, unit: !0, retainedNodes: !94)
+!94 = !{}
+!99 = distinct !DILexicalBlock(scope: !93, file: !1, line: 37, column: 3)
+!103 = distinct !DILexicalBlock(scope: !99, file: !1, line: 37, column: 3)
+!106 = !DILocation(line: 38, column: 15, scope: !107)
+!107 = distinct !DILexicalBlock(scope: !103, file: !1, line: 37, column: 28)
+!108 = !DILocation(line: 38, column: 12, scope: !107)
+!110 = !DILocation(line: 38, column: 5, scope: !107)
+!111 = !DILocation(line: 38, column: 10, scope: !107)
+!136 = distinct !DISubprogram(name: "test_backward_dep", scope: !1, file: !1, line: 45, type: !137, scopeLine: 45, unit: !0, retainedNodes: !141)
+!137 = !DISubroutineType(types: !138)
+!138 = !{null, !17, !139}
+!139 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !140, size: 64)
+!140 = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float)
+!141 = !{}
+!145 = distinct !DILexicalBlock(scope: !136, file: !1, line: 46, column: 3)
+!149 = distinct !DILexicalBlock(scope: !145, file: !1, line: 46, column: 3)
+!153 = distinct !DILexicalBlock(scope: !149, file: !1, line: 46, column: 39)
+!157 = !DILocation(line: 47, column: 5, scope: !153)
+!160 = !DILocation(line: 48, column: 14, scope: !153)
+!166 = distinct !DISubprogram(name: "test_forwardPreventsForwarding_dep", scope: !1, file: !1, line: 58, type: !14, scopeLine: 58, unit: !0, retainedNodes: !167)
+!167 = !{}
+!172 = distinct !DILexicalBlock(scope: !166, file: !1, line: 59, column: 3)
+!175 = !DILocation(line: 59, column: 18, scope: !176)
+!176 = distinct !DILexicalBlock(scope: !172, file: !1, line: 59, column: 3)
+!177 = !DILocation(line: 59, column: 3, scope: !172)
+!178 = !DILocation(line: 63, column: 1, scope: !166)
+!179 = !DILocation(line: 60, column: 5, scope: !180)
+!180 = distinct !DILexicalBlock(scope: !176, file: !1, line: 59, column: 28)
+!181 = !DILocation(line: 60, column: 10, scope: !180)
+!182 = !DILocation(line: 61, column: 15, scope: !180)
+!183 = !DILocation(line: 61, column: 12, scope: !180)
+!184 = !DILocation(line: 61, column: 5, scope: !180)
+!185 = !DILocation(line: 61, column: 10, scope: !180)
+!186 = !DILocation(line: 59, column: 23, scope: !176)
+!189 = distinct !DISubprogram(name: "test_backwardVectorizableButPreventsForwarding", scope: !1, file: !1, line: 72, type: !190, scopeLine: 72, unit: !0, retainedNodes: !192)
+!190 = !DISubroutineType(types: !191)
+!191 = !{null, !16, !17}
+!192 = !{}
+!196 = distinct !DILexicalBlock(scope: !189, file: !1, line: 73, column: 3)
+!200 = distinct !DILexicalBlock(scope: !196, file: !1, line: 73, column: 3)
+!204 = distinct !DILexicalBlock(scope: !200, file: !1, line: 73, column: 29)
+!207 = !DILocation(line: 74, column: 21, scope: !204)
+!209 = !DILocation(line: 74, column: 5, scope: !204)
+!214 = distinct !DISubprogram(name: "test_unknown_dep", scope: !1, file: !1, line: 80, type: !190, scopeLine: 80, unit: !0, retainedNodes: !215)
+!215 = !{}
+!219 = distinct !DILexicalBlock(scope: !214, file: !1, line: 81, column: 3)
+!223 = distinct !DILexicalBlock(scope: !219, file: !1, line: 81, column: 3)
+!227 = distinct !DILexicalBlock(scope: !223, file: !1, line: 81, column: 28)
+!229 = !DILocation(line: 82, column: 7, scope: !227)
+!231 = !DILocation(line: 83, column: 7, scope: !227)

llvm/test/Analysis/LoopAccessAnalysis/pointer-phis.ll

 ; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 %s1 = type { [32000 x double], [32000 x double], [32000 x double] }
 
 define i32 @load_with_pointer_phi_no_runtime_checks(%s1* %data) {
 ; CHECK-LABEL: load_with_pointer_phi_no_runtime_checks
 ; CHECK-NEXT:  loop.header:
-; CHECK-NEXT:    Report: cannot identify array bounds
+; CHECK-NEXT:    Report: Unable to determine aliasing information because the bounds of this access cannot be computed.
 ;
 entry:
   br label %loop.header
 
 loop.header:                                        ; preds = %loop.latch, %entry
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
   %iv.next = add nuw nsw i64 %iv, 1
   %cmp5 = icmp ult i64 %iv, 15999

 
 exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 define i32 @store_with_pointer_phi_no_runtime_checks(%s1* %data) {
 ; CHECK-LABEL: 'store_with_pointer_phi_no_runtime_checks'
 ; CHECK-NEXT:  loop.header:
-; CHECK-NEXT:    Report: cannot identify array bounds
+; CHECK-NEXT:    Report: Unable to determine aliasing information because the bounds of this access cannot be computed.
 ;
 entry:
   br label %loop.header
 
 loop.header:                                        ; preds = %loop.latch, %entry
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
   %iv.next = add nuw nsw i64 %iv, 1
   %cmp5 = icmp ult i64 %iv, 15999

 
 exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 define i32 @store_with_pointer_phi_runtime_checks(double* %A, double* %B, double* %C) {
 ; CHECK-LABEL: 'store_with_pointer_phi_runtime_checks'
 ; CHECK-NEXT:  loop.header:
-; CHECK-NEXT:    Report: cannot identify array bounds
+; CHECK-NEXT:    Report: Unable to determine aliasing information because the bounds of this access cannot be computed.
 ;
 entry:
   br label %loop.header
 
 loop.header:                                        ; preds = %loop.latch, %entry
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %loop.latch ]
   %iv.next = add nuw nsw i64 %iv, 1
   %cmp5 = icmp ult i64 %iv, 15999

llvm/test/Analysis/LoopAccessAnalysis/pointer-with-unknown-bounds.ll

 ; RUN: opt -loop-accesses -analyze -enable-new-pm=0 < %s | FileCheck %s
 ; RUN: opt -aa-pipeline=basic-aa -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; We shouldn't quit the analysis if we encounter a pointer without known
 ; bounds *unless* we actually need to emit a memcheck for it.  (We only
 ; compute bounds for SCEVAddRecs so A[i*i] is deemed not having known bounds.)
 ;
 ; for (i = 0; i < 20; ++i)
 ;   A[i*i] *= 2;
 
 ; CHECK-LABEL: addrec_squared
 ; CHECK-NEXT: for.body:
 ; CHECK-NEXT:   Report: unsafe dependent memory operations in loop
-; CHECK-NOT:    Report: cannot identify array bounds
+; CHECK-NOT:    Report: Unable to determine aliasing information because the bounds of this access cannot be computed.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       Unknown:
 ; CHECK-NEXT:         %loadA = load i16, i16* %arrayidxA, align 2 ->
 ; CHECK-NEXT:         store i16 %mul, i16* %arrayidxA, align 2
 
 define void @addrec_squared(i16* %a) {
 entry:
   br label %for.body

 }
 
 ; TODO: We cannot compute the bound for %arrayidxA_ub, because the index is
 ; loaded on each iteration. As %a and %b are no-alias, no memchecks are required
 ; and unknown bounds should not prevent further analysis.
 define void @loaded_bound(i16* noalias %a, i16* noalias %b) {
 ; CHECK-LABEL: loaded_bound
 ; CHECK-NEXT:  for.body:
-; CHECK-NEXT:    Report: cannot identify array bounds
+; CHECK-NEXT:    Report: Unable to determine aliasing information because the bounds of this access cannot be computed.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:    Run-time memory checks:
 
 entry:
   br label %for.body
 
 for.body:                                         ; preds = %for.body, %entry
   %iv = phi i64 [ 0, %entry ], [ %iv.next, %for.body ]

llvm/test/Transforms/LoopVectorize/X86/vectorization-remarks-missed.ll

 ; CHECK: remark: source.cpp:5:9: loop not vectorized
 
 ; void test_disabled(int *A, int Length) {
 ; #pragma clang loop vectorize(disable) interleave(disable)
 ;   for (int i = 0; i < Length; i++)
 ;     A[i] = i;
 ; }
 ; CHECK: remark: source.cpp:12:8: loop not vectorized: vectorization and interleaving are explicitly disabled, or the loop has already been vectorized
-
+j
 ; void test_array_bounds(int *A, int *B, int Length) {
 ; #pragma clang loop vectorize(enable)
 ;   for (int i = 0; i < Length; i++)
 ;     A[i] = A[B[i]];
 ; }
-; CHECK: remark: source.cpp:19:5: loop not vectorized: cannot identify array bounds
+; CHECK: remark: source.cpp:19:5: loop not vectorized: Unable to determine aliasing information because the bounds of this access cannot be computed.
 ; CHECK: remark: source.cpp:19:5: loop not vectorized
 ; CHECK: warning: source.cpp:19:5: loop not vectorized: the optimizer was unable to perform the requested transformation; the transformation might be disabled or specified as part of an unsupported transformation ordering
 
 ; int foo();
 ; void test_multiple_failures(int *A) {
 ;   int k = 0;
 ; #pragma clang loop vectorize(enable) interleave(enable)
 ;   for (int i = 0; i < 1000; i+=A[i]) {

 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            AllDisabled
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 12, Column: 8 }
 ; YAML-NEXT: Function:        _Z13test_disabledPii
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'loop not vectorized: vectorization and interleaving are explicitly disabled, or the loop has already been vectorized
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Analysis
+; YAML-NEXT: Pass:            loop-accesses
+; YAML-NEXT: Name:            UnknownArrayBounds
+; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 19, Column: 5 }
+; YAML-NEXT: Function:        _Z17test_array_boundsPiS_i
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          'Unable to determine aliasing information because the bounds of this access cannot be computed.'
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Analysis
 ; YAML-NEXT: Pass:            ''
-; YAML-NEXT: Name:            CantIdentifyArrayBounds
+; YAML-NEXT: Name:            UnknownArrayBounds
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 19, Column: 5 }
 ; YAML-NEXT: Function:        _Z17test_array_boundsPiS_i
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          'loop not vectorized: '
-; YAML-NEXT:   - String:          cannot identify array bounds
+; YAML-NEXT:   - String:          'Unable to determine aliasing information because the bounds of this access cannot be computed.'
 ; YAML-NEXT: ...
 ; YAML-NEXT: --- !Missed
 ; YAML-NEXT: Pass:            loop-vectorize
 ; YAML-NEXT: Name:            MissedDetails
 ; YAML-NEXT: DebugLoc:        { File: source.cpp, Line: 19, Column: 5 }
 ; YAML-NEXT: Function:        _Z17test_array_boundsPiS_i
 ; YAML-NEXT: Args:
 ; YAML-NEXT:   - String:          loop not vectorized

llvm/test/Transforms/LoopVectorize/diag-with-hotness-info-2.ll

 ;  14
 ;  15 void unknown(char *A, char *B, char *C, char *D, char *E, int N) {
 ;  16   for(int i = 0; i < N; i++) {
 ;  17     A[i + 1] = A[i] + B[i];
 ;  18     C[i] = D[i] * E[i];
 ;  19   }
 ;  20 }
 
-; CHECK: remark: /tmp/s.c:2:3: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop (hotness: 300)
-; CHECK: remark: /tmp/s.c:9:3: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop (hotness: 5000)
-; CHECK: remark: /tmp/s.c:16:3: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop{{$}}
+; CHECK: remark: /tmp/s.c:3:14: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop (hotness: 300)
+; CHECK: remark: /tmp/s.c:10:14: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop (hotness: 5000)
+; CHECK: remark: /tmp/s.c:17:14: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop{{$}}
 
 ; ModuleID = '/tmp/s.c'
 source_filename = "/tmp/s.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; Function Attrs: norecurse nounwind ssp uwtable
 define void @cold(i8* nocapture %A, i8* nocapture readonly %B, i8* nocapture %C, i8* nocapture readonly %D, i8* nocapture readonly %E, i32 %N) local_unnamed_addr #0 !dbg !7 !prof !56 {
 entry:

llvm/test/Transforms/LoopVectorize/unsafe-dep-remark.ll

 ; RUN: opt -loop-vectorize -force-vector-width=2 -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s
 
 ; ModuleID = '/tmp/kk.c'
 source_filename = "/tmp/kk.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ;     1 void success (char *A, char *B, char *C, char *D, char *E, int N) {
 ;     2   for(int i = 0; i < N; i++) {
 ;     3     A[i + 1] = A[i] + B[i];
 ;     4     C[i] = D[i] * E[i];
 ;     5   }
 ;     6 }
 
-; CHECK: remark: /tmp/kk.c:2:3: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
+; CHECK: remark: /tmp/kk.c:3:14: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop
 
 define void @success(i8* nocapture %A, i8* nocapture readonly %B, i8* nocapture %C, i8* nocapture readonly %D, i8* nocapture readonly %E, i32 %N) !dbg !6 {
 entry:
   %cmp28 = icmp sgt i32 %N, 0, !dbg !8
   br i1 %cmp28, label %for.body, label %for.cond.cleanup, !dbg !9
 
 for.body:                                         ; preds = %entry, %for.body
   %indvars.iv = phi i64 [ %indvars.iv.next, %for.body ], [ 0, %entry ]