[llvm] [LoopInterchange] Redundant isLexicographicallyPositive check (PR #117343)

[Ryotaro Kasuga via llvm-commits]

================
@@ -204,11 +204,12 @@ static bool isLegalToInterChangeLoops(CharMatrix &DepMatrix,
   std::vector<char> Cur;
   // For each row check if it is valid to interchange.
   for (unsigned Row = 0; Row < NumRows; ++Row) {
-    // Create temporary DepVector check its lexicographical order
-    // before and after swapping OuterLoop vs InnerLoop
+    // A dependence vector has to be lexigraphically positive. We could assert
+    // that here, as a sanity check for the dependency analysis, but it can
+    // contain "don't know" elements ('*'), which will be rightfully
+    // interpreted as not lexicographical positive. So, skip that sanity check,
+    // it suffices just to check the interchanged direction vector.
----------------
kasuga-fj wrote:

Hi, I found this PR by chance. I think `isLexicographicallyPositive` check is necessary before the interchange.

> if there's a "don't know" element, then the permuted direction vector will be rejected too.

I think the following case is a counterexample to this.

```c
#define N 4
int a[N][N];
void f() {
  for (int i = 0; i < N; i++) {
    for (int j = 1; j < N; j++) {
      a[j][N-1-i] += a[j+1][i];
    }
  }
}
```

See also: https://godbolt.org/z/jzEr93hf8

There is a direction vector `[* <]`, which is interpreted as not lexicographically positive before the interchange, but positive after it.

If you want to reduce compilation time, I think one way would be to stop all the subsequent processes and exit when we find a direction vector with `*` on its first element. However, with improving the legality check, I believe some of these cases should be interchangeable in the future.

https://github.com/llvm/llvm-project/pull/117343