[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

587

Remark instead of 'insight'?

1761

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

2133

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

247

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

587

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

1756

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

247

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

587

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

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

1756

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

521

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

247

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

2111

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).

2155

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

2212–2213

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

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

12 ↗

(On Diff #371371)

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

2111

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

12 ↗

(On Diff #371371)

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

2216

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

793

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

12 ↗

(On Diff #371371)

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

793

Done. thanks for that suggestion.

2216

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

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

12 ↗

(On Diff #371371)

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

615

This seems unused?

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2080

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.

2083

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

[sdesmalen]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

1759

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

2111

unnecessary change.

2137

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.

2139

nit: Please remove the newline.

2139

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

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

121

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

615

thanks for pointing it out. Removed it.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

1759

There can be more.

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

2080

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.

2137

Thanks for pointing this out. Done.

2139

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

121

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

585

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?

1762

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.

1844

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).

1847–1849

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

2081

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?

2082

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

295

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

295

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

llvm/lib/Analysis/LoopAccessAnalysis.cpp

585

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

1762

Done.
That's a good point, thanks !

1844

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

2081

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

2132

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?

2134

nit: variable names here start with upper cases

2137

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

2145

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

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

2

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

17

nit: check here not needed?

20

nit: easier to read if this is the last block

122

Is this needed? Same for other tests.

127

is this needed?

265

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

2145

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

122

Can you please explain why this is not needed ?

127

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

265

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

2138

Can this be an assert?

2145

Can this be an assert?

2151

nit: please move this code below the switch

2155

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

121

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

2138

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.

2145

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)

2155

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

121

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

2138

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

2140–2148

nit:

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

2182–2189

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/ScalarEvolutionExpressions.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/Pass.h"
 
 namespace llvm {
 
 class AAResults;
 class DataLayout;
 class Loop;
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;
 
 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;
   const Loop *InnermostLoop;
private:
   //// Dependences is invalid.
   bool RecordDependences = true;
 
   /// Memory dependences collected during the analysis.  Only valid if
   /// RecordDependences is true.
   SmallVector<Dependence, 8> Dependences;
 
   /// 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
   /// plausible dependence but the dependence distance is bigger than one
   /// element access it records this distance in \p MaxSafeDepDistBytes (if this
   /// distance is smaller than any other distance encountered so far).
public:
   LoopAccessInfo(Loop *L, ScalarEvolution *SE, const TargetLibraryInfo *TLI,
                  AAResults *AA, DominatorTree *DT, LoopInfo *LI);
 
   /// Return true we can analyze the memory accesses in the loop and there are
   /// no memory dependence cycles.
   bool canVectorizeMemory() const { return CanVecMem; }
 
   /// 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();
   }
 
   /// Number of memchecks required to prove independence of otherwise
OptimizationRemarkAnalysis &recordAnalysis(StringRef RemarkName,
                                              Instruction *Instr = nullptr);
 
   /// Collect memory access with loop invariant strides.
   ///
   /// Looks for accesses like "a[i * StrideA]" where "StrideA" is loop
   /// invariant.
   void collectStridedAccess(Value *LoadOrStoreInst);
 
+  // Emits the first unsafe memory dependence in a loop.
+  // Emits nothing if there are no unsafe dependences
+  // or if the dependences were not recorded.
+  void emitUnsafeDependenceRemark();
+
   std::unique_ptr<PredicatedScalarEvolution> PSE;
 
   /// 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;
 
   Loop *TheLoop;

llvm/lib/Analysis/LoopAccessAnalysis.cpp

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; }
 
 private:
   typedef SetVector<MemAccessInfo> PtrAccessSet;
 
   /// 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)) {
         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
     // independently. For example CanDoRT=false, MayNeedRTCheck=false means that
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));
 
             // 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,
   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;
     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);
     MaxSafeDepDistBytes = DepChecker->getMaxSafeDepDistBytes();
 
