flang/test/Analysis/AliasAnalysis/alias-analysis-cray-pointers.fir

// Check that cray pointers might alias with everything.

// RUN: fir-opt %s -unsafe-cray-pointers -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -mlir-disable-threading 2>&1 | FileCheck %s
// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -mlir-disable-threading 2>&1 | FileCheck --check-prefix=DEFAULT %s

// Fortran source:
// subroutine test()
//   real :: a, b, c
//   pointer(p, a)
//   p = loc(b)
//   p = loc(c)
//   a = 1.0
// end subroutine

// CHECK-LABEL: Testing : "_QPtest"
// Legend:
// * 'a' is the descriptor address.
// * 'a.data" is the address of the 'a's data.
// * 'b' is the address of the 'b's data.
// * 'c' is the address of the 'c's data.
// * 'p' is the address of memory holding the raw address
//   of the 'b's data (or any other pointee's data)
// * 'raw_ptr_b' is the address of the 'b's data.
// * 'raw_ptr_c' is the address of the 'c's data.

// TODO: we should report NoAlias here, because
// 'p' is the address of location of the cray pointer value.
// It cannot alias with anything but itself.
// CHECK-DAG: p#0 <-> b#0: MayAlias
// CHECK-DAG: p#1 <-> b#0: MayAlias
// CHECK-DAG: p#0 <-> b#1: MayAlias
// CHECK-DAG: p#1 <-> b#1: MayAlias
// CHECK-DAG: p#0 <-> c#0: MayAlias
// CHECK-DAG: p#1 <-> c#0: MayAlias
// CHECK-DAG: p#0 <-> c#1: MayAlias
// CHECK-DAG: p#1 <-> c#1: MayAlias
// CHECK-DAG: p#0 <-> raw_ptr_b#0: MayAlias
// CHECK-DAG: p#1 <-> raw_ptr_b#0: MayAlias
// CHECK-DAG: p#0 <-> raw_ptr_c#0: MayAlias
// CHECK-DAG: p#1 <-> raw_ptr_c#0: MayAlias
// CHECK-DAG: p#0 <-> a.data#0: MayAlias
// CHECK-DAG: p#1 <-> a.data#0: MayAlias

// The descriptor address does not alias 'p'.
// CHECK-DAG: p#0 <-> a#0: NoAlias
// CHECK-DAG: p#1 <-> a#0: NoAlias
// CHECK-DAG: p#0 <-> a#1: NoAlias
// CHECK-DAG: p#1 <-> a#1: NoAlias

// 'b's data address and 'c's data address cannot alias.
// CHECK-DAG: b#0 <-> c#0: NoAlias
// CHECK-DAG: b#1 <-> c#0: NoAlias
// CHECK-DAG: b#0 <-> c#1: NoAlias
// CHECK-DAG: b#1 <-> c#1: NoAlias

// 'b's and 'c's data addresses cannot alias with
// the address of 'a' descriptor.
// CHECK-DAG: b#0 <-> a#0: NoAlias
// CHECK-DAG: b#1 <-> a#0: NoAlias
// CHECK-DAG: c#0 <-> a#0: NoAlias
// CHECK-DAG: c#1 <-> a#0: NoAlias
// CHECK-DAG: b#0 <-> a#1: NoAlias
// CHECK-DAG: b#1 <-> a#1: NoAlias
// CHECK-DAG: c#0 <-> a#1: NoAlias
// CHECK-DAG: c#1 <-> a#1: NoAlias

// 'b' == 'raw_ptr_b' and 'c' == 'raw_ptr_c'
// CHECK-DAG: b#0 <-> raw_ptr_b#0: MustAlias
// CHECK-DAG: b#1 <-> raw_ptr_b#0: MustAlias
// CHECK-DAG: c#0 <-> raw_ptr_c#0: MustAlias
// CHECK-DAG: c#1 <-> raw_ptr_c#0: MustAlias

// CHECK-DAG: c#0 <-> raw_ptr_b#0: NoAlias
// CHECK-DAG: c#1 <-> raw_ptr_b#0: NoAlias
// CHECK-DAG: a#0 <-> raw_ptr_b#0: NoAlias
// CHECK-DAG: a#1 <-> raw_ptr_b#0: NoAlias
// CHECK-DAG: b#0 <-> raw_ptr_c#0: NoAlias
// CHECK-DAG: b#1 <-> raw_ptr_c#0: NoAlias
// CHECK-DAG: a#0 <-> raw_ptr_c#0: NoAlias
// CHECK-DAG: a#1 <-> raw_ptr_c#0: NoAlias
// CHECK-DAG: raw_ptr_b#0 <-> raw_ptr_c#0: NoAlias

