Fix todos for handling addresses of pointers

The general `if` calling `isTargetOrPointer` was handling addresses
*of* pointers similarly to addresses *in* pointers: it assumed they
may alias each other.  While that's true in the case of dummy args,
it's not true generally, as revealed by some of the test suite todos
fixed by this commit.

Author: jdenny-ornl

flang/lib/Optimizer/Analysis/AliasAnalysis.cpp

@@ -118,8 +118,13 @@ bool AliasAnalysis::Source::canBeActualArgWithPtr(
   // Must not be local.
   if (!canBeActualArg())
     return false;
-  // Must be address of a composite with a pointer component.
-  return isRecordWithPointerComponent(val->getType());
+  // Can be address *of* (not *in*) a pointer.
+  if (attributes.test(Attribute::Pointer) && !isData())
+    return true;
+  // Can be address of a composite with a pointer component.
+  if (isRecordWithPointerComponent(val->getType()))
+    return true;
+  return false;
 }
 
 AliasResult AliasAnalysis::alias(mlir::Value lhs, mlir::Value rhs) {
@@ -222,16 +227,18 @@ AliasResult AliasAnalysis::alias(mlir::Value lhs, mlir::Value rhs) {
     src2->attributes.set(Attribute::Target);
   }
 
-  // Two TARGET/POINTERs may alias.
+  // Two TARGET/POINTERs may alias.  The logic here focuses on data.  Handling
+  // of non-data is included below.
   if (src1->isTargetOrPointer() && src2->isTargetOrPointer() &&
-      src1->isData() == src2->isData()) {
+      src1->isData() && src2->isData()) {
     LLVM_DEBUG(llvm::dbgs() << "  aliasing because of target or pointer\n");
     return AliasResult::MayAlias;
   }
 
-  // A pointer dummy arg (but not a pointer component of a dummy arg) may alias
-  // a pointer component and thus the associated composite.  That composite
-  // might be a global or another dummy arg.  This is an example of the global
+  // The address of a pointer dummy arg (but not a pointer component of a dummy
+  // arg) may alias the address of either (1) a non-local pointer or (2) thus a
+  // non-local composite with a pointer component.  A non-local might be a
+  // global or another dummy arg.  The following is an example of the global
   // composite case:
   //
   // module m
@@ -276,8 +283,8 @@ AliasResult AliasAnalysis::alias(mlir::Value lhs, mlir::Value rhs) {
   if ((src1->aliasesLikePtrDummyArg() && src2->canBeActualArgWithPtr(val2)) ||
       (src2->aliasesLikePtrDummyArg() && src1->canBeActualArgWithPtr(val1))) {
     LLVM_DEBUG(llvm::dbgs()
-               << "  aliasing between pointer dummy arg and composite with "
-               << "pointer component\n");
+               << "  aliasing between pointer dummy arg and either pointer or "
+               << "composite with pointer component\n");
     return AliasResult::MayAlias;
   }
 

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

@@ -52,12 +52,8 @@
 // CHECK-DAG: xnext1#0 <-> xnext2#0: MayAlias
 // CHECK-DAG: xnext1.fir#0 <-> xnext2.fir#0: MayAlias
 
-// TODO: These should be NoAlias.  However, AliasAnalysis currently
-// indiscriminately treats all pointers as aliasing.  That makes sense for the
-// addresses within the pointers but not necessarily for the addresses of the
-// pointers.
-// CHECK-DAG: xnext1#0 <-> ynext#0: MayAlias
-// CHECK-DAG: xnext1.fir#0 <-> ynext.fir#0: MayAlias
+// CHECK-DAG: xnext1#0 <-> ynext#0: NoAlias
+// CHECK-DAG: xnext1.fir#0 <-> ynext.fir#0: NoAlias
 
 func.func @_QMmPfoo(%arg0: !fir.ref<!fir.type<_QMmTt{next:!fir.box<!fir.ptr<!fir.type<_QMmTt>>>,i:i32}>> {fir.bindc_name = "x"}, %arg1: !fir.ref<!fir.type<_QMmTt{next:!fir.box<!fir.ptr<!fir.type<_QMmTt>>>,i:i32}>> {fir.bindc_name = "y"}) {
   %0 = fir.alloca i32 {bindc_name = "i1", uniq_name = "_QMmFfooEi1"}
@@ -391,16 +387,11 @@ func.func @_QMmPtest.fir() {
 
 // Check when composite is a local and thus cannot alias a dummy arg.
 //
-// TODO: The argp vs. loc%p cases should be NoAlias.  However, AliasAnalysis
-// currently indiscriminately treats all pointers as aliasing.  That makes sense
-// for the addresses within the pointers but not necessarily for the addresses
-// of the pointers here.
-//
 // CHECK-DAG: argp#0 <-> loc#0: NoAlias
-// CHECK-DAG: argp#0 <-> loc%p#0: MayAlias
+// CHECK-DAG: argp#0 <-> loc%p#0: NoAlias
 // CHECK-DAG: argp#0 <-> loc%i#0: NoAlias
 // CHECK-DAG: argp.fir#0 <-> loc.fir#0: NoAlias
-// CHECK-DAG: argp.fir#0 <-> loc%p.fir#0: MayAlias
+// CHECK-DAG: argp.fir#0 <-> loc%p.fir#0: NoAlias
 // CHECK-DAG: argp.fir#0 <-> loc%i.fir#0: NoAlias
 //
 // CHECK-DAG: argp.tgt#0 <-> loc#0: NoAlias
@@ -519,13 +510,10 @@ func.func @_QMmPtest.fir(%arg0: !fir.ref<!fir.box<!fir.ptr<i32>>> {fir.bindc_nam
 // CHECK-DAG: argp.tgt.fir#0 <-> arg%p.fir#0: MayAlias
 // CHECK-DAG: argp.tgt.fir#0 <-> arg%i.fir#0: MayAlias
 //
-// TODO: Shouldn't the arga vs. arg%p cases be NoAlias?  However, arga is
-// treated like a target because it's HostAssoc and arg is Argument, and arg%p
-// is treated like a pointer.
 // CHECK-DAG: arga#0 <-> arg#0: NoAlias
-// CHECK-DAG: arga#0 <-> arg%p#0: MayAlias
+// CHECK-DAG: arga#0 <-> arg%p#0: NoAlias
 // CHECK-DAG: arga.fir#0 <-> arg.fir#0: NoAlias
-// CHECK-DAG: arga.fir#0 <-> arg%p.fir#0: MayAlias
+// CHECK-DAG: arga.fir#0 <-> arg%p.fir#0: NoAlias
 
 // Check when composite is a global.
 //
@@ -552,16 +540,11 @@ func.func @_QMmPtest.fir(%arg0: !fir.ref<!fir.box<!fir.ptr<i32>>> {fir.bindc_nam
 
 // Check when composite is a local and thus cannot alias a dummy arg.
 //
-// TODO: The argp vs. loc%p case should be NoAlias.  However, AliasAnalysis
-// currently indiscriminately treats all pointers as aliasing.  That makes sense
-// for the addresses within the pointers but not necessarily for the addresses
-// of the pointers here.
-//
 // CHECK-DAG: argp#0 <-> loc#0: NoAlias
-// CHECK-DAG: argp#0 <-> loc%p#0: MayAlias
+// CHECK-DAG: argp#0 <-> loc%p#0: NoAlias
 // CHECK-DAG: argp#0 <-> loc%i#0: NoAlias
 // CHECK-DAG: argp.fir#0 <-> loc.fir#0: NoAlias
-// CHECK-DAG: argp.fir#0 <-> loc%p.fir#0: MayAlias
+// CHECK-DAG: argp.fir#0 <-> loc%p.fir#0: NoAlias
 // CHECK-DAG: argp.fir#0 <-> loc%i.fir#0: NoAlias
 //
 // TODO: Shouldn't these be NoAlias?  However, argp.tgt is currently handled as