[flang] Added coarse grained alias analysis for FIR.

[vzakhari]

Summary

These are experimental changes in Flang AA to provide
at least some means to disambiguate memory accesses in some
simple cases. This AA is still not used by any transformation,
so the LIT tests are the only way to trigger it currently.
I will further look into applying this AA within Flang
to address some of the known performance issues in the benchmarks.

Credits to @Renaud-K for the initial implementation.

[PeteSteinfeld]

Aside from a couple of nits, all builds and tests correctly and looks good.

flang/include/flang/Optimizer/Analysis/AliasAnalysis.h

40

Should read "unknown" rather than "uknown".

65–68

This name would read a little more naturally if it were isRecordWithPointerComponent. But this function isn't mentioned anywhere else. Can you just get rid of it?

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

128–137

This code looks identical to the code in lines 95 -104. Should they be extracted to a separate function?

[vzakhari]

flang/include/flang/Optimizer/Analysis/AliasAnalysis.h

40

Thanks!

65–68

Good name suggestion! Thanks!

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

128–137

I would like to keep it as-is for the time being. This code is WIP, so I will likely restructure it in future. So far, the code duplication is not too awful :)

[vzakhari]

• Fixed typo and the method name.

[tschuett]

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

27

static. No anonymous namespace for functions.

106

The common style for asserts in LLVM is assert(important && "something bad happened ");

[tschuett]

flang/include/flang/Optimizer/Analysis/AliasAnalysis.h

46

My last question: struct or class?

[vzakhari]

flang/include/flang/Optimizer/Analysis/AliasAnalysis.h

46

struct should be good enough.

[jeanPerier]

Looks great !

flang/include/flang/Optimizer/Analysis/AliasAnalysis.h

-//===- AliasAnalysis.h - Alias Analysis in FIR -----------------*- C++ -*-===//
+//===-- AliasAnalysis.h - Alias Analysis in FIR -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef FIR_ANALYSIS_ALIASANALYSIS_H_
-#define FIR_ANALYSIS_ALIASANALYSIS_H_
+#ifndef FORTRAN_OPTIMIZER_ANALYSIS_ALIASANALYSIS_H
+#define FORTRAN_OPTIMIZER_ANALYSIS_ALIASANALYSIS_H
 
+#include "flang/Common/enum-class.h"
+#include "flang/Common/enum-set.h"
 #include "mlir/Analysis/AliasAnalysis.h"
+#include "mlir/IR/Value.h"
+#include "llvm/ADT/PointerUnion.h"
 
 namespace fir {
 
 //===----------------------------------------------------------------------===//
 // AliasAnalysis
 //===----------------------------------------------------------------------===//
 class AliasAnalysis {
+  // Structures to describe the memory source of a value.
+
+  /// Kind of the memory source referenced by a value.
+  ENUM_CLASS(SourceKind,
+             /// Unique memory allocated by an operation, e.g.
+             /// by fir::AllocaOp or fir::AllocMemOp.
+             Allocate,
+             /// A global object allocated statically on the module level.
+             Global,
+             /// Memory allocated outside of a function and passed
+             /// to the function as a by-ref argument.
+             Argument,
+             /// Represents memory allocated by unknown means and
+             /// with the memory address defined by a memory reading
+             /// operation (e.g. fir::LoadOp).
+             Indirect,
+             /// Represents memory allocated by unknown means.
+             Unknown);
+
+  /// Attributes of the memory source object.
+  ENUM_CLASS(Attribute, Target, Pointer, IntentIn);
+
+  struct Source {
+    using SourceUnion = llvm::PointerUnion<mlir::SymbolRefAttr, mlir::Value>;
+    using Attributes = Fortran::common::EnumSet<Attribute, Attribute_enumSize>;
+
+    /// Source definition of a value.
+    SourceUnion u;
+    /// Kind of the memory source.
+    SourceKind kind;
+    /// Value type of the source definition.
+    mlir::Type valueType;
+    /// Attributes of the memory source object, e.g. Target.
+    Attributes attributes;
+
+    /// Print information about the memory source to `os`.
+    void print(llvm::raw_ostream &os) const;
+
+    /// Return true, if Target or Pointer attribute is set.
+    bool isTargetOrPointer() const;
+
+    /// Return true, if the memory source's `valueType` is a reference type
+    /// to an object of derived type that contains a component with POINTER
+    /// attribute.
+    bool isRecordWithPointerComponent() const;
+
+    /// Return true, if `ty` is a reference type to a boxed
+    /// POINTER object or a raw fir::PointerType.
+    static bool isPointerReference(mlir::Type ty);
+  };
+
+  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                       const AliasAnalysis::Source &op);
+
 public:
   /// Given two values, return their aliasing behavior.
   mlir::AliasResult alias(mlir::Value lhs, mlir::Value rhs);
 
   /// Return the modify-reference behavior of `op` on `location`.
   mlir::ModRefResult getModRef(mlir::Operation *op, mlir::Value location);
+
+  /// Return the memory source of a value.
+  Source getSource(mlir::Value);
 };
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const AliasAnalysis::Source &op) {
+  op.print(os);
+  return os;
+}
+
 } // namespace fir
 
