================
@@ -406,7 +406,7 @@ AliasAnalysis::Source AliasAnalysis::getSource(mlir::Value
v) {
attributes.set(Attribute::Pointer);
}
- if (type == SourceKind::Global)
+ if (type == SourceKind::Global || type == SourceKind::Direct)
----------------
Renaud-K wrote:
Would it help, if I just said that %val does not come from a global variable.
It comes from the heap because glbl is an allocatable. The box is global, but
the data it wraps is not.
In the example below glbl is a global
```module mod
real, dimension(1000) :: glbl
contains
subroutine func(arg)
real, intent(in), dimension(:) :: arg
call escape(glbl)
end subroutine
end module
```
In this case the SourceKind is global and we can infer that it cannot alias
with anything else because of where it is physically located. But if you prefer
to stick to Fortran rules, you can say that it is an F77 construct (since it
does not have any target attribute) and therefore does not alias with anything.
It would be non-conformant to pass it as an argument.
```
fir.global @_QMmodEglbl : !fir.array<1000xf32> {
%0 = fir.zero_bits !fir.array<1000xf32>
fir.has_value %0 : !fir.array<1000xf32>
}
func.func @_QMmodPfunc(%arg0: !fir.box<!fir.array<?xf32>> {fir.bindc_name =
"arg"}) {
%c1000 = arith.constant 1000 : index
%0 = fir.address_of(@_QMmodEglbl) : !fir.ref<!fir.array<1000xf32>>
%1 = fir.shape %c1000 : (index) -> !fir.shape<1>
%2 = fir.declare %0(%1) {uniq_name = "_QMmodEglbl"} :
(!fir.ref<!fir.array<1000xf32>>, !fir.shape<1>) ->
!fir.ref<!fir.array<1000xf32>>
%3 = fir.declare %arg0 {fortran_attrs = #fir.var_attrs<intent_in>, uniq_name
= "_QMmodFfuncEarg"} : (!fir.box<!fir.array<?xf32>>) ->
!fir.box<!fir.array<?xf32>>
fir.call @_QPescape(%2) fastmath<contract> : (!fir.ref<!fir.array<1000xf32>>)
-> ()
return
}
```
In the case of the Direct SourceKind, the outcome w.r.t. `arg` is the same but
the rule is different. We have a direct memory access because, despite the box
load and indirect fir.box_addr operations, we could establish that %val is
indexing into glbl. There is no target or pointer attribute on `arg` so we say
that it cannot alias with it.
A couple of observations here is:
1. Direct SourceKind by itself is not sufficient to determine aliasing, the
attributes need to be looked at as well.
2. Unlike the global case, the rule for direct is not reflective. Aliasing is
established w.r.t. another value.
Hopefully, this clarifies things. But if none of that helps I am now wondering
if we cannot alter the rule to make it reflective. Instead of
```
lhsSrc.kind == SourceKind::Direct && !rhsSrc.isTargetOrPointer()
```
could we have
```
lhsSrc.kind == SourceKind::Direct && !lhsSrc.isTargetOrPointer()
```
I will play with it today.
https://github.com/llvm/llvm-project/pull/68727
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
