// RUN: mlir-opt -allow-unregistered-dialect %s -affine-super-vectorizer-test -forward-slicing=true 2>&1 | FileCheck %s --check-prefix=FWD
// RUN: mlir-opt -allow-unregistered-dialect %s -affine-super-vectorizer-test -backward-slicing=true 2>&1 | FileCheck %s --check-prefix=BWD
// RUN: mlir-opt -allow-unregistered-dialect %s -affine-super-vectorizer-test -slicing=true 2>&1 | FileCheck %s --check-prefix=FWDBWD

///   1       2      3      4
///   |_______|      |______|
///   |   |             |
///   |   5             6
///   |___|_____________|
///     |               |
///     7               8
///     |_______________|
///             |
///             9
// FWD-LABEL: slicing_test
// BWD-LABEL: slicing_test
// FWDBWD-LABEL: slicing_test
func @slicing_test() {
  // Fake 0 to align on 1 and match ASCII art.
  %0 = alloc() : memref<1xi32>

  // FWD: matched: %[[v1:.*]] {{.*}} forward static slice:
  // FWD-NEXT: %[[v5:.*]] {{.*}} -> i5
  // FWD-DAG: %[[v8:.*]] {{.*}} -> i8
  // FWD-DAG: %[[v7:.*]] {{.*}} -> i7
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v1:.*]] {{.*}} backward static slice:
  //
  // FWDBWD: matched: %[[v1:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-DAG: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-DAG: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %1 = "slicing-test-op" () : () -> i1

  // FWD-NEXT: matched: %[[v2:.*]] {{.*}} forward static slice:
  // FWD-NEXT: %[[v5:.*]] {{.*}} -> i5
  // FWD-DAG: %[[v8:.*]] {{.*}} -> i8
  // FWD-DAG: %[[v7:.*]] {{.*}} -> i7
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v2:.*]] {{.*}} backward static slice:
  //
  // FWDBWD-NEXT: matched: %[[v2:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-DAG: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-DAG: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %2 = "slicing-test-op" () : () -> i2

  // FWD-NEXT: matched: %[[v3:.*]] {{.*}} forward static slice:
  // FWD-NEXT: %[[v6:.*]] {{.*}} -> i6
  // FWD-NEXT: %[[v8:.*]] {{.*}} -> i8
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v3:.*]] {{.*}} backward static slice:
  //
  // FWDBWD-NEXT: matched: %[[v3:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-NEXT: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-NEXT: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %3 = "slicing-test-op" () : () -> i3

  // FWD-NEXT: matched: %[[v4:.*]] {{.*}} forward static slice:
  // FWD-NEXT: %[[v6:.*]] {{.*}} -> i6
  // FWD-NEXT: %[[v8:.*]] {{.*}} -> i8
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v4:.*]] {{.*}} backward static slice:
  //
  // FWDBWD-NEXT: matched: %[[v4:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-NEXT: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-NEXT: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %4 = "slicing-test-op" () : () -> i4

  // FWD-NEXT: matched: %[[v5:.*]] {{.*}} forward static slice:
  // FWD-DAG: %[[v7:.*]] {{.*}} -> i7
  // FWD-DAG: %[[v8:.*]] {{.*}} -> i8
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v5:.*]] {{.*}} backward static slice:
  // BWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // BWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  //
  // FWDBWD-NEXT: matched: %[[v5:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-DAG: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-DAG: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %5 = "slicing-test-op" (%1, %2) : (i1, i2) -> i5

  // FWD-NEXT: matched: %[[v6:.*]] {{.*}} forward static slice:
  // FWD-NEXT: %[[v8:.*]] {{.*}} -> i8
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v6:.*]] {{.*}} backward static slice:
  // BWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // BWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  //
  // FWDBWD-NEXT: matched: %[[v6:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-NEXT: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-NEXT: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %6 = "slicing-test-op" (%3, %4) : (i3, i4) -> i6

  // FWD-NEXT: matched: %[[v7:.*]] {{.*}} forward static slice:
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v7:.*]] {{.*}} backward static slice:
  // BWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // BWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // BWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  //
  // FWDBWD-NEXT: matched: %[[v7:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-DAG: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-DAG: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %7 = "slicing-test-op" (%1, %5) : (i1, i5) -> i7

  // FWD-NEXT: matched: %[[v8:.*]] {{.*}} forward static slice:
  // FWD-NEXT: %[[v9:.*]] {{.*}} -> i9
  //
  // BWD: matched: %[[v8:.*]] {{.*}} backward static slice:
  // BWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // BWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // BWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // BWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // BWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // BWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  //
  // FWDBWD-NEXT: matched: %[[v8:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-DAG: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-DAG: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %8 = "slicing-test-op" (%5, %6) : (i5, i6) -> i8

  // FWD-NEXT: matched: %[[v9:.*]] {{.*}} forward static slice:
  //
  // BWD: matched: %[[v9:.*]] {{.*}} backward static slice:
  // BWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // BWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // BWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // BWD-NEXT: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // BWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // BWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // BWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // BWD-NEXT: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  //
  // FWDBWD-NEXT: matched: %[[v9:.*]] {{.*}} static slice:
  // FWDBWD-DAG: %[[v4:.*]] = "slicing-test-op"() : () -> i4
  // FWDBWD-DAG: %[[v3:.*]] = "slicing-test-op"() : () -> i3
  // FWDBWD-NEXT: %[[v6:.*]] = "slicing-test-op"(%[[v3]], %[[v4]]) : (i3, i4) -> i6
  // FWDBWD-DAG: %[[v2:.*]] = "slicing-test-op"() : () -> i2
  // FWDBWD-DAG: %[[v1:.*]] = "slicing-test-op"() : () -> i1
  // FWDBWD-NEXT: %[[v5:.*]] = "slicing-test-op"(%[[v1]], %[[v2]]) : (i1, i2) -> i5
  // FWDBWD-DAG: %[[v8:.*]] = "slicing-test-op"(%[[v5]], %[[v6]]) : (i5, i6) -> i8
  // FWDBWD-DAG: %[[v7:.*]] = "slicing-test-op"(%[[v1]], %[[v5]]) : (i1, i5) -> i7
  // FWDBWD-NEXT: %[[v9:.*]] = "slicing-test-op"(%[[v7]], %[[v8]]) : (i7, i8) -> i9

  %9 = "slicing-test-op" (%7, %8) : (i7, i8) -> i9

  return
}