-#endif // FIR_ANALYSIS_ALIASANALYSIS_H_
+#endif // FORTRAN_OPTIMIZER_ANALYSIS_ALIASANALYSIS_H

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

 //===- AliasAnalysis.cpp - Alias Analysis for FIR  ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Analysis/AliasAnalysis.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "mlir/Analysis/AliasAnalysis.h"
+#include "mlir/IR/BuiltinOps.h"
+#include "mlir/IR/Value.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
+#include "llvm/ADT/TypeSwitch.h"
+#include "llvm/Support/Casting.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // AliasAnalysis: alias
 //===----------------------------------------------------------------------===//
 
+static bool isDummyArgument(mlir::Value v) {
+  auto blockArg{v.dyn_cast<mlir::BlockArgument>()};
+  if (!blockArg)
+    return false;
+
+  return blockArg.getOwner()->isEntryBlock();
+}
+
 namespace fir {
+
+void AliasAnalysis::Source::print(llvm::raw_ostream &os) const {
+  if (auto v = llvm::dyn_cast<mlir::Value>(u))
+    os << v;
+  else if (auto gbl = llvm::dyn_cast<mlir::SymbolRefAttr>(u))
+    os << gbl;
+  os << " SourceKind: " << EnumToString(kind);
+  os << " Type: " << valueType << " ";
+  attributes.Dump(os, EnumToString);
+}
+
+bool AliasAnalysis::Source::isPointerReference(mlir::Type ty) {
+  auto eleTy = fir::dyn_cast_ptrEleTy(ty);
+  if (!eleTy)
+    return false;
+
+  return fir::isPointerType(eleTy) || eleTy.isa<fir::PointerType>();
+}
+
+bool AliasAnalysis::Source::isTargetOrPointer() const {
+  return attributes.test(Attribute::Pointer) ||
+         attributes.test(Attribute::Target);
+}
+
+bool AliasAnalysis::Source::isRecordWithPointerComponent() const {
+  auto eleTy = fir::dyn_cast_ptrEleTy(valueType);
+  if (!eleTy)
+    return false;
+  // TO DO: Look for pointer components
+  return eleTy.isa<fir::RecordType>();
+}
+
 AliasResult AliasAnalysis::alias(Value lhs, Value rhs) {
-  // This is for now a mock analysis
-  if (lhs == rhs) {
+  auto lhsSrc = getSource(lhs);
+  auto rhsSrc = getSource(rhs);
+
+  // Indirect case currently not handled. Conservatively assume
+  // it aliases with everything
+  if (lhsSrc.kind == SourceKind::Indirect ||
+      lhsSrc.kind == SourceKind::Unknown ||
+      rhsSrc.kind == SourceKind::Indirect || rhsSrc.kind == SourceKind::Unknown)
+    return AliasResult::MayAlias;
+
+  if (lhsSrc.kind == rhsSrc.kind) {
+    if (lhsSrc.u == rhsSrc.u)
       return AliasResult::MustAlias;
+
+    // Allocate and global memory address cannot physically alias
+    if (lhsSrc.kind == SourceKind::Allocate ||
+        lhsSrc.kind == SourceKind::Global)
+      return AliasResult::NoAlias;
+
+    assert(lhsSrc.kind == SourceKind::Argument &&
+           "unexpected memory source kind");
+
+    // Dummy TARGET/POINTER arguments may alias.
+    if (lhsSrc.isTargetOrPointer() && rhsSrc.isTargetOrPointer())
+      return AliasResult::MayAlias;
+
+    // Box for POINTER component inside an object of a derived type
+    // may alias box of a POINTER object, as well as boxes for POINTER
+    // components inside two objects of derived types may alias.
+    if ((lhsSrc.isRecordWithPointerComponent() && rhsSrc.isTargetOrPointer()) ||
+        (rhsSrc.isRecordWithPointerComponent() && lhsSrc.isTargetOrPointer()) ||
+        (lhsSrc.isRecordWithPointerComponent() &&
+         rhsSrc.isRecordWithPointerComponent()))
+      return AliasResult::MayAlias;
+
+    return AliasResult::NoAlias;
+  }
+
+  assert(lhsSrc.kind != rhsSrc.kind && "memory source kinds must be the same");
+
+  Source *src1, *src2;
+  if (lhsSrc.kind < rhsSrc.kind) {
+    src1 = &lhsSrc;
+    src2 = &rhsSrc;
+  } else {
+    src1 = &rhsSrc;
+    src2 = &lhsSrc;
   }
+
+  assert(src2->kind <= SourceKind::Argument && "unexpected memory source kind");
+  if (src1->kind == SourceKind::Allocate)
+    return AliasResult::NoAlias;
+
+  assert(src1->kind == SourceKind::Global &&
+         src2->kind == SourceKind::Argument &&
+         "unexpected memory source kinds");
+
+  // Dummy TARGET/POINTER argument may alias with a global TARGET/POINTER.
+  if (src1->isTargetOrPointer() && src2->isTargetOrPointer())
+    return AliasResult::MayAlias;
+
+  // Box for POINTER component inside an object of a derived type
+  // may alias box of a POINTER object, as well as boxes for POINTER
+  // components inside two objects of derived types may alias.
+  if ((src1->isRecordWithPointerComponent() && src2->isTargetOrPointer()) ||
+      (src2->isRecordWithPointerComponent() && src1->isTargetOrPointer()) ||
+      (src1->isRecordWithPointerComponent() &&
+       src2->isRecordWithPointerComponent()))
     return AliasResult::MayAlias;
+
+  return AliasResult::NoAlias;
 }
 
 //===----------------------------------------------------------------------===//
 // AliasAnalysis: getModRef
 //===----------------------------------------------------------------------===//
 
 /// This is mostly inspired by MLIR::LocalAliasAnalysis with 2 notable
 /// differences 1) Regions are not handled here but will be handled by a data
-/// flow analysis to come 2) Allocate and Free effects are considered modifying
+/// flow analysis to come 2) Allocate and Free effects are considered
+/// modifying
 ModRefResult AliasAnalysis::getModRef(Operation *op, Value location) {
   MemoryEffectOpInterface interface = dyn_cast<MemoryEffectOpInterface>(op);
   if (!interface)
     return ModRefResult::getModAndRef();
 
   // Build a ModRefResult by merging the behavior of the effects of this
   // operation.
   SmallVector<MemoryEffects::EffectInstance> effects;
   interface.getEffects(effects);
 
   ModRefResult result = ModRefResult::getNoModRef();
   for (const MemoryEffects::EffectInstance &effect : effects) {
 
     // Check for an alias between the effect and our memory location.
     AliasResult aliasResult = AliasResult::MayAlias;
     if (Value effectValue = effect.getValue())
       aliasResult = alias(effectValue, location);
 
     // If we don't alias, ignore this effect.
     if (aliasResult.isNo())
       continue;
 
     // Merge in the corresponding mod or ref for this effect.
-    if (isa<MemoryEffects::Read>(effect.getEffect())) {
+    if (isa<MemoryEffects::Read>(effect.getEffect()))
       result = result.merge(ModRefResult::getRef());
-    } else {
+    else
       result = result.merge(ModRefResult::getMod());
-    }
+
     if (result.isModAndRef())
       break;
   }
   return result;
 }
+
+AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v) {
+  auto *defOp = v.getDefiningOp();
+  SourceKind type{SourceKind::Unknown};
+  mlir::Type ty;
+  bool breakFromLoop{false};
+  mlir::SymbolRefAttr global;
+  Source::Attributes attributes;
+  while (defOp && !breakFromLoop) {
+    ty = defOp->getResultTypes()[0];
+    llvm::TypeSwitch<Operation *>(defOp)
+        .Case<fir::AllocaOp, fir::AllocMemOp>([&](auto op) {
+          // Unique memory allocation.
+          type = SourceKind::Allocate;
+          breakFromLoop = true;
+        })
+        .Case<fir::ConvertOp>([&](auto op) {
+          // Skip ConvertOp's and track further through the operand.
+          v = op->getOperand(0);
+          defOp = v.getDefiningOp();
+        })
+        .Case<fir::LoadOp>([&](auto op) {
+          // No further tracking for addresses loaded from memory (e.g. a box)
+          // right now.
+          type = SourceKind::Indirect;
+          breakFromLoop = true;
+        })
+        .Case<fir::AddrOfOp>([&](auto op) {
+          // Address of a global scope object.
+          type = SourceKind::Global;
+          ty = v.getType();
+          if (fir::valueHasFirAttribute(v,
+                                        fir::GlobalOp::getTargetAttrNameStr()))
+            attributes.set(Attribute::Target);
+
+          if (Source::isPointerReference(ty))
+            attributes.set(Attribute::Pointer);
+          global = llvm::cast<fir::AddrOfOp>(op).getSymbol();
+          breakFromLoop = true;
+        })
+        .Default([&](auto op) {
+          defOp = nullptr;
+          breakFromLoop = true;
+        });
+  }
+  if (!defOp && type == SourceKind::Unknown)
+    // Check if the memory source is coming through a dummy argument.
+    if (isDummyArgument(v)) {
+      type = SourceKind::Argument;
+      ty = v.getType();
+      if (fir::valueHasFirAttribute(v, fir::getTargetAttrName()))
+        attributes.set(Attribute::Target);
+
+      if (Source::isPointerReference(ty))
+        attributes.set(Attribute::Pointer);
+    }
+
+  if (type == SourceKind::Global)
+    return {global, type, ty, attributes};
+
+  return {v, type, ty, attributes};
+}
+
 } // namespace fir

