When there is a call to a function which host associations,

pessimistically assume that the procedure will access all the arrays and
copies need to be made. [i0c]

Author: schweitzpgi

flang/include/flang/Optimizer/Dialect/FIROpsSupport.h

@@ -56,11 +56,6 @@ mlir::FuncOp createFuncOp(mlir::Location loc, mlir::ModuleOp module,
                           llvm::StringRef name, mlir::FunctionType type,
                           llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
 
-/// Get or create a GlobalOp in a module.
-fir::GlobalOp createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
-                             llvm::StringRef name, mlir::Type type,
-                             llvm::ArrayRef<mlir::NamedAttribute> attrs = {});
-
 /// Attribute to mark Fortran entities with the CONTIGUOUS attribute.
 static constexpr llvm::StringRef getContiguousAttrName() {
   return "fir.contiguous";
@@ -82,6 +77,10 @@ static constexpr llvm::StringRef getHostAssocAttrName() {
   return "fir.host_assoc";
 }
 
+/// Does the function, \p func, have a host-associations tuple argument?
+/// Some internal procedures may have access to host procedure variables.
+bool hasHostAssociationArgument(mlir::FuncOp func);
+
 /// Tell if \p value is:
 ///   - a function argument that has attribute \p attributeName
 ///   - or, the result of fir.alloca/fir.allocamem op that has attribute \p

flang/lib/Optimizer/Dialect/FIROps.cpp

@@ -3221,15 +3221,13 @@ mlir::FuncOp fir::createFuncOp(mlir::Location loc, mlir::ModuleOp module,
   return result;
 }
 
-fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
-                                  StringRef name, mlir::Type type,
-                                  llvm::ArrayRef<mlir::NamedAttribute> attrs) {
-  if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
-    return g;
-  mlir::OpBuilder modBuilder(module.getBodyRegion());
-  auto result = modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
-  result.setVisibility(mlir::SymbolTable::Visibility::Private);
-  return result;
+bool fir::hasHostAssociationArgument(mlir::FuncOp func) {
+  if (auto allArgAttrs = func.getAllArgAttrs())
+    for (auto attr : allArgAttrs)
+      if (auto dict = attr.template dyn_cast_or_null<mlir::DictionaryAttr>())
+        if (dict.get(fir::getHostAssocAttrName()))
+          return true;
+  return false;
 }
 
 bool fir::valueHasFirAttribute(mlir::Value value,

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

@@ -13,6 +13,7 @@
 #include "flang/Optimizer/Builder/FIRBuilder.h"
 #include "flang/Optimizer/Builder/Factory.h"
 #include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROpsSupport.h"
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/SCF/SCF.h"
@@ -224,6 +225,11 @@ class ReachCollector {
       for (auto *user : op->getResult(0).getUsers())
         followUsers(user);
 
+    if (mlir::isa<fir::CallOp>(op)) {
+      LLVM_DEBUG(llvm::dbgs() << "add " << *op << " to reachable set\n");
+      reach.push_back(op);
+    }
+
     for (auto u : op->getOperands())
       collectArrayMentionFrom(u);
   }
@@ -539,6 +545,22 @@ static bool conflictDetected(llvm::ArrayRef<mlir::Operation *> reach,
   return conflictOnLoad(reach, st) || conflictOnMerge(mentions);
 }
 
+// Assume that any call to a function that uses host-associations will be
+// modifying the output array.
+static bool
+conservativeCallConflict(llvm::ArrayRef<mlir::Operation *> reaches) {
+  return llvm::any_of(reaches, [](mlir::Operation *op) {
+    if (auto call = mlir::dyn_cast<fir::CallOp>(op))
+      if (auto callee =
+              call.getCallableForCallee().dyn_cast<mlir::SymbolRefAttr>()) {
+        auto module = op->getParentOfType<mlir::ModuleOp>();
+        return fir::hasHostAssociationArgument(
+            module.lookupSymbol<mlir::FuncOp>(callee));
+      }
+    return false;
+  });
+}
+
 /// Constructor of the array copy analysis.
 /// This performs the analysis and saves the intermediate results.
 void ArrayCopyAnalysis::construct(mlir::MutableArrayRef<mlir::Region> regions) {
@@ -550,12 +572,13 @@ void ArrayCopyAnalysis::construct(mlir::MutableArrayRef<mlir::Region> regions) {
         if (auto st = mlir::dyn_cast<ArrayMergeStoreOp>(op)) {
           llvm::SmallVector<Operation *> values;
           ReachCollector::reachingValues(values, st.sequence());
+          auto callConflict = conservativeCallConflict(values);
           llvm::SmallVector<Operation *> mentions;
           arrayMentions(mentions,
                         mlir::cast<ArrayLoadOp>(st.original().getDefiningOp()));
           auto conflict = conflictDetected(values, mentions, st);
           auto refConflict = conflictOnReference(mentions);
-          if (conflict || refConflict) {
+          if (callConflict || conflict || refConflict) {
             LLVM_DEBUG(llvm::dbgs()
                        << "CONFLICT: copies required for " << st << '\n'
                        << "   adding conflicts on: " << op << " and "