// 'a.data' may point to either 'b' or 'c'.
// CHECK-DAG: b#0 <-> a.data#0: MayAlias
// CHECK-DAG: b#1 <-> a.data#0: MayAlias
// CHECK-DAG: c#0 <-> a.data#0: MayAlias
// CHECK-DAG: c#1 <-> a.data#0: MayAlias
// CHECK-DAG: raw_ptr_b#0 <-> a.data#0: MayAlias
// CHECK-DAG: raw_ptr_c#0 <-> a.data#0: MayAlias

// The descriptor address 'a' does not alias the 'a's data.
// CHECK-DAG: a#0 <-> a.data#0: NoAlias
// CHECK-DAG: a#1 <-> a.data#0: NoAlias

// By default, alias analysis assumes that cray pointers do not alias with
// non-target data. See flang/docs/Aliasing.md.
// DEFAULT-LABEL: Testing : "_QPtest"
// NoAlias is always correct, though we report MayAlias
// under -unsafe-cray-pointers.
// DEFAULT-DAG: p#0 <-> b#0: NoAlias
// DEFAULT-DAG: p#1 <-> b#0: NoAlias
// DEFAULT-DAG: p#0 <-> b#1: NoAlias
// DEFAULT-DAG: p#1 <-> b#1: NoAlias
// DEFAULT-DAG: p#0 <-> c#0: NoAlias
// DEFAULT-DAG: p#1 <-> c#0: NoAlias
// DEFAULT-DAG: p#0 <-> c#1: NoAlias
// DEFAULT-DAG: p#1 <-> c#1: NoAlias
// DEFAULT-DAG: p#0 <-> raw_ptr_b#0: NoAlias
// DEFAULT-DAG: p#1 <-> raw_ptr_b#0: NoAlias
// DEFAULT-DAG: p#0 <-> raw_ptr_c#0: NoAlias
// DEFAULT-DAG: p#1 <-> raw_ptr_c#0: NoAlias
// DEFAULT-DAG: p#0 <-> a.data#0: NoAlias
// DEFAULT-DAG: p#1 <-> a.data#0: NoAlias

// Same as with -unsafe-cray-pointers.
// DEFAULT-DAG: p#0 <-> a#0: NoAlias
// DEFAULT-DAG: p#1 <-> a#0: NoAlias
// DEFAULT-DAG: p#0 <-> a#1: NoAlias
// DEFAULT-DAG: p#1 <-> a#1: NoAlias

// Same as with -unsafe-cray-pointers.
// DEFAULT-DAG: b#0 <-> c#0: NoAlias
// DEFAULT-DAG: b#1 <-> c#0: NoAlias
// DEFAULT-DAG: b#0 <-> c#1: NoAlias
// DEFAULT-DAG: b#1 <-> c#1: NoAlias

// Same as with -unsafe-cray-pointers.
// DEFAULT-DAG: b#0 <-> a#0: NoAlias
// DEFAULT-DAG: b#1 <-> a#0: NoAlias
// DEFAULT-DAG: c#0 <-> a#0: NoAlias
// DEFAULT-DAG: c#1 <-> a#0: NoAlias
// DEFAULT-DAG: b#0 <-> a#1: NoAlias
// DEFAULT-DAG: b#1 <-> a#1: NoAlias
// DEFAULT-DAG: c#0 <-> a#1: NoAlias
// DEFAULT-DAG: c#1 <-> a#1: NoAlias

// Same as with -unsafe-cray-pointers.
// DEFAULT-DAG: b#0 <-> raw_ptr_b#0: MustAlias
// DEFAULT-DAG: b#1 <-> raw_ptr_b#0: MustAlias
// DEFAULT-DAG: c#0 <-> raw_ptr_c#0: MustAlias
// DEFAULT-DAG: c#1 <-> raw_ptr_c#0: MustAlias