flang/test/Analysis/AliasAnalysis/alias-analysis-1.fir

-// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file 2>&1 | FileCheck %s
+// Use --mlir-disable-threading so that the AA queries are serialized
+// as well as its diagnostic output.
+// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file --mlir-disable-threading 2>&1 | FileCheck %s
 
 // CHECK-LABEL: Testing : "_QPtest"
-// CHECK-DAG: alloca_1#0 <-> address_of#0: MayAlias
+// CHECK-DAG: alloca_1#0 <-> address_of#0: NoAlias
 func.func @_QPtest(%arg1: !fir.ref<i32>) {
   %c1_i32 = arith.constant 1 : i32
   %0 = fir.alloca () -> () {test.ptr = "alloca_1"}
   %1 = fir.address_of(@_QPf) {test.ptr = "address_of"} : () -> i32 
   %2 = fir.convert %1 : (() -> i32) -> (() -> ())
   %4 = fir.convert %0 : (!fir.ref<() -> ()>) -> !fir.llvm_ptr<() -> ()>
   fir.store %2 to %4 : !fir.llvm_ptr<() -> ()>
   %6 = fir.load %0 : !fir.ref<() -> ()>
   fir.call @_QPs(%6) : (() -> ()) -> ()
   return
 }
 
-// -----
 func.func private @_QPs(%arg0: () -> ()) 
-
-// -----
 func.func private @_QPf() -> i32

flang/test/Analysis/AliasAnalysis/alias-analysis-2.fir

+// Use --mlir-disable-threading so that the AA queries are serialized
+// as well as its diagnostic output.
+// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file --mlir-disable-threading 2>&1 | FileCheck %s
+
+// CHECK-LABEL: Testing : "_QFPtest"
+
+// p1.addr and p2.addr result from 2 different allocas
+// They cannot physically alias
+// CHECK-DAG: p1.addr#0 <-> p2.addr#0: NoAlias
+
+// p1.addr and p2.addr could both be wrapped inside boxes
+// CHECK-DAG: p1.addr#0 <-> boxp1.addr#0: MayAlias
+// CHECK-DAG: p2.addr#0 <-> boxp1.addr#0: MayAlias
+// CHECK-DAG: p1.addr#0 <-> arg2.addr#0: MayAlias
+// CHECK-DAG: p2.addr#0 <-> arg2.addr#0: MayAlias
+
+// p1.addr and p2.addr are the result of an allocation
+// They cannot physically alias with an argument
+// CHECK-DAG: p1.addr#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: p2.addr#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: p1.addr#0 <-> func.region0#1: NoAlias
+// CHECK-DAG: p2.addr#0 <-> func.region0#1: NoAlias
+// CHECK-DAG: p1.addr#0 <-> func.region0#2: NoAlias
+// CHECK-DAG: p2.addr#0 <-> func.region0#2: NoAlias
+
+// All arguments are either pointers or targets
+// A pointer in a box may alias with both
+// CHECK-DAG: boxp1.addr#0 <-> func.region0#0: MayAlias
+// CHECK-DAG: boxp1.addr#0 <-> func.region0#1: MayAlias
+// CHECK-DAG: boxp1.addr#0 <-> func.region0#2: MayAlias
+
+// A target dummy may alias with another target
+// CHECK-DAG: func.region0#0 <-> func.region0#1: MayAlias
+
+// arg2 is a reference to a pointer. Modifying arg2 could
+// modify a target with a pointer component
+// CHECK-DAG: func.region0#0 <-> func.region0#2: MayAlias
+// CHECK-DAG: func.region0#1 <-> func.region0#2: MayAlias
+
+// However, the address wrapped by arg2, can alias with any target or
+// pointer arguments
+// CHECK-DAG: arg2.addr#0 <-> func.region0#0: MayAlias
+// CHECK-DAG: arg2.addr#0 <-> func.region0#1: MayAlias
+// CHECK-DAG: arg2.addr#0 <-> func.region0#2: MayAlias
+// CHECK-DAG: boxp1.addr#0 <-> arg2.addr#0: MayAlias
+
+func.func @_QFPtest(%arg0: !fir.ref<f32> {fir.bindc_name = "v1", fir.target}, %arg1: !fir.ref<f32> {fir.bindc_name = "v2", fir.target}, %arg2: !fir.ref<!fir.box<!fir.ptr<f32>>> ) attributes {test.ptr = "func"} {
+
+  %1 = fir.alloca !fir.ptr<f32> {test.ptr = "p1.addr"}
+  %2 = fir.zero_bits !fir.ptr<f32>
+  fir.store %2 to %1 : !fir.ref<!fir.ptr<f32>>
+
+  %4 = fir.alloca !fir.ptr<f32> {test.ptr = "p2.addr"}
+  fir.store %2 to %4 : !fir.ref<!fir.ptr<f32>>
+
+  %5 = fir.convert %arg0 : (!fir.ref<f32>) -> !fir.ptr<f32>
+  fir.store %5 to %1 : !fir.ref<!fir.ptr<f32>>
+
+  %6 = fir.convert %arg1 : (!fir.ref<f32>) -> !fir.ptr<f32>
+  fir.store %6 to %4 : !fir.ref<!fir.ptr<f32>>
+
+  %0 = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "p1", uniq_name = "_QFtestEp1"}
+  %7 = fir.load %1 : !fir.ref<!fir.ptr<f32>>
+  %8 = fir.embox %7 : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
+  fir.store %8 to %0 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+
+  %3 = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "p2", uniq_name = "_QFtestEp2"}
+  %9 = fir.load %4 : !fir.ref<!fir.ptr<f32>>
+  %10 = fir.embox %9 : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
+  fir.store %10 to %3 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+
+  %11 = fir.load %0 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %12 = fir.box_addr %11 {test.ptr = "boxp1.addr"} : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
+  fir.store %12 to %1 : !fir.ref<!fir.ptr<f32>>
+
+  %13 = fir.load %3 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %14 = fir.box_addr %13 : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
+  fir.store %14 to %4 : !fir.ref<!fir.ptr<f32>>
+
+  %15 = fir.load %arg2 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %16 = fir.box_addr %15 {test.ptr = "arg2.addr"} : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "_QFPtest2"
+
+// subroutine test2(v1,p1,p2)
+//   real, target :: v1
+//   real, pointer :: p1, p2
+//   ...
+// end subroutine
+
+// Direct access to dummy POINTER references can modify other dummy POINTER references
+// CHECK-DAG: func.region0#1 <-> func.region0#2: MayAlias
+
+// They can also modify targets that have pointer components
+// CHECK-DAG: func.region0#0 <-> func.region0#1: MayAlias
+// CHECK-DAG: func.region0#0 <-> func.region0#2: MayAlias
+
+func.func @_QFPtest2(%arg0: !fir.ref<f32> {fir.bindc_name = "v1", fir.target}, %arg1: !fir.ref<!fir.box<!fir.ptr<f32>>>, %arg2: !fir.ref<!fir.ptr<f32>> ) attributes {test.ptr = "func"} {
+  return
+}
+
+// -----
+
+// CHECK-LABEL: Testing : "_QFPtest3"
+
+// module pointers
+//   real, pointer :: p
+// end module
+//
+// program main
+//   use pointers
+//   real, target :: var1 = 1, var2 =2
+//   p => var1
+//
+//   call test3(p)
+//
+// contains
+//   subroutine test3(p1)
+//     real, pointer :: p1
+//     p1 => var2
+//     print *, p
+//   end subroutine
+// end
+
+// The global pointer p may alias with the dummy argument p1
+// but not with the dummy arg1 which is just a regular dummy
+// CHECK-DAG: p#0 <-> func.region0#0: MayAlias
+// CHECK-DAG: p#0 <-> func.region0#1: NoAlias
+
+// FIXME: p and p1 are pointers, they cannot alias with a wrapped address.
+//        Only the addresses they wrap could alias with the address wrapped by the box
+// CHECK-DAG: p#0 <-> box.addr#0: MayAlias
+// CHECK-DAG: box.addr#0 <-> func.region0#0: MayAlias
+
+// var2, although it is a target, cannot alias with p
+// A modification of p would only make them point to a new target but not modify it
+// CHECK-DAG: var2#0 <-> p#0: NoAlias
+// It can alias with p1, if p1 is a pointer component
+// CHECK-DAG: var2#0 <-> func.region0#0: MayAlias
+// It can alias with a box.addr
+// CHECK-DAG: var2#0 <-> box.addr#0: MayAlias
+
+// A global may not alias with a dummy
+// CHECK-DAG: var2#0 <-> func.region0#1: NoAlias
+
+// FIXME: a pointer may only alias with a target but arg1 is a regular dummy
+// CHECK-DAG: box.addr#0 <-> func.region0#1: MayAlias
+
+// Dummy argument do not alias
+// CHECK-DAG: func.region0#0 <-> func.region0#1: NoAlias
+
+fir.global @_QMpointersEp : !fir.box<!fir.ptr<f32>> {
+  %0 = fir.zero_bits !fir.ptr<f32>
+  %1 = fir.embox %0 : (!fir.ptr<f32>) -> !fir.box<!fir.ptr<f32>>
+  fir.has_value %1 : !fir.box<!fir.ptr<f32>>
+}
+
+fir.global internal @_QFEvar2 target : f32 {
+  %cst = arith.constant 2.000000e+00 : f32
+  fir.has_value %cst : f32
+}
+
+func.func @_QFPtest3(%arg0: !fir.ref<!fir.box<!fir.ptr<f32>>> {fir.bindc_name = "p1"}, %arg1: !fir.ref<f32>) attributes {test.ptr = "func"} {
+  %4 = fir.address_of(@_QFEvar2) {test.ptr = "var2"} : !fir.ref<f32>
+  %5 = fir.address_of(@_QMpointersEp) {test.ptr = "p"} : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %6 = fir.embox %4 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
+  %13 = fir.box_addr %6 {test.ptr = "box.addr"} : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
+  return
+}

flang/test/Analysis/AliasAnalysis/alias-analysis-3.fir

+// Use --mlir-disable-threading so that the AA queries are serialized
+// as well as its diagnostic output.
+// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' -split-input-file --mlir-disable-threading 2>&1 | FileCheck %s
+
+// module m
+//   type t
+//      real, pointer :: pointer_component
+//   end type t
+//   type(t) :: a
+// contains
+//   subroutine test(pointer_dummy, x)
+//     real, pointer :: pointer_dummy
+//     real, target :: x
+//     pointer_dummy => x
+//     call test2(a%pointer_component)
+//   end subroutine test
+// end module m
+
+// A composite with a pointer component may alias with a dummy pointer
+// CHECK-LABEL: Testing : "_QMmPtest
+// CHECK: a#0 <-> func.region0#0: MayAlias
+
+// FIXME: a's box cannot alias with raw reference to f32 (x), so MayAlias below must be NoAlias:
+// CHECK: a#0 <-> func.region0#1: MayAlias
+
+// FIXME: pointer_dummy's box cannot alias with raw reference to f32 (x), so MayAlias below must be NoAlias:
+// CHECK: func.region0#0 <-> func.region0#1: MayAlias
+
+fir.global @_QMmEa : !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}> {
+  %0 = fir.undefined !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+  fir.has_value %0 : !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+}
+func.func @_QMmPtest(%arg0: !fir.ref<!fir.box<!fir.ptr<f32>>> {fir.bindc_name = "pointer_dummy"}, %arg1: !fir.ref<f32> {fir.bindc_name = "x", fir.target}) attributes {test.ptr = "func"} {
+  %0 = fir.address_of(@_QMmEa) {test.ptr = "a"} : !fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>>
+  %1 = fir.embox %arg1 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
+  fir.store %1 to %arg0 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %2 = fir.field_index pointer_component, !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+  %3 = fir.coordinate_of %0, %2 : (!fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %4 = fir.load %3 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %5 = fir.box_addr %4 : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
+  %6 = fir.convert %5 : (!fir.ptr<f32>) -> !fir.ref<f32>
+  fir.call @_QPtest2(%6) fastmath<contract> : (!fir.ref<f32>) -> ()
+  return
+}
+func.func private @_QPtest2(!fir.ref<f32>)
+
+// -----
+
+// A composite with a pointer component may alias with a dummy
+// argument of composite type with a pointer component:
+// module m
+//   type t
+//      real, pointer :: pointer_component
+//   end type t
+//   type(t) :: a
+// contains
+//   subroutine test(b, x)
+//     type(t) :: b
+//     real, target :: x
+//     a%pointer_component => x
+//     call test2(b%pointer_component)
+//   end subroutine test
+// end module m
+
+// CHECK-LABEL: Testing : "_QMmPtest"
+// CHECK: a#0 <-> func.region0#0: MayAlias
+
+fir.global @_QMmEa : !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}> {
+  %0 = fir.undefined !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+  fir.has_value %0 : !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+}
+func.func @_QMmPtest(%arg0: !fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>> {fir.bindc_name = "b"}, %arg1: !fir.ref<f32> {fir.bindc_name = "x", fir.target}) attributes {test.ptr = "func"} {
+  %0 = fir.address_of(@_QMmEa) {test.ptr = "a"} : !fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>>
+  %1 = fir.field_index pointer_component, !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+  %2 = fir.coordinate_of %0, %1 : (!fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %3 = fir.embox %arg1 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
+  fir.store %3 to %2 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %4 = fir.field_index pointer_component, !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+  %5 = fir.coordinate_of %arg0, %4 : (!fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %6 = fir.load %5 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %7 = fir.box_addr %6 : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
+  %8 = fir.convert %7 : (!fir.ptr<f32>) -> !fir.ref<f32>
+  fir.call @_QPtest2(%8) fastmath<contract> : (!fir.ref<f32>) -> ()
+  return
+}
+func.func private @_QPtest2(!fir.ref<f32>)
+
+// -----
+
+// Two dummy arguments of composite type with a pointer component
+// may alias each other:
+// module m
+//   type t
+//      real, pointer :: pointer_component
+//   end type t
+// contains
+//   subroutine test(a, b, x)
+//     type(t) :: a, b
+//     real, target :: x
+//     a%pointer_component => x
+//     call test2(b%pointer_component)
+//   end subroutine test
+// end module m
+
+// CHECK-LABEL: Testing : "_QMmPtest"
+// CHECK: func.region0#0 <-> func.region0#1: MayAlias
+
+func.func @_QMmPtest(%arg0: !fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>> {fir.bindc_name = "b"}, %arg2: !fir.ref<f32> {fir.bindc_name = "x", fir.target}) attributes {test.ptr = "func"} {
+  %0 = fir.field_index pointer_component, !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+  %1 = fir.coordinate_of %arg0, %0 : (!fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %2 = fir.embox %arg2 : (!fir.ref<f32>) -> !fir.box<!fir.ptr<f32>>
+  fir.store %2 to %1 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %3 = fir.field_index pointer_component, !fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>
+  %4 = fir.coordinate_of %arg1, %3 : (!fir.ref<!fir.type<_QMmTt{pointer_component:!fir.box<!fir.ptr<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %5 = fir.load %4 : !fir.ref<!fir.box<!fir.ptr<f32>>>
+  %6 = fir.box_addr %5 : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
+  %7 = fir.convert %6 : (!fir.ptr<f32>) -> !fir.ref<f32>
+  fir.call @_QPtest2(%7) fastmath<contract> : (!fir.ref<f32>) -> ()
+  return
+}
+func.func private @_QPtest2(!fir.ref<f32>)
+
+// -----
+
+// Two dummy arguments of composite type consisting of an allocatable
+// component cannot alias:
+// module m
+//   type t
+//      real, allocatable :: allocatable_component
+//   end type t
+// contains
+//   subroutine test(a, b)
+//     type(t) :: a, b
+//     allocate(a%allocatable_component)
+//     call test2(b%allocatable_component)
+//   end subroutine test
+// end module m
+
+// CHECK-LABEL: Testing : "_QMmPtest"
+// FIXME: MayAlias must be NoAlias
+// CHECK: func.region0#0 <-> func.region0#1: MayAlias
+
+func.func @_QMmPtest(%arg0: !fir.ref<!fir.type<_QMmTt{allocatable_component:!fir.box<!fir.heap<f32>>}>> {fir.bindc_name = "a"}, %arg1: !fir.ref<!fir.type<_QMmTt{allocatable_component:!fir.box<!fir.heap<f32>>}>> {fir.bindc_name = "b"}) attributes {test.ptr = "func"} {
+  %0 = fir.field_index allocatable_component, !fir.type<_QMmTt{allocatable_component:!fir.box<!fir.heap<f32>>}>
+  %1 = fir.coordinate_of %arg0, %0 : (!fir.ref<!fir.type<_QMmTt{allocatable_component:!fir.box<!fir.heap<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<f32>>>
+  %2 = fir.allocmem f32 {uniq_name = "_QMmEallocatable_component.alloc"}
+  %3 = fir.embox %2 : (!fir.heap<f32>) -> !fir.box<!fir.heap<f32>>
+  fir.store %3 to %1 : !fir.ref<!fir.box<!fir.heap<f32>>>
+  %4 = fir.field_index allocatable_component, !fir.type<_QMmTt{allocatable_component:!fir.box<!fir.heap<f32>>}>
+  %5 = fir.coordinate_of %arg1, %4 : (!fir.ref<!fir.type<_QMmTt{allocatable_component:!fir.box<!fir.heap<f32>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.heap<f32>>>
+  %6 = fir.load %5 : !fir.ref<!fir.box<!fir.heap<f32>>>
+  %7 = fir.box_addr %6 : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32>
+  %8 = fir.convert %7 : (!fir.heap<f32>) -> !fir.ref<f32>
+  fir.call @_QPtest2(%8) fastmath<contract> : (!fir.ref<f32>) -> ()
+  return
+}
+func.func private @_QPtest2(!fir.ref<f32>)