if (!CanVecMem && DepChecker->shouldRetryWithRuntimeCheck()) {
                                                  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;
         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")
-        << "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");
+  else
+    emitUnsafeDependenceRemark();
+}
+
+void LoopAccessInfo::emitUnsafeDependenceRemark() {
+  auto Deps = getDepChecker().getDependences();
+  if (!Deps)
+    return;
+  auto Found = std::find_if(
+      Deps->begin(), Deps->end(), [](const MemoryDepChecker::Dependence &D) {
+        return MemoryDepChecker::Dependence::isSafeForVectorization(D.Type) !=
+               MemoryDepChecker::VectorizationSafetyStatus::Safe;
+      });
+  if (Found == Deps->end())
+    return;
+  MemoryDepChecker::Dependence Dep = *Found;
+
+  LLVM_DEBUG(dbgs() << "LAA: unsafe dependent memory operations in loop\n");
+
+  // Emit remark for first unsafe dependence
+  OptimizationRemarkAnalysis &R =
+      recordAnalysis("UnsafeDep", Dep.getDestination(*this))
+
+  switch (Dep.Type) {
+  case MemoryDepChecker::Dependence::NoDep:
+  case MemoryDepChecker::Dependence::Forward:
+  case MemoryDepChecker::Dependence::BackwardVectorizable:
+    llvm_unreachable("Unexpected dependence");
+  case MemoryDepChecker::Dependence::Backward:
+    R << "\nBackward loop carried data dependence.";
+    break;
+  case MemoryDepChecker::Dependence::ForwardButPreventsForwarding:
+    R << "\nForward loop carried data dependence that prevents "
+         "store-to-load forwarding.";
+    break;
+  case MemoryDepChecker::Dependence::BackwardVectorizableButPreventsForwarding:
+    R << "\nBackward loop carried data dependence that prevents "
+         "store-to-load forwarding.";
+    break;
+  case MemoryDepChecker::Dependence::Unknown:
+    R << "\nUnknown data dependence.";
+    break;
+  }
+
+  if (Instruction *I = Dep.getSource(*this)) {
+    DebugLoc SourceLoc = I->getDebugLoc();
+    if (auto *DD = dyn_cast_or_null<Instruction>(getPointerOperand(I)))
+      SourceLoc = DD->getDebugLoc();
+    if (SourceLoc)
+      R << " Memory location is the same as accessed at "
+        << ore::NV("Location", SourceLoc);
   }
 }
 
 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");
 
   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.
     if (I->getDebugLoc())
       DL = I->getDebugLoc();
   }
 
   Report = std::make_unique<OptimizationRemarkAnalysis>(DEBUG_TYPE, RemarkName, DL,
                                                    CodeRegion);
   return *Report;
 }
 
 bool LoopAccessInfo::isUniform(Value *V) const {
   auto *SE = PSE->getSE();
   // Since we rely on SCEV for uniformity, if the type is not SCEVable, it is
   // never considered uniform.
   // TODO: Is this really what we want? Even without FP SCEV, we may want some
   // trivially loop-invariant FP values to be considered uniform.

llvm/test/Analysis/LoopAccessAnalysis/depend_diff_types.ll

 ; In the function below one of the accesses is done as i19 type, which has a
 ; different store size than the i32 type, even though their alloc sizes are
 ; equivalent. This is a negative test to ensure that they are not analyzed as
 ; in the tests above.
 ;
 ; CHECK-LABEL: function 'backdep_type_store_size_equivalence':
 ; CHECK-NEXT:    loop:
 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop.
+; CHECK-NEXT:      Unknown data dependence.
 ; CHECK-NEXT:      Dependences:
 ; CHECK-NEXT:        Unknown:
 ; CHECK-NEXT:            %ld.f32 = load float, float* %gep.iv.f32, align 8 ->
 ; CHECK-NEXT:            store i19 %indvars.iv.i19, i19* %gep.iv.i19, align 8
 ; CHECK-EMPTY:
 ; CHECK-NEXT:        Run-time memory checks:
 ; CHECK-NEXT:        Grouped accesses:
 

 
 ; In the function below some of the accesses are done as double types and some
 ; are done as i64 and i32 types. This is a negative test to ensure that they
 ; are not analyzed as in the tests above.
 
 ; CHECK-LABEL: function 'neg_dist_dep_type_size_equivalence':
 ; CHECK-NEXT:    loop:
 ; CHECK-NEXT:      Report: unsafe dependent memory operations in loop.
+; CHECK-NEXT:      Unknown data dependence.
 ; CHECK-NEXT:      Dependences:
 ; CHECK-NEXT:        Unknown:
 ; CHECK-NEXT:            %ld.i64 = load i64, i64* %gep.iv, align 8 ->
 ; CHECK-NEXT:            store i32 %ld.i64.i32, i32* %gep.iv.n.i32, align 8
 ; CHECK-EMPTY:
 ; CHECK-NEXT:        ForwardButPreventsForwarding:
 ; CHECK-NEXT:            store double %val, double* %gep.iv.101.f64, align 8 ->
 ; CHECK-NEXT:            %ld.i64 = load i64, i64* %gep.iv, align 8

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

 exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 define i32 @load_with_pointer_phi_outside_loop(double* %A, double* %B, double* %C, i1 %c.0, i1 %c.1) {
 ; CHECK-LABEL: 'load_with_pointer_phi_outside_loop'
 ; CHECK-NEXT:  loop.header:
 ; CHECK-NEXT:    Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:    Unknown data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Unknown:
 ; CHECK-NEXT:          %v8 = load double, double* %ptr, align 8 ->
 ; CHECK-NEXT:          store double %mul16, double* %arrayidx, align 8
 ;
 entry:
   br i1 %c.0, label %if.then, label %if.else
 

 exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 define i32 @store_with_pointer_phi_outside_loop(double* %A, double* %B, double* %C, i1 %c.0, i1 %c.1) {
 ; CHECK-LABEL: 'store_with_pointer_phi_outside_loop'
 ; CHECK-NEXT:  loop.header:
 ; CHECK-NEXT:    Report: unsafe dependent memory operations in loop.
+; CHECK-NEXT:    Unknown data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Unknown:
 ; CHECK-NEXT:          %v8 = load double, double* %arrayidx, align 8 ->
 ; CHECK-NEXT:          store double %mul16, double* %ptr, align 8
 ;
 entry:
   br i1 %c.0, label %if.then, label %if.else
 

 exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 define i32 @store_with_pointer_phi_incoming_phi(double* %A, double* %B, double* %C, i1 %c.0, i1 %c.1) {
 ; CHECK-LABEL: 'store_with_pointer_phi_incoming_phi'
 ; CHECK-NEXT:  loop.header:
 ; CHECK-NEXT:    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
+; CHECK-NEXT:    Unknown data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Unknown:
 ; CHECK-NEXT:          %v8 = load double, double* %arrayidx, align 8 ->
 ; CHECK-NEXT:          store double %mul16, double* %ptr.2, align 8
 ; CHECK-EMPTY:
 ; CHECK-NEXT:    Run-time memory checks:
 ; CHECK-NEXT:    Check 0:
 ; CHECK-NEXT:      Comparing group ([[GROUP_C:.+]]):
exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 ; Test cases with pointer phis forming a cycle.
 define i32 @store_with_pointer_phi_incoming_phi_irreducible_cycle(double* %A, double* %B, double* %C, i1 %c.0, i1 %c.1) {
 ; CHECK-LABEL: 'store_with_pointer_phi_incoming_phi_irreducible_cycle'
 ; CHECK-NEXT:  loop.header:
 ; CHECK-NEXT:    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
+; CHECK-NEXT:    Unknown data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Unknown:
 ; CHECK-NEXT:          %v8 = load double, double* %arrayidx, align 8 ->
 ; CHECK-NEXT:          store double %mul16, double* %ptr.3, align 8
 ; CHECK-EMPTY:
 ; CHECK-NEXT:    Run-time memory checks:
 ; CHECK-NEXT:    Check 0:
 ; CHECK-NEXT:      Comparing group ([[GROUP_C:.+]]):

 exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 define i32 @store_with_pointer_phi_outside_loop_select(double* %A, double* %B, double* %C, i1 %c.0, i1 %c.1) {
 ; CHECK-LABEL: 'store_with_pointer_phi_outside_loop_select'
 ; CHECK-NEXT:  loop.header:
 ; CHECK-NEXT:    Report: unsafe dependent memory operations in loop.
+; CHECK-NEXT:    Unknown data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Unknown:
 ; CHECK-NEXT:          %v8 = load double, double* %arrayidx, align 8 ->
 ; CHECK-NEXT:          store double %mul16, double* %ptr, align 8
 ;
 entry:
   br i1 %c.0, label %if.then, label %if.else
 

 exit:                                             ; preds = %loop.latch
   ret i32 10
 }
 
 define void @phi_load_store_memdep_check(i1 %c, i16* %A, i16* %B, i16* %C) {
 ; CHECK-LABEL: Loop access info in function 'phi_load_store_memdep_check':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:    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
+; CHECK-NEXT:    Unknown data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Unknown:
 ; CHECK-NEXT:          %lv3 = load i16, i16* %c.sink, align 2 ->
 ; CHECK-NEXT:          store i16 %add, i16* %c.sink, align 1
 ; CHECK-EMPTY:
 ; CHECK-NEXT:      Unknown:
 ; CHECK-NEXT:          %lv3 = load i16, i16* %c.sink, align 2 ->
 ; CHECK-NEXT:          store i16 %add, i16* %c.sink, align 1

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

 ; 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-NEXT:   Unknown data dependence.
 ; 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

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

 ; void unsafe_Read_Write(int *A) {
 ;   for (unsigned i = 0; i < 1024; i+=3)
 ;     A[i+3] = A[i] + 1;
 ; }
 
 ; CHECK: function 'unsafe_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:     Backward loop carried data dependence.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:           %0 = load i32, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx3, align 4
 
 define void @unsafe_Read_Write(i32* nocapture %A) {
 entry:
   br label %for.body

 ;   }
 ;
 ;   return sum;
 ; }
 
 ; CHECK: function 'unsafe_Write_Read':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:     Backward loop carried data dependence.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           %1 = load i32, i32* %arrayidx2, align 4
 
 define i32 @unsafe_Write_Read(i32* nocapture %A) {
 entry:
   br label %for.body

 ;     A[i] = i;
 ;     A[i+2] = i+1;
 ;   }
 ; }
 
 ; CHECK: function 'unsafe_Write_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:     Backward loop carried data dependence.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:           store i32 %0, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx3, align 4
 
 define void @unsafe_Write_Write(i32* nocapture %A) {
 entry:
   br label %for.body

 ; }
 
 ; FIXME: This case looks like previous case @vectorizable_Read_Write. It sould
 ; be vectorizable.
 
 ; CHECK: function 'vectorizable_unscaled_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:     Backward loop carried data dependence that prevents store-to-load forwarding.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       BackwardVectorizableButPreventsForwarding:
 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 ->
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 
 define void @vectorizable_unscaled_Read_Write(i32* nocapture %A) {
 entry:
   %0 = bitcast i32* %A to i8*

 ;   int *B = (int *)((char *)A + 11);
 ;   for (unsigned i = 0; i < 1024; i+=2)
 ;     B[i] = A[i] + 1;
 ; }
 
 ; CHECK: function 'unsafe_unscaled_Read_Write':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:     Backward loop carried data dependence.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       Backward:
 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 
 define void @unsafe_unscaled_Read_Write(i32* nocapture %A) {
 entry:
   %0 = bitcast i32* %A to i8*
for.body:                                         ; preds = %entry, %for.body
   %indvars.iv.next = add nuw nsw i64 %indvars.iv, 2
   %cmp = icmp ult i64 %indvars.iv.next, 1024
   br i1 %cmp, label %for.body, label %for.cond.cleanup
 }
 
 ; CHECK: function 'unsafe_unscaled_Read_Write2':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:     Backward loop carried data dependence.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       Backward:
 ; CHECK-NEXT:           %2 = load i32, i32* %arrayidx, align 4 -> 
 ; CHECK-NEXT:           store i32 %add, i32* %arrayidx2, align 4
 
 ; void unsafe_unscaled_Read_Write2(int *A) {
 ;   int *B = (int *)((char *)A + 1);
 ;   for (unsigned i = 0; i < 1024; i+=2)

 ;   }
 ; }
 ;
 ; The access (2) has overlaps with (1) and (3).
 
 ; CHECK: function 'interleaved_stores':
 ; CHECK-NEXT:   for.body:
 ; CHECK-NEXT:     Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:     Backward loop carried data dependence.
 ; CHECK-NEXT:     Dependences:
 ; CHECK-NEXT:       Backward:
 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx5, align 4 -> 
 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx9, align 4
 ; CHECK:       Backward:
 ; CHECK-NEXT:           store i32 %2, i32* %arrayidx2, align 4 -> 
 ; CHECK-NEXT:           store i32 %4, i32* %arrayidx5, align 4
 

llvm/test/Analysis/LoopAccessAnalysis/symbolic-stride.ll

 ; RUN: opt -S -disable-output -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' %s 2>&1 | FileCheck %s
 
 ;
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 
 ; A forwarding in the presence of symbolic strides.
 define void @single_stride(i32* noalias %A, i32* noalias %B, i64 %N, i64 %stride) {
 ; CHECK-LABEL: Loop access info in function 'single_stride':
 ; CHECK-NEXT:  loop:
 ; CHECK-NEXT:    Report: unsafe dependent memory operations in loop.
+; CHECK-NEXT:    Backward loop carried data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:          %load = load i32, i32* %gep.A, align 4 ->
 ; CHECK-NEXT:          store i32 %add, i32* %gep.A.next, align 4
 ; CHECK-EMPTY:
 ; CHECK-NEXT:    Run-time memory checks:
 ; CHECK-NEXT:    Grouped accesses:
 ; CHECK-EMPTY:
exit:                                          ; preds = %loop
   ret void
 }
 
 ; Similar to @single_stride, but with struct types.
 define void @single_stride_struct({ i32, i8 }* noalias %A, { i32, i8 }* noalias %B, i64 %N, i64 %stride) {
 ; CHECK-LABEL: Loop access info in function 'single_stride_struct':
 ; CHECK-NEXT:  loop:
 ; CHECK-NEXT:    Report: unsafe dependent memory operations in loop.
+; CHECK-NEXT:    Backward loop carried data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:          %load = load { i32, i8 }, { i32, i8 }* %gep.A, align 4 ->
 ; CHECK-NEXT:          store { i32, i8 } %ins, { i32, i8 }* %gep.A.next, align 4
 ; CHECK-EMPTY:
 ; CHECK-NEXT:    Run-time memory checks:
 ; CHECK-NEXT:    Grouped accesses:
 ; CHECK-EMPTY:
exit:
   ret void
 }
 
 ; A loop with two symbolic strides.
 define void @two_strides(i32* noalias %A, i32* noalias %B, i64 %N, i64 %stride.1, i64 %stride.2) {
 ; CHECK-LABEL: Loop access info in function 'two_strides':
 ; CHECK-NEXT:  loop:
 ; CHECK-NEXT:    Report: unsafe dependent memory operations in loop.
+; CHECK-NEXT:    Backward loop carried data dependence.
 ; CHECK-NEXT:    Dependences:
 ; CHECK-NEXT:      Backward:
 ; CHECK-NEXT:          %load = load i32, i32* %gep.A, align 4 ->
 ; CHECK-NEXT:          store i32 %add, i32* %gep.A.next, align 4
 ; CHECK-EMPTY:
 ; CHECK-NEXT:    Run-time memory checks:
 ; CHECK-NEXT:    Grouped accesses:
 ; CHECK-EMPTY:

llvm/test/Analysis/LoopAccessAnalysis/underlying-objects-2.ll

 ; distance).
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; CHECK-LABEL: function 'f'
 ; CHECK: for_j.body:
 ; CHECK-NEXT: Report: unsafe dependent memory operations in loop
+; CHECK-NEXT: Backward loop carried data dependence.
 ; CHECK-NEXT: Dependences:
 ; CHECK-NEXT: Backward:
 ; CHECK-NEXT: %loadB = load i8, i8* %gepB, align 1 ->
 ; CHECK-NEXT: store i8 2, i8* %gepB_plus_one, align 1
 
 define void @f(i8** noalias %A, i8* noalias %B, i64 %N) {
 for_i.preheader:
   %prev_0 = load i8*, i8** %A, align 8

llvm/test/Analysis/LoopAccessAnalysis/unsafe-and-rt-checks.ll

 ; RUN: opt -passes='require<scalar-evolution>,require<aa>,loop(print-access-info)' -disable-output  < %s 2>&1 | FileCheck %s
 
 ; Analyze this loop:
 ;   for (i = 0; i < n; i++)
 ;    A[i + 1] = A[i] * B[i] * C[i];
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; CHECK: Report: unsafe dependent memory operations in loop
+; CHECK-NEXT:  Backward loop carried data dependence.
 ; CHECK-NEXT: Dependences:
 ; CHECK-NEXT:   Backward:
 ; CHECK-NEXT:     %loadA = load i16, i16* %arrayidxA, align 2 ->
 ; CHECK-NEXT:     store i16 %mul1, i16* %arrayidxA_plus_2, align 2
 ; CHECK: Run-time memory checks:
 ; CHECK-NEXT: 0:
 ; CHECK-NEXT: Comparing group
 ; CHECK-NEXT:   %arrayidxA = getelementptr inbounds i16, i16* %a, i64 %storemerge3

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
+; CHECK-NEXT: Backward loop carried data dependence. Memory location is the same as accessed at /tmp/s.c:3:16 (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
+; CHECK-NEXT: Backward loop carried data dependence. Memory location is the same as accessed at /tmp/s.c:10:16 (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
+; CHECK-NEXT: Backward loop carried data dependence. Memory location is the same as accessed at /tmp/s.c:17:16{{$}}
 
 ; 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/memory-dep-remarks.ll

+; RUN: opt -passes='loop(require<access-info>),function(loop-vectorize)' -disable-output -pass-remarks-analysis=loop-vectorize < %s 2>&1 | FileCheck %s
+; RUN: opt < %s -passes='loop(require<access-info>),function(loop-vectorize)' -o /dev/null -pass-remarks-output=%t.yaml
+; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
+
+target datalayout = "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128"
+
+; // 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.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
+
+for.cond.cleanup:                                 ; preds = %for.body, %entry
+  ret void
+}
+
+
+; // 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.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
+
+  for.cond.cleanup:                                 ; preds = %for.body, %entry
+    ret void
+}
+
+
+; // 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) {
+;   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) !dbg !93 {
+entry:
+  %cmp8 = icmp sgt i64 %n, 4
+  br i1 %cmp8, label %for.body, label %for.cond.cleanup
+
+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
+
+  for.cond.cleanup:                                 ; preds = %for.body, %entry
+    ret void
+}
+
+; // 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, int *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: 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-NEXT: Backward loop carried data dependence. Memory location is the same as accessed at source.c:47:5
+
+define void @test_backward_dep(i64 %n, i32* nocapture %A) {
+entry:
+  %cmp.not19 = icmp slt i64 %n, 4
+  br i1 %cmp.not19, label %for.cond.cleanup, label %for.body.preheader
+
+for.body.preheader:                               ; preds = %entry
+  %sub = add nsw i64 %n, -3
+  br label %for.body
+
+for.body:                                         ; preds = %for.body.preheader, %for.body
+  %indvars.iv = phi i64 [ 1, %for.body.preheader ], [ %indvars.iv.next, %for.body ]
+  %0 = add nsw i64 %indvars.iv, -1
+  %arrayidx = getelementptr inbounds i32, i32* %A, i64 %0
+  %1 = load i32, i32* %arrayidx, align 8
+  %arrayidx3 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv, !dbg !157
+  store i32 %1, i32* %arrayidx3, align 8
+  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 3
+  %arrayidx5 = getelementptr inbounds i32, i32* %A, i64 %indvars.iv.next, !dbg !160
+  %2 = load i32, i32* %arrayidx5, align 8, !dbg !160
+  %3 = add nuw nsw i64 %indvars.iv, 1
+  %arrayidx8 = getelementptr inbounds i32, i32* %A, i64 %3
+  store i32 %2, i32* %arrayidx8, align 8
+  %cmp.not = icmp ugt i64 %indvars.iv.next, %n
+  br i1 %cmp.not, label %for.cond.cleanup, label %for.body
+
+  for.cond.cleanup:                                 ; preds = %for.body, %entry
+    ret void
+}
+
+; // 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_forwardButPreventsForwarding_dep(int n, int* A, int* B) {
+;   for(int i=3; i < n; ++i) {
+;     A[i] = 10;
+;     B[i] = A[i-3];
+;   }
+; }
+
+; CHECK: remark: source.c:61:12: 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-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_forwardButPreventsForwarding_dep(i64 %n, i32* nocapture %A, i32* nocapture %B) !dbg !166 {
+entry:
+  %cmp11 = icmp sgt i64 %n, 3
+  br i1 %cmp11, label %for.body, label %for.cond.cleanup
+
+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
+
+  for.cond.cleanup:                                 ; preds = %for.body, %entry
+    ret void
+}
+
+; // 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 n, int* A) {
+;   for(int i=15; i < n; ++i) {
+;     A[i] = A[i-2] + A[i-15];
+;   }
+; }
+
+; CHECK: remark: source.c:74:5: 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: 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(i64 %n, i32* nocapture %A) !dbg !189 {
+entry:
+  %cmp13 = icmp sgt i64 %n, 15
+  br i1 %cmp13, label %for.body, label %for.cond.cleanup
+
+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
+
+  for.cond.cleanup:                                 ; preds = %for.body, %entry
+    ret void
+}
+
+; // g) Dependence::Unknown
+; // Different stride lengths
+; void test_unknown_dep(int n, int* A) {
+;   for(int i=0; i < n; ++i) {
+;       A[(i+1)*4] = 10;
+;       A[i] = 100;
+;   }
+; }
+
+; CHECK: remark: source.c:83:7: 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: Unknown data dependence. Memory location is the same as accessed at source.c:82:7
+
+define void @test_unknown_dep(i64 %n, i32* nocapture %A) !dbg !214 {
+entry:
+  %cmp8 = icmp sgt i64 %n, 0
+  br i1 %cmp8, label %for.body, label %for.cond.cleanup
+
+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
+
+  for.cond.cleanup:                                 ; preds = %for.body, %entry
+    ret void
+}
+
+; YAML:      --- !Analysis
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            UnsafeDep
+; YAML-NEXT: DebugLoc:        { File: source.c, Line: 48, Column: 14 }
+; YAML-NEXT: Function:        test_backward_dep
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          'loop not vectorized: '
+; YAML-NEXT:   - String:          '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'
+; YAML-NEXT:   - String:          "\nBackward loop carried data dependence."
+; YAML-NEXT:   - String:          ' Memory location is the same as accessed at '
+; YAML-NEXT:   - Location:        'source.c:47:5'
+; YAML-NEXT:     DebugLoc:        { File: source.c, Line: 47, Column: 5 }
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Missed
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            MissedDetails
+; YAML-NEXT: Function:        test_backward_dep
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          loop not vectorized
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Analysis
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            UnsafeDep
+; YAML-NEXT: DebugLoc:        { File: source.c, Line: 61, Column: 12 }
+; YAML-NEXT: Function:        test_forwardButPreventsForwarding_dep
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          'loop not vectorized: '
+; YAML-NEXT:   - String:          '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'
+; YAML-NEXT:   - String:          "\nForward loop carried data dependence that prevents store-to-load forwarding."
+; YAML-NEXT:   - String:          ' Memory location is the same as accessed at '
+; YAML-NEXT:   - Location:        'source.c:60:5'
+; YAML-NEXT:     DebugLoc:        { File: source.c, Line: 60, Column: 5 }
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Missed
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            MissedDetails
+; YAML-NEXT: Function:        test_forwardButPreventsForwarding_dep
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          loop not vectorized
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Analysis
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            UnsafeDep
+; YAML-NEXT: DebugLoc:        { File: source.c, Line: 74, Column: 5 }
+; YAML-NEXT: Function:        test_backwardVectorizableButPreventsForwarding
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          'loop not vectorized: '
+; YAML-NEXT:   - String:          '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'
+; YAML-NEXT:   - String:          "\nBackward loop carried data dependence that prevents store-to-load forwarding."
+; YAML-NEXT:   - String:          ' Memory location is the same as accessed at '
+; YAML-NEXT:   - Location:        'source.c:74:21'
+; YAML-NEXT:     DebugLoc:        { File: source.c, Line: 74, Column: 21 }
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Missed
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            MissedDetails
+; YAML-NEXT: Function:        test_backwardVectorizableButPreventsForwarding
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          loop not vectorized
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Analysis
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            UnsafeDep
+; YAML-NEXT: DebugLoc:        { File: source.c, Line: 83, Column: 7 }
+; YAML-NEXT: Function:        test_unknown_dep
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          'loop not vectorized: '
+; YAML-NEXT:   - String:          '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'
+; YAML-NEXT:   - String:          "\nUnknown data dependence."
+; YAML-NEXT:   - String:          ' Memory location is the same as accessed at '
+; YAML-NEXT:   - Location:        'source.c:82:7'
+; YAML-NEXT:     DebugLoc:        { File: source.c, Line: 82, Column: 7 }
+; YAML-NEXT: ...
+; YAML-NEXT: --- !Missed
+; YAML-NEXT: Pass:            loop-vectorize
+; YAML-NEXT: Name:            MissedDetails
+; YAML-NEXT: Function:        test_unknown_dep
+; YAML-NEXT: Args:
+; YAML-NEXT:   - String:          loop not vectorized
+; YAML-NEXT: ...
+
+
+!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}
+!44 = distinct !DISubprogram(name: "test_nodep", scope: !1, file: !1, line: 14, type: !45, scopeLine: 14, unit: !0, retainedNodes: !2)
+!45 = !DISubroutineType(types: !46)
+!46 = !{null, !18, !16, !16}
+!16 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !17, size: 64)
+!17 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!18 = !DIBasicType(name: "int", size: 64, encoding: DW_ATE_signed)
+!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: !2)
+!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: !95, scopeLine: 36, unit: !0, retainedNodes: !2)
+!95 = !DISubroutineType(types: !96)
+!96 = !{null, !18, !16}
+!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: !95, scopeLine: 45, unit: !0, retainedNodes: !2)
+!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_forwardButPreventsForwarding_dep", scope: !1, file: !1, line: 58, type: !45, scopeLine: 58, unit: !0, retainedNodes: !2)
+!172 = distinct !DILexicalBlock(scope: !166, file: !1, line: 59, column: 3)
+!176 = distinct !DILexicalBlock(scope: !172, file: !1, line: 59, column: 3)
+!179 = !DILocation(line: 60, column: 5, scope: !180)
+!180 = distinct !DILexicalBlock(scope: !176, file: !1, line: 59, column: 28)
+!183 = !DILocation(line: 61, column: 12, scope: !180)
+!189 = distinct !DISubprogram(name: "test_backwardVectorizableButPreventsForwarding", scope: !1, file: !1, line: 72, type: !95, scopeLine: 72, unit: !0, retainedNodes: !2)
+!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: !95, scopeLine: 80, unit: !0, retainedNodes: !2)
+!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/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 ]