mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-16 06:46:33 +00:00
Code Issues Projects Releases Wiki Activity

[flang][NFCI] Stop tracking memory source after a load in a more explicit manner. (#126156)

Browse Source 
Typically, we do not track memory sources after a load because of the
dynamic nature of the load and the fact that the alias analysis is a
simple static analysis.

However, the code is written in a way that makes it seem like we are
continuing to track memory but in reality we are only doing so when we
know that the tracked memory is a leaf and therefore when there will
only be one more iteration through the switch statement. In other words,
we are iterating one more time, to gather data about a box, anticipating
that this will be the last time. This is a hack that helped avoid
cut-and-paste from other case statements but gives the wrong impression
about the intention of the code and makes it confusing.

To make it clear that there is no more tracking, we gather all the
necessary data from the memref of the load, in the case statement for
the load, and exit the loop. I am also limiting this data gathering for
the case when we load a box reference while we were actually following
data, as tests have shows, is the only case when we need it for. Other
cases will be handled conservatively, but this can change in the future,
on a case-by-case basis.

---------

Co-authored-by: Joel E. Denny <jdenny.ornl@gmail.com>
This commit is contained in:
Renaud Kauffmann 2025-02-11 10:47:38 -08:00 committed by GitHub
parent 71e623d878
commit 9d7177a2d7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
3 changed files with 122 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
flang/lib/Optimizer/Analysis/AliasAnalysis.cpp
View File

@ -51,7 +51,7 @@ static bool hasGlobalOpTargetAttr(mlir::Value v, fir::AddrOfOp op) {
v, fir::GlobalOp::getTargetAttrName(globalOpName));
}
mlir::Value getOriginalDef(mlir::Value v) {
static mlir::Value getOriginalDef(mlir::Value v) {
mlir::Operation *defOp;
bool breakFromLoop = false;
while (!breakFromLoop && (defOp = v.getDefiningOp())) {
@ -578,16 +578,6 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
breakFromLoop = true;
})
.Case<fir::LoadOp>([&](auto op) {
// If the load is from a leaf source, return the leaf. Do not track
// through indirections otherwise.
// TODO: Add support to fir.alloca and fir.allocmem
auto def = getOriginalDef(op.getMemref());
if (isDummyArgument(def) ||
def.template getDefiningOp<fir::AddrOfOp>()) {
v = def;
defOp = v.getDefiningOp();
return;
}
// If load is inside target and it points to mapped item,
// continue tracking.
Operation *loadMemrefOp = op.getMemref().getDefiningOp();
@ -600,6 +590,40 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value v,
defOp = v.getDefiningOp();
return;
}
// If we are loading a box reference, but following the data,
// we gather the attributes of the box to populate the source
// and stop tracking.
if (auto boxTy = mlir::dyn_cast<fir::BaseBoxType>(ty);
boxTy && followingData) {
if (mlir::isa<fir::PointerType>(boxTy.getEleTy()))
attributes.set(Attribute::Pointer);
auto def = getOriginalDef(op.getMemref());
if (auto addrOfOp = def.template getDefiningOp<fir::AddrOfOp>()) {
global = addrOfOp.getSymbol();
if (hasGlobalOpTargetAttr(def, addrOfOp))
attributes.set(Attribute::Target);
type = SourceKind::Global;
}
// TODO: Add support to fir.alloca and fir.allocmem
// if (auto allocOp = def.template getDefiningOp<fir::AllocaOp>()) {
// ...
// }
if (isDummyArgument(def)) {
defOp = nullptr;
v = def;
}
breakFromLoop = true;
return;
}
// No further tracking for addresses loaded from memory for now.
type = SourceKind::Indirect;
breakFromLoop = true;

8
flang/test/Analysis/AliasAnalysis/alias-analysis-2.fir
View File

@ -47,13 +47,15 @@
// CHECK-DAG: arg2.load#0 <-> arg2.addr#0: MustAlias
// CHECK-DAG: boxp1.addr#0 <-> arg2.addr#0: MayAlias
// TODO: Can the address in a pointer alias the address of a pointer, even when the
// TODO: Can the address in a pointer alias the address of a pointer, when the
// pointer has no box. Should this be NoAlias?
// T3: CHECK-DAG: p1.addr#0 <-> p1.tgt#0: MayAlias
// T3 from <https://github.com/llvm/llvm-project/pull/117785#discussion_r1924348480>.
// CHECK-DAG: p1.addr#0 <-> p1.tgt#0: MayAlias
// The addresses stored in two different pointers can alias, even if one has no
// box. In this program, they happen to be the same address.
// T4: CHECK-DAG: p1.tgt#0 <-> boxp1.addr#0: MayAlias
// T4:
// CHECK-DAG: p1.tgt#0 <-> boxp1.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"} {

82
flang/test/Analysis/AliasAnalysis/alias-analysis-target.fir Normal file
View File

@ -0,0 +1,82 @@
// RUN: fir-opt %s -pass-pipeline='builtin.module(func.func(test-fir-alias-analysis))' 2>&1 | FileCheck %s
// The test was obtained from
// bbc test.f90 -emit-fir
// module mod
// real, pointer :: p0
// real, allocatable :: alloc
// real, allocatable, target :: t_alloc
// real, target :: t
// real :: v
// end module
//
// subroutine test(n)
// use mod
// integer :: n
// real r1
// p0 => t_alloc
// v = alloc
// r1 = p0
// end subroutine test
// Checking that aliasing can only happen with an entity with the target attribute
//
// CHECK-DAG: r1#0 <-> t_alloc#0: NoAlias
// CHECK-DAG: r1#0 <-> alloc#0: NoAlias
// CHECK-DAG: t_alloc#0 <-> alloc#0: NoAlias
// CHECK-DAG: r1#0 <-> p0.ptr#0: NoAlias
// CHECK-DAG: t_alloc#0 <-> p0.ptr#0: MayAlias
// CHECK-DAG: alloc#0 <-> p0.ptr#0: NoAlias
fir.global @_QMmodEalloc : !fir.box<!fir.heap<f32>> {
%0 = fir.zero_bits !fir.heap<f32>
%1 = fir.embox %0 : (!fir.heap<f32>) -> !fir.box<!fir.heap<f32>>
fir.has_value %1 : !fir.box<!fir.heap<f32>>
}
fir.global @_QMmodEp0 : !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 @_QMmodEt target : f32 {
%0 = fir.zero_bits f32
fir.has_value %0 : f32
}
fir.global @_QMmodEt_alloc target : !fir.box<!fir.heap<f32>> {
%0 = fir.zero_bits !fir.heap<f32>
%1 = fir.embox %0 : (!fir.heap<f32>) -> !fir.box<!fir.heap<f32>>
fir.has_value %1 : !fir.box<!fir.heap<f32>>
}
fir.global @_QMmodEv : f32 {
%0 = fir.zero_bits f32
fir.has_value %0 : f32
}
func.func @_QPtest(%arg0: !fir.ref<i32> {fir.bindc_name = "n"}) {
%0 = fir.dummy_scope : !fir.dscope
%1 = fir.address_of(@_QMmodEalloc) : !fir.ref<!fir.box<!fir.heap<f32>>>
%2 = fir.declare %1 {fortran_attrs = #fir.var_attrs<allocatable>, uniq_name = "_QMmodEalloc"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> !fir.ref<!fir.box<!fir.heap<f32>>>
%3 = fir.declare %arg0 dummy_scope %0 {uniq_name = "_QFtestEn"} : (!fir.ref<i32>, !fir.dscope) -> !fir.ref<i32>
%4 = fir.address_of(@_QMmodEp0) : !fir.ref<!fir.box<!fir.ptr<f32>>>
%5 = fir.declare %4 {fortran_attrs = #fir.var_attrs<pointer>, uniq_name = "_QMmodEp0"} : (!fir.ref<!fir.box<!fir.ptr<f32>>>) -> !fir.ref<!fir.box<!fir.ptr<f32>>>
%6 = fir.alloca f32 {bindc_name = "r1", uniq_name = "_QFtestEr1"}
%7 = fir.declare %6 {test.ptr="r1", uniq_name = "_QFtestEr1"} : (!fir.ref<f32>) -> !fir.ref<f32>
%8 = fir.address_of(@_QMmodEt) : !fir.ref<f32>
%9 = fir.declare %8 {fortran_attrs = #fir.var_attrs<target>, uniq_name = "_QMmodEt"} : (!fir.ref<f32>) -> !fir.ref<f32>
%10 = fir.address_of(@_QMmodEt_alloc) : !fir.ref<!fir.box<!fir.heap<f32>>>
%11 = fir.declare %10 {fortran_attrs = #fir.var_attrs<allocatable, target>, uniq_name = "_QMmodEt_alloc"} : (!fir.ref<!fir.box<!fir.heap<f32>>>) -> !fir.ref<!fir.box<!fir.heap<f32>>>
%12 = fir.address_of(@_QMmodEv) : !fir.ref<f32>
%13 = fir.declare %12 {uniq_name = "_QMmodEv"} : (!fir.ref<f32>) -> !fir.ref<f32>
%14 = fir.load %11 : !fir.ref<!fir.box<!fir.heap<f32>>>
%15 = fir.box_addr %14 {test.ptr="t_alloc"}: (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32>
%16 = fir.embox %15 : (!fir.heap<f32>) -> !fir.box<!fir.ptr<f32>>
fir.store %16 to %5 : !fir.ref<!fir.box<!fir.ptr<f32>>>
%17 = fir.load %2 : !fir.ref<!fir.box<!fir.heap<f32>>>
%18 = fir.box_addr %17 {test.ptr="alloc"} : (!fir.box<!fir.heap<f32>>) -> !fir.heap<f32>
%19 = fir.load %18 : !fir.heap<f32>
fir.store %19 to %13 : !fir.ref<f32>
%20 = fir.load %5 : !fir.ref<!fir.box<!fir.ptr<f32>>>
%21 = fir.box_addr %20 {test.ptr="p0.ptr"} : (!fir.box<!fir.ptr<f32>>) -> !fir.ptr<f32>
%22 = fir.load %21 : !fir.ptr<f32>
fir.store %22 to %7 : !fir.ref<f32>
return
}