// FWD-LABEL: slicing_test_2
// BWD-LABEL: slicing_test_2
// FWDBWD-LABEL: slicing_test_2
func @slicing_test_2() {
  %c0 = constant 0 : index
  %c2 = constant 2 : index
  %c16 = constant 16 : index
  affine.for %i0 = %c0 to %c16 {
    affine.for %i1 = affine_map<(i)[] -> (i)>(%i0) to 10 {
      // BWD: matched: %[[b:.*]] {{.*}} backward static slice:
      // BWD: affine.for {{.*}}

      // affine.for appears in the body of scf.for
      // BWD: affine.for {{.*}}

      // affine.for appears as a proper op in the backward slice
      // BWD: affine.for {{.*}}
      %b = "slicing-test-op"(%i1): (index) -> index

      // BWD: matched: %[[c:.*]] {{.*}} backward static slice:
      // BWD: affine.for {{.*}}

      // affine.for appears in the body of scf.for
      // BWD-NEXT: affine.for {{.*}}

      // affine.for only appears in the body of scf.for
      // BWD-NOT: affine.for {{.*}}
      %c = "slicing-test-op"(%i0): (index) -> index
    }
  }
  return
}

// FWD-LABEL: slicing_test_3
// BWD-LABEL: slicing_test_3
// FWDBWD-LABEL: slicing_test_3
func @slicing_test_3() {
  %f = constant 1.0 : f32
  %c = "slicing-test-op"(%f): (f32) -> index
  // FWD: matched: {{.*}} (f32) -> index forward static slice:
  // FWD: scf.for {{.*}}
  // FWD: matched: {{.*}} (index, index) -> index forward static slice:
  scf.for %i2 = %c to %c step %c {
    %d = "slicing-test-op"(%c, %i2): (index, index) -> index
  }
  return
}

// FWD-LABEL: slicing_test_function_argument
// BWD-LABEL: slicing_test_function_argument
// FWDBWD-LABEL: slicing_test_function_argument
func @slicing_test_function_argument(%arg0: index) -> index {
  // BWD: matched: {{.*}} (index, index) -> index backward static slice:
  %0 = "slicing-test-op"(%arg0, %arg0): (index, index) -> index
  return %0 : index
}

// FWD-LABEL: slicing_test_multiple_return
// BWD-LABEL: slicing_test_multiple_return
// FWDBWD-LABEL: slicing_test_multiple_return
func @slicing_test_multiple_return(%arg0: index) -> (index, index) {
  // BWD: matched: {{.*}} (index, index) -> (index, index) backward static slice:
  // FWD: matched: %{{.*}}:2 = "slicing-test-op"(%arg0, %arg0) : (index, index) -> (index, index) forward static slice:
  // FWD: return %{{.*}}#0, %{{.*}}#1 : index, index
  %0:2 = "slicing-test-op"(%arg0, %arg0): (index, index) -> (index, index)
  return %0#0, %0#1 : index, index
}

// This test dumps 2 sets of outputs: first the test outputs themselves followed
// by the module. These labels isolate the test outputs from the module dump.
// FWD-LABEL: slicing_test
// BWD-LABEL: slicing_test
// FWDBWD-LABEL: slicing_test
// FWD-LABEL: slicing_test_2
// BWD-LABEL: slicing_test_2
// FWDBWD-LABEL: slicing_test_2
// FWD-LABEL: slicing_test_3
// BWD-LABEL: slicing_test_3
// FWDBWD-LABEL: slicing_test_3
// FWD-LABEL: slicing_test_function_argument
// BWD-LABEL: slicing_test_function_argument
// FWDBWD-LABEL: slicing_test_function_argument