// Same as with -unsafe-cray-pointers.
// DEFAULT-DAG: c#0 <-> raw_ptr_b#0: NoAlias
// DEFAULT-DAG: c#1 <-> raw_ptr_b#0: NoAlias
// DEFAULT-DAG: a#0 <-> raw_ptr_b#0: NoAlias
// DEFAULT-DAG: a#1 <-> raw_ptr_b#0: NoAlias
// DEFAULT-DAG: b#0 <-> raw_ptr_c#0: NoAlias
// DEFAULT-DAG: b#1 <-> raw_ptr_c#0: NoAlias
// DEFAULT-DAG: a#0 <-> raw_ptr_c#0: NoAlias
// DEFAULT-DAG: a#1 <-> raw_ptr_c#0: NoAlias
// DEFAULT-DAG: raw_ptr_b#0 <-> raw_ptr_c#0: NoAlias

// This is the functional difference with -unsafe-cray-pointers.
// The safe assumption is MayAlias.
// DEFAULT-DAG: b#0 <-> a.data#0: NoAlias
// DEFAULT-DAG: b#1 <-> a.data#0: NoAlias
// DEFAULT-DAG: c#0 <-> a.data#0: NoAlias
// DEFAULT-DAG: c#1 <-> a.data#0: NoAlias
// DEFAULT-DAG: raw_ptr_b#0 <-> a.data#0: NoAlias
// DEFAULT-DAG: raw_ptr_c#0 <-> a.data#0: NoAlias

// Same as with -unsafe-cray-pointers.
// DEFAULT-DAG: a#0 <-> a.data#0: NoAlias
// DEFAULT-DAG: a#1 <-> a.data#0: NoAlias

func.func @_QPtest() {
  %0 = fir.alloca !fir.box<!fir.ptr<f32>>
  %1 = fir.dummy_scope : !fir.dscope
  %2 = fir.alloca i64 {bindc_name = "p", uniq_name = "_QFtestEp"}
  %3:2 = hlfir.declare %2 {test.ptr = "p", fortran_attrs = #fir.var_attrs<cray_pointer>, uniq_name = "_QFtestEp"} : (!fir.ref<i64>) -> (!fir.ref<i64>, !fir.ref<i64>)
  %4 = fir.alloca f32 {bindc_name = "b", uniq_name = "_QFtestEb"}
  %5:2 = hlfir.declare %4 {test.ptr = "b", uniq_name = "_QFtestEb"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
  %6 = fir.alloca f32 {bindc_name = "c", uniq_name = "_QFtestEc"}
  %7:2 = hlfir.declare %6 {test.ptr = "c", uniq_name = "_QFtestEc"} : (!fir.ref<f32>) -> (!fir.ref<f32>, !fir.ref<f32>)
  %8:2 = hlfir.declare %0 {test.ptr = "a", fortran_attrs = #fir.var_attrs<pointer, cray_pointee>, uniq_name = "_QFtestEa"} : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> (!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.ptr<f32>>>)
  %9 = fir.zero_bits !fir.ptr<f32>
  %10 = fir.embox %9 : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
  fir.store %10 to %8#0 : !fir.ref<!fir.box<!fir.ptr<f32>>>
  %11 = fir.embox %5#0 : (!fir.ref<f32>) -> !fir.box<f32>
  %12 = fir.box_addr %11 {test.ptr = "raw_ptr_b"} : (!fir.box<f32>) -> !fir.ref<f32>
  %13 = fir.convert %12 : (!fir.ref<f32>) -> i64
  hlfir.assign %13 to %3#0 : i64, !fir.ref<i64>
  %14 = fir.embox %7#0 : (!fir.ref<f32>) -> !fir.box<f32>
  %15 = fir.box_addr %14 {test.ptr = "raw_ptr_c"} : (!fir.box<f32>) -> !fir.ref<f32>
  %16 = fir.convert %15 : (!fir.ref<f32>) -> i64
  hlfir.assign %16 to %3#0 : i64, !fir.ref<i64>
  %cst = arith.constant 1.000000e+00 : f32
  // There should be _FortranAPointerAssociateScalar call here, but
  // we skip it for the test.
  %21 = fir.load %8#0 : !fir.ref<!fir.box<!fir.ptr<f32>>>
  %22 = fir.box_addr %21 {test.ptr = "a.data"} : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
  hlfir.assign %cst to %22 : f32, !fir.ptr<f32>
  return
}