[flang] Avoid unnecessary temporaries in ArrayValueCopy.

[vzakhari]

Summary

Assume no conflict between pointer arrays and arrays without the target
attribute, if the fact of an array not having the target attribute
can be reliably computed.

This change speeds up SPEC CPU2017/527.cam from 2.5k seconds to 880 seconds
on Icelake, and makes further performance investigation easier.

[tschuett]

flang/lib/Optimizer/Dialect/FIROps.cpp

3634

*mayHaveAttr instead of mayHaveAttr.value()

[jeanPerier]

flang/lib/Optimizer/Dialect/FIROps.cpp

3634

Better, you can combine the two lines above with return mayHaveAttr.value_or(true);

flang/test/Fir/array-value-copy-cam4.fir

40

Can you produce this test without the derived type descriptor data? I do not think they are relevant here and they make the test really hard to read. (you can generate the FIR with bbc -emit-fir -I nowhere where "nowhere" can literally be nowhere (it just have to be a directory that does not contain the intrinsic modules so that the front-end cannot generate the derived type descriptors) )

[PeteSteinfeld]

Other than a few nits on comments, all builds and tests correctly and looks good.

flang/lib/Optimizer/Dialect/FIROps.cpp

3546–3547

I couldn't mentally parse the sentence beginning with "Function argument ...". Does this make sense -- "Function arguments may also contribute to the value's definition and carry relevant attributes."

[vzakhari]

flang/lib/Optimizer/Dialect/FIROps.cpp

3546–3547

Thank you, Pete. I am not sure if "contribute" is the right word here. Please see if the modified version reads better.

flang/test/Fir/array-value-copy-cam4.fir

40

Sure! Fixed.

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

 /// Some internal procedures may have access to saved host procedure
 /// variables even when they do not have a tuple argument.
 inline bool isInternalPorcedure(mlir::func::FuncOp func) {
   return func->hasAttr(fir::getInternalProcedureAttrName());
 }
 
 /// 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
+///   - or, the result of fir.alloca/fir.allocmem op that has attribute \p
 ///     attributeName
 ///   - or, the result of a fir.address_of of a fir.global that has attribute \p
 ///     attributeName
 ///   - or, a fir.box loaded from a fir.ref<fir.box> that matches one of the
 ///     previous cases.
 bool valueHasFirAttribute(mlir::Value value, llvm::StringRef attributeName);
 
+/// A more conservative version of valueHasFirAttribute().
+/// If `value` is one of the operation/function-argument cases listed
+/// for valueHasFirAttribute():
+///   * if any of the `attributeNames` attributes is set, then the function
+///     will return true.
+///   * otherwise, it will return false.
+///
+/// Otherwise, the function will return true indicating that the attributes
+/// may actually be set but we were not able to reach the point of definition
+/// to confirm that.
+bool valueMayHaveFirAttributes(mlir::Value value,
+                               llvm::ArrayRef<llvm::StringRef> attributeNames);
+
 /// Scan the arguments of a FuncOp to determine if any arguments have the
 /// attribute `attr` placed on them. This can be used to determine if the
 /// function has any host associations, for example.
 bool anyFuncArgsHaveAttr(mlir::func::FuncOp func, llvm::StringRef attr);
 
 /// Unwrap integer constant from an mlir::Value.
 inline std::optional<std::int64_t> getIntIfConstant(mlir::Value value) {
   if (auto *definingOp = value.getDefiningOp())

flang/include/flang/Optimizer/Transforms/Passes.h

 #define GEN_PASS_DECL_MEMORYALLOCATIONOPT
 #define GEN_PASS_DECL_SIMPLIFYREGIONLITE
 #define GEN_PASS_DECL_ALGEBRAICSIMPLIFICATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 std::unique_ptr<mlir::Pass> createAbstractResultOnFuncOptPass();
 std::unique_ptr<mlir::Pass> createAbstractResultOnGlobalOptPass();
 std::unique_ptr<mlir::Pass> createAffineDemotionPass();
-std::unique_ptr<mlir::Pass> createArrayValueCopyPass();
+std::unique_ptr<mlir::Pass>
+createArrayValueCopyPass(fir::ArrayValueCopyOptions options = {});
 std::unique_ptr<mlir::Pass> createFirToCfgPass();
 std::unique_ptr<mlir::Pass> createCharacterConversionPass();
 std::unique_ptr<mlir::Pass> createExternalNameConversionPass();
 std::unique_ptr<mlir::Pass> createMemDataFlowOptPass();
 std::unique_ptr<mlir::Pass> createPromoteToAffinePass();
 std::unique_ptr<mlir::Pass> createMemoryAllocationPass();
 std::unique_ptr<mlir::Pass> createSimplifyIntrinsicsPass();
 std::unique_ptr<mlir::Pass> createAddDebugFoundationPass();

flang/include/flang/Optimizer/Transforms/Passes.td

let description = [{
     representation. If there is a potential conflict, a temporary is created
     along with appropriate copy-in/copy-out operations. Here, a more refined
     analysis might be deployed, such as using the affine framework.
 
     This pass is required before code gen to the LLVM IR dialect.
   }];
   let constructor = "::fir::createArrayValueCopyPass()";
   let dependentDialects = [ "fir::FIROpsDialect" ];
+  let options = [
+    Option<"optimizeConflicts", "optimize-conflicts", "bool",
+           /*default=*/"false",
+           "do more detailed conflict analysis to reduce the number "
+           "of temporaries">
+  ];
 }
 
 def CharacterConversion : Pass<"character-conversion"> {
   let summary = "Convert CHARACTER entities with different KINDs";
   let description = [{
     Translates entities of one CHARACTER KIND to another.
 
     By default the translation is to naively zero-extend or truncate a code

flang/include/flang/Tools/CLOptions.inc

static void defaultFlangInlinerOptPipeline(mlir::OpPassManager &pm) {
   pm.addPass(mlir::createCanonicalizerPass(config));
 }
 
 inline void addCfgConversionPass(mlir::PassManager &pm) {
   addNestedPassConditionally<mlir::func::FuncOp>(
       pm, disableCfgConversion, fir::createFirToCfgPass);
 }
 
-inline void addAVC(mlir::PassManager &pm) {
+inline void addAVC(
+    mlir::PassManager &pm, const llvm::OptimizationLevel &optLevel) {
+  ArrayValueCopyOptions options;
+  options.optimizeConflicts = optLevel.isOptimizingForSpeed();
   addNestedPassConditionally<mlir::func::FuncOp>(
-      pm, disableFirAvc, fir::createArrayValueCopyPass);
+      pm, disableFirAvc, [&]() { return createArrayValueCopyPass(options); });
 }
 
 inline void addMemoryAllocationOpt(mlir::PassManager &pm) {
   addNestedPassConditionally<mlir::func::FuncOp>(pm, disableFirMao, [&]() {
     return fir::createMemoryAllocationPass(
         dynamicArrayStackToHeapAllocation, arrayStackAllocationThreshold);
   });
 }

 ///
 /// \param pm - MLIR pass manager that will hold the pipeline definition
 inline void createDefaultFIROptimizerPassPipeline(
     mlir::PassManager &pm, llvm::OptimizationLevel optLevel = defaultOptLevel) {
   // simplify the IR
   mlir::GreedyRewriteConfig config;
   config.enableRegionSimplification = false;
   pm.addPass(mlir::createCSEPass());
-  fir::addAVC(pm);
+  fir::addAVC(pm, optLevel);
   pm.addNestedPass<mlir::func::FuncOp>(fir::createCharacterConversionPass());
   pm.addPass(mlir::createCanonicalizerPass(config));
   pm.addPass(fir::createSimplifyRegionLitePass());
   if (optLevel.isOptimizingForSpeed()) {
     // These passes may increase code size.
     pm.addPass(fir::createSimplifyIntrinsicsPass());
     pm.addPass(fir::createAlgebraicSimplificationPass(config));
   }

flang/lib/Optimizer/Dialect/FIROps.cpp

bool fir::hasHostAssociationArgument(mlir::func::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,
-                               llvm::StringRef attributeName) {
+// Test if value's definition has the specified set of
+// attributeNames. The value's definition is one of the operations
+// that are able to carry the Fortran variable attributes, e.g.
+// fir.alloca or fir.allocmem. Function arguments may also represent
+// value definitions and carry relevant attributes.
+//
+// If it is not possible to reach the limited set of definition
+// entities from the given value, then the function will return
+// std::nullopt. Otherwise, the definition is known and the return
+// value is computed as:
+//   * if checkAny is true, then the function will return true
+//     iff any of the attributeNames attributes is set on the definition.
+//   * if checkAny is false, then the function will return true
+//     iff all of the attributeNames attributes are set on the definition.
+static std::optional<bool>
+valueCheckFirAttributes(mlir::Value value,
+                        llvm::ArrayRef<llvm::StringRef> attributeNames,
+                        bool checkAny) {
+  auto testAttributeSets = [&](llvm::ArrayRef<mlir::NamedAttribute> setAttrs,
+                               llvm::ArrayRef<llvm::StringRef> checkAttrs) {
+    if (checkAny) {
+      // Return true iff any of checkAttrs attributes is present
+      // in setAttrs set.
+      for (llvm::StringRef checkAttrName : checkAttrs)
+        if (llvm::any_of(setAttrs, [&](mlir::NamedAttribute setAttr) {
+              return setAttr.getName() == checkAttrName;
+            }))
+          return true;
+
+      return false;
+    }
+
+    // Return true iff all attributes from checkAttrs are present
+    // in setAttrs set.
+    for (mlir::StringRef checkAttrName : checkAttrs)
+      if (llvm::none_of(setAttrs, [&](mlir::NamedAttribute setAttr) {
+            return setAttr.getName() == checkAttrName;
+          }))
+        return false;
+
+    return true;
+  };
   // If this is a fir.box that was loaded, the fir attributes will be on the
   // related fir.ref<fir.box> creation.
   if (value.getType().isa<fir::BoxType>())
     if (auto definingOp = value.getDefiningOp())
       if (auto loadOp = mlir::dyn_cast<fir::LoadOp>(definingOp))
         value = loadOp.getMemref();
   // If this is a function argument, look in the argument attributes.
   if (auto blockArg = value.dyn_cast<mlir::BlockArgument>()) {
     if (blockArg.getOwner() && blockArg.getOwner()->isEntryBlock())
       if (auto funcOp = mlir::dyn_cast<mlir::func::FuncOp>(
               blockArg.getOwner()->getParentOp()))
-        if (funcOp.getArgAttr(blockArg.getArgNumber(), attributeName))
-          return true;
-    return false;
+        return testAttributeSets(
+            mlir::cast<mlir::FunctionOpInterface>(*funcOp).getArgAttrs(
+                blockArg.getArgNumber()),
+            attributeNames);
+
+    // If it is not a function argument, the attributes are unknown.
+    return std::nullopt;
   }
 
   if (auto definingOp = value.getDefiningOp()) {
     // If this is an allocated value, look at the allocation attributes.
     if (mlir::isa<fir::AllocMemOp>(definingOp) ||
-        mlir::isa<AllocaOp>(definingOp))
-      return definingOp->hasAttr(attributeName);
+        mlir::isa<fir::AllocaOp>(definingOp))
+      return testAttributeSets(definingOp->getAttrs(), attributeNames);
     // If this is an imported global, look at AddrOfOp and GlobalOp attributes.
     // Both operations are looked at because use/host associated variable (the
     // AddrOfOp) can have ASYNCHRONOUS/VOLATILE attributes even if the ultimate
     // entity (the globalOp) does not have them.
     if (auto addressOfOp = mlir::dyn_cast<fir::AddrOfOp>(definingOp)) {
-      if (addressOfOp->hasAttr(attributeName))
+      if (testAttributeSets(addressOfOp->getAttrs(), attributeNames))
         return true;
       if (auto module = definingOp->getParentOfType<mlir::ModuleOp>())
         if (auto globalOp =
                 module.lookupSymbol<fir::GlobalOp>(addressOfOp.getSymbol()))
-          return globalOp->hasAttr(attributeName);
+          return testAttributeSets(globalOp->getAttrs(), attributeNames);
     }
   }
   // TODO: Construct associated entities attributes. Decide where the fir
   // attributes must be placed/looked for in this case.
-  return false;
+  return std::nullopt;
+}
+
+bool fir::valueMayHaveFirAttributes(
+    mlir::Value value, llvm::ArrayRef<llvm::StringRef> attributeNames) {
+  std::optional<bool> mayHaveAttr =
+      valueCheckFirAttributes(value, attributeNames, /*checkAny=*/true);
+  return mayHaveAttr.value_or(true);
+}
+
+bool fir::valueHasFirAttribute(mlir::Value value,
+                               llvm::StringRef attributeName) {
+  std::optional<bool> mayHaveAttr =
+      valueCheckFirAttributes(value, {attributeName}, /*checkAny=*/false);
+  return mayHaveAttr.value_or(false);
 }
 
 bool fir::anyFuncArgsHaveAttr(mlir::func::FuncOp func, llvm::StringRef attr) {
   for (unsigned i = 0, end = func.getNumArguments(); i < end; ++i)
     if (func.getArgAttr(i, attr))
       return true;
   return false;
 }

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

 /// shape as the other array values a_i, where i != j. [Possible overlapping
 /// arrays.]
 ///
 /// 2. There is either an array_fetch or array_update of a_j with a different
 /// set of index values. [Possible loop-carried dependence.]
 ///
 /// If none of the array values overlap in storage and the accesses are not
 /// loop-carried, then the arrays are conflict-free and no copies are required.
-class ArrayCopyAnalysis {
+class ArrayCopyAnalysisBase {
 public:
-  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArrayCopyAnalysis)
-
   using ConflictSetT = llvm::SmallPtrSet<mlir::Operation *, 16>;
   using UseSetT = llvm::SmallPtrSet<mlir::OpOperand *, 8>;
   using LoadMapSetsT = llvm::DenseMap<mlir::Operation *, UseSetT>;
   using AmendAccessSetT = llvm::SmallPtrSet<mlir::Operation *, 4>;
 
-  ArrayCopyAnalysis(mlir::Operation *op) : operation{op} { construct(op); }
+  ArrayCopyAnalysisBase(mlir::Operation *op, bool optimized)
+      : operation{op}, optimizeConflicts(optimized) {
+    construct(op);
+  }
+  virtual ~ArrayCopyAnalysisBase() = default;
 
   mlir::Operation *getOperation() const { return operation; }
 
   /// Return true iff the `array_merge_store` has potential conflicts.
   bool hasPotentialConflict(mlir::Operation *op) const {
     LLVM_DEBUG(llvm::dbgs()
                << "looking for a conflict on " << *op
                << " and the set has a total of " << conflicts.size() << '\n');
private:
   void construct(mlir::Operation *topLevelOp);
 
   mlir::Operation *operation; // operation that analysis ran upon
   ConflictSetT conflicts;     // set of conflicts (loads and merge stores)
   OperationUseMapT useMap;
   LoadMapSetsT loadMapSets;
   // Set of array_access ops associated with array_amend ops.
   AmendAccessSetT amendAccesses;
+  bool optimizeConflicts;
+};
+
+// Optimized array copy analysis that takes into account Fortran
+// variable attributes to prove that no conflict is possible
+// and reduce the number of temporary arrays.
+class ArrayCopyAnalysisOptimized : public ArrayCopyAnalysisBase {
+public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArrayCopyAnalysisOptimized)
+
+  ArrayCopyAnalysisOptimized(mlir::Operation *op)
+      : ArrayCopyAnalysisBase(op, /*optimized=*/true) {}
+};
+
+// Unoptimized array copy analysis used at O0.
+class ArrayCopyAnalysis : public ArrayCopyAnalysisBase {
+public:
+  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(ArrayCopyAnalysis)
+
+  ArrayCopyAnalysis(mlir::Operation *op)
+      : ArrayCopyAnalysisBase(op, /*optimized=*/false) {}
 };
 } // namespace
 
 namespace {
 /// Helper class to collect all array operations that produced an array value.
 class ReachCollector {
 public:
   ReachCollector(llvm::SmallVectorImpl<mlir::Operation *> &reach,
private:
   llvm::SmallPtrSet<mlir::Value, 16> visited;
   /// Region of the loops nest that produced the array value.
   mlir::Region *loopRegion;
 };
 } // namespace
 
 /// Find all the array operations that access the array value that is loaded by
 /// the array load operation, `load`.
-void ArrayCopyAnalysis::arrayMentions(
+void ArrayCopyAnalysisBase::arrayMentions(
     llvm::SmallVectorImpl<mlir::Operation *> &mentions, ArrayLoadOp load) {
   mentions.clear();
   auto lmIter = loadMapSets.find(load);
   if (lmIter != loadMapSets.end()) {
     for (auto *opnd : lmIter->second) {
       auto *owner = opnd->getOwner();
       if (mlir::isa<ArrayAccessOp, ArrayAmendOp, ArrayFetchOp, ArrayUpdateOp,
                     ArrayModifyOp>(owner))
static bool mutuallyExclusiveSliceRange(ArrayLoadOp ld, ArrayMergeStoreOp st) {
   LLVM_DEBUG(llvm::dbgs() << "detected non-overlapping slice ranges on " << ld
                           << " and " << st << ", which is not a conflict\n");
   return true;
 }
 
 /// Is there a conflict between the array value that was updated and to be
 /// stored to `st` and the set of arrays loaded (`reach`) and used to compute
 /// the updated value?
+/// If `optimize` is true, use the variable attributes to prove that
+/// there is no conflict.
 static bool conflictOnLoad(llvm::ArrayRef<mlir::Operation *> reach,
-                           ArrayMergeStoreOp st) {
+                           ArrayMergeStoreOp st, bool optimize) {
   mlir::Value load;
   mlir::Value addr = st.getMemref();
   const bool storeHasPointerType = hasPointerType(addr.getType());
   for (auto *op : reach)
     if (auto ld = mlir::dyn_cast<ArrayLoadOp>(op)) {
       mlir::Type ldTy = ld.getMemref().getType();
       if (ld.getMemref() == addr) {
         if (mutuallyExclusiveSliceRange(ld, st))
           continue;
         if (ld.getResult() != st.getOriginal())
           return true;
         if (load) {
           // TODO: extend this to allow checking if the first `load` and this
           // `ld` are mutually exclusive accesses but not identical.
           return true;
         }
         load = ld;
-      } else if ((hasPointerType(ldTy) || storeHasPointerType)) {
-        // TODO: Use target attribute to restrict this case further.
-        // TODO: Check if types can also allow ruling out some cases. For now,
-        // the fact that equivalences is using pointer attribute to enforce
-        // aliasing is preventing any attempt to do so, and in general, it may
-        // be wrong to use this if any of the types is a complex or a derived
-        // for which it is possible to create a pointer to a part with a
-        // different type than the whole, although this deserve some more
-        // investigation because existing compiler behavior seem to diverge
-        // here.
-        return true;
-      }
+      } else if (storeHasPointerType) {
+        if (optimize && !hasPointerType(ldTy) &&
+            !valueMayHaveFirAttributes(
+                ld.getMemref(),
+                {getTargetAttrName(), GlobalOp::getTargetAttrNameStr()}))
+          continue;
+
+        return true;
+      } else if (hasPointerType(ldTy)) {
+        if (optimize && !storeHasPointerType &&
+            !valueMayHaveFirAttributes(
+                addr, {getTargetAttrName(), GlobalOp::getTargetAttrNameStr()}))
+          continue;
+
+        return true;
+      }
     }
   return false;
 }
 
 /// Is there an access vector conflict on the array being merged into? If the
 /// access vectors diverge, then assume that there are potentially overlapping
 /// loop-carried references.
 static bool conflictOnMerge(llvm::ArrayRef<mlir::Operation *> mentions) {
for (auto *op : mentions)
     if (auto amend = mlir::dyn_cast<ArrayAmendOp>(op))
       return amend.getMemref().getDefiningOp();
   return {};
 }
 
 // Are any conflicts present? The conflicts detected here are described above.
 static bool conflictDetected(llvm::ArrayRef<mlir::Operation *> reach,
                              llvm::ArrayRef<mlir::Operation *> mentions,
-                             ArrayMergeStoreOp st) {
-  return conflictOnLoad(reach, st) || conflictOnMerge(mentions);
+                             ArrayMergeStoreOp st, bool optimize) {
+  return conflictOnLoad(reach, st, optimize) || 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 isInternalPorcedure(
             module.lookupSymbol<mlir::func::FuncOp>(callee));
       }
     return false;
   });
 }
 
 /// Constructor of the array copy analysis.
 /// This performs the analysis and saves the intermediate results.
-void ArrayCopyAnalysis::construct(mlir::Operation *topLevelOp) {
+void ArrayCopyAnalysisBase::construct(mlir::Operation *topLevelOp) {
   topLevelOp->walk([&](Operation *op) {
     if (auto st = mlir::dyn_cast<fir::ArrayMergeStoreOp>(op)) {
       llvm::SmallVector<mlir::Operation *> values;
       ReachCollector::reachingValues(values, st.getSequence());
       bool callConflict = conservativeCallConflict(values);
       llvm::SmallVector<mlir::Operation *> mentions;
       arrayMentions(mentions,
                     mlir::cast<ArrayLoadOp>(st.getOriginal().getDefiningOp()));
-      bool conflict = conflictDetected(values, mentions, st);
+      bool conflict = conflictDetected(values, mentions, st, optimizeConflicts);
       bool refConflict = conflictOnReference(mentions);
       if (callConflict || conflict || refConflict) {
         LLVM_DEBUG(llvm::dbgs()
                    << "CONFLICT: copies required for " << st << '\n'
                    << "   adding conflicts on: " << *op << " and "
                    << st.getOriginal() << '\n');
         conflicts.insert(op);
         conflicts.insert(st.getOriginal().getDefiningOp());

 /// If there is a conflict for the update, then we need to perform a
 /// copy-in/copy-out to preserve the original values of the array. If there is
 /// no conflict, then it is save to eschew making any copies.
 template <typename ArrayOp>
 class ArrayUpdateConversionBase : public mlir::OpRewritePattern<ArrayOp> {
 public:
   // TODO: Implement copy/swap semantics?
   explicit ArrayUpdateConversionBase(mlir::MLIRContext *ctx,
-                                     const ArrayCopyAnalysis &a,
+                                     const ArrayCopyAnalysisBase &a,
                                      const OperationUseMapT &m)
       : mlir::OpRewritePattern<ArrayOp>{ctx}, analysis{a}, useMap{m} {}
 
   /// The array_access, \p access, is to be to a cloned copy due to a potential
   /// conflict. Uses copy-in/copy-out semantics and not copy/swap.
   mlir::Value referenceToClone(mlir::Location loc,
                                mlir::PatternRewriter &rewriter,
                                ArrayOp access) const {
auto coor =
         genCoorOp(rewriter, loc, coorTy, lhsEltRefType, load.getMemref(),
                   load.getShape(), load.getSlice(), update.getIndices(), load,
                   update->hasAttr(factory::attrFortranArrayOffsets()));
     assignElement(coor);
     return {coor, load.getResult()};
   }
 
 protected:
-  const ArrayCopyAnalysis &analysis;
+  const ArrayCopyAnalysisBase &analysis;
   const OperationUseMapT &useMap;
 };
 
 class ArrayUpdateConversion : public ArrayUpdateConversionBase<ArrayUpdateOp> {
 public:
   explicit ArrayUpdateConversion(mlir::MLIRContext *ctx,
-                                 const ArrayCopyAnalysis &a,
+                                 const ArrayCopyAnalysisBase &a,
                                  const OperationUseMapT &m)
       : ArrayUpdateConversionBase{ctx, a, m} {}
 
   mlir::LogicalResult
   matchAndRewrite(ArrayUpdateOp update,
                   mlir::PatternRewriter &rewriter) const override {
     auto loc = update.getLoc();
     auto assignElement = [&](mlir::Value coor) {
matchAndRewrite(ArrayUpdateOp update,
     rewriter.replaceOp(update, lhsLoadResult);
     return mlir::success();
   }
 };
 
 class ArrayModifyConversion : public ArrayUpdateConversionBase<ArrayModifyOp> {
 public:
   explicit ArrayModifyConversion(mlir::MLIRContext *ctx,
-                                 const ArrayCopyAnalysis &a,
+                                 const ArrayCopyAnalysisBase &a,
                                  const OperationUseMapT &m)
       : ArrayUpdateConversionBase{ctx, a, m} {}
 
   mlir::LogicalResult
   matchAndRewrite(ArrayModifyOp modify,
                   mlir::PatternRewriter &rewriter) const override {
     auto loc = modify.getLoc();
     auto assignElement = [](mlir::Value) {
private:
   const OperationUseMapT &useMap;
 };
 
 /// As array_access op is like an array_fetch op, except that it does not imply
 /// a load op. (It operates in the reference domain.)
 class ArrayAccessConversion : public ArrayUpdateConversionBase<ArrayAccessOp> {
 public:
   explicit ArrayAccessConversion(mlir::MLIRContext *ctx,
-                                 const ArrayCopyAnalysis &a,
+                                 const ArrayCopyAnalysisBase &a,
                                  const OperationUseMapT &m)
       : ArrayUpdateConversionBase{ctx, a, m} {}
 
   mlir::LogicalResult
   matchAndRewrite(ArrayAccessOp access,
                   mlir::PatternRewriter &rewriter) const override {
     auto *op = access.getOperation();
     auto loc = access.getLoc();
matchAndRewrite(ArrayAmendOp amend,
     rewriter.replaceOp(amend, undef.getResult());
     return mlir::success();
   }
 };
 
 class ArrayValueCopyConverter
     : public fir::impl::ArrayValueCopyBase<ArrayValueCopyConverter> {
 public:
+  ArrayValueCopyConverter() = default;
+  ArrayValueCopyConverter(const fir::ArrayValueCopyOptions &options)
+      : Base(options) {}
+
   void runOnOperation() override {
     auto func = getOperation();
     LLVM_DEBUG(llvm::dbgs() << "\n\narray-value-copy pass on function '"
                             << func.getName() << "'\n");
     auto *context = &getContext();
 
     // Perform the conflict analysis.
-    const auto &analysis = getAnalysis<ArrayCopyAnalysis>();
-    const auto &useMap = analysis.getUseMap();
+    const ArrayCopyAnalysisBase *analysis;
+    if (optimizeConflicts)
+      analysis = &getAnalysis<ArrayCopyAnalysisOptimized>();
+    else
+      analysis = &getAnalysis<ArrayCopyAnalysis>();
+
+    const auto &useMap = analysis->getUseMap();
 
     mlir::RewritePatternSet patterns1(context);
     patterns1.insert<ArrayFetchConversion>(context, useMap);
-    patterns1.insert<ArrayUpdateConversion>(context, analysis, useMap);
-    patterns1.insert<ArrayModifyConversion>(context, analysis, useMap);
-    patterns1.insert<ArrayAccessConversion>(context, analysis, useMap);
+    patterns1.insert<ArrayUpdateConversion>(context, *analysis, useMap);
+    patterns1.insert<ArrayModifyConversion>(context, *analysis, useMap);
+    patterns1.insert<ArrayAccessConversion>(context, *analysis, useMap);
     patterns1.insert<ArrayAmendConversion>(context);
     mlir::ConversionTarget target(*context);
     target
         .addLegalDialect<FIROpsDialect, mlir::scf::SCFDialect,
                          mlir::arith::ArithDialect, mlir::func::FuncDialect>();
     target.addIllegalOp<ArrayAccessOp, ArrayAmendOp, ArrayFetchOp,
                         ArrayUpdateOp, ArrayModifyOp>();
     // Rewrite the array fetch and array update ops.
if (mlir::failed(
       mlir::emitError(mlir::UnknownLoc::get(context),
                       "failure in array-value-copy pass, phase 2");
       signalPassFailure();
     }
   }
 };
 } // namespace
 
-std::unique_ptr<mlir::Pass> fir::createArrayValueCopyPass() {
-  return std::make_unique<ArrayValueCopyConverter>();
+std::unique_ptr<mlir::Pass>
+fir::createArrayValueCopyPass(fir::ArrayValueCopyOptions options) {
+  return std::make_unique<ArrayValueCopyConverter>(options);
 }

flang/test/Fir/array-copies-pointers.fir

 // Test array-copy-value pass (copy elision) with array assignment
 // involving Fortran pointers. Focus in only on wether copy ellision
 // is made or not.
-// RUN: fir-opt %s --array-value-copy -split-input-file | FileCheck %s
+// RUN: fir-opt %s --array-value-copy -split-input-file | FileCheck --check-prefixes=ALL,NOOPT %s
+// RUN: fir-opt %s --array-value-copy="optimize-conflicts=true" -split-input-file | FileCheck --check-prefixes=ALL,OPT %s
 
 // Test `pointer(:) = array(:)`
-// TODO: array should have target attribute.
-// CHECK-LABEL: func @maybe_overlap
-// CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
-// CHECK: fir.do_loop
-// CHECK: fir.do_loop
-// CHECK: fir.do_loop
-// CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
-func.func @maybe_overlap(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
+// ALL-LABEL: func @maybe_overlap
+// ALL: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
+func.func @maybe_overlap(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1 : !fir.ref<!fir.array<100xf32>> {fir.target}) {
+  %c100 = arith.constant 100 : index
+  %c99 = arith.constant 99 : index
+  %c1 = arith.constant 1 : index
+  %c0 = arith.constant 0 : index
+  %0 = fir.alloca f32
+  %1 = fir.shape %c100 : (index) -> !fir.shape<1>
+  %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) {
+    %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32
+    %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
+    fir.result %6 : !fir.array<100xf32>
+  }
+  fir.array_merge_store %2, %4 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ptr<!fir.array<100xf32>>
+  return
+}
+
+// -----
+
+// Test `pointer(:) = array(:)`
+// ALL-LABEL: func @no_overlap1
+// OPT-NOT: fir.allocmem
+// NOOPT: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
+// NOOPT: fir.do_loop
+// NOOPT: fir.do_loop
+// NOOPT: fir.do_loop
+// NOOPT: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
+func.func @no_overlap1(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1 : !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) {
     %5 = fir.array_fetch %3, %arg2 : (!fir.array<100xf32>, index) -> f32
     %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
     fir.result %6 : !fir.array<100xf32>
   }
   fir.array_merge_store %2, %4 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ptr<!fir.array<100xf32>>
   return
 }
 
 // -----
 
 // Test `pointer(:) = pointer(:)`
-// CHECK-LABEL: func @no_overlap
-// CHECK-NOT: fir.allocmem
-// CHECK:     fir.do_loop
-// CHECK:       fir.array_coor
-// CHECK:       fir.array_coor
-// CHECK:       fir.store
+// ALL-LABEL: func @no_overlap
+// ALL-NOT: fir.allocmem
+// ALL:     fir.do_loop
+// ALL:       fir.array_coor
+// ALL:       fir.array_coor
+// ALL:       fir.store
 func.func @no_overlap(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %2) -> (!fir.array<100xf32>) {
     %4 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32
     %5 = fir.array_update %arg3, %4, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
     fir.result %5 : !fir.array<100xf32>
   }
   fir.array_merge_store %2, %3 to %arg0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ptr<!fir.array<100xf32>>
   return
 }
 
 // -----
 
 // Test `array(:) = pointer(:)`
-// TODO: array should have target attribute.
-// CHECK-LABEL: func @maybe_overlap_2
-// CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
-// CHECK: fir.do_loop
-// CHECK: fir.do_loop
-// CHECK: fir.do_loop
-// CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
-func.func @maybe_overlap_2(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
+// ALL-LABEL: func @maybe_overlap_2
+// ALL: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
+func.func @maybe_overlap_2(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>> {fir.target}) {
+  %c100 = arith.constant 100 : index
+  %c99 = arith.constant 99 : index
+  %c1 = arith.constant 1 : index
+  %c0 = arith.constant 0 : index
+  %0 = fir.alloca f32
+  %1 = fir.shape %c100 : (index) -> !fir.shape<1>
+  %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) {
+    %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32
+    %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
+    fir.result %6 : !fir.array<100xf32>
+  }
+  fir.array_merge_store %3, %4 to %arg1 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
+  return
+}
+
+// -----
+
+// Test `array(:) = pointer(:)`
+// ALL-LABEL: func @no_overlap_2
+// OPT-NOT: fir.allocmem
+// NOOPT: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
+// NOOPT: fir.do_loop
+// NOOPT: fir.do_loop
+// NOOPT: fir.do_loop
+// NOOPT: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
+func.func @no_overlap_2(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) {
     %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32
     %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
     fir.result %6 : !fir.array<100xf32>
   }
   fir.array_merge_store %3, %4 to %arg1 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
   return
 }
 
 // -----
 
 // Test `pointer1(:) = pointer2(:)`
-// CHECK-LABEL: func @maybe_overlap_3
-// CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
-// CHECK: fir.do_loop
-// CHECK: fir.do_loop
-// CHECK: fir.do_loop
-// CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
+// ALL-LABEL: func @maybe_overlap_3
+// ALL: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
 func.func @maybe_overlap_3(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ptr<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32
   %1 = fir.shape %c100 : (index) -> !fir.shape<1>
   %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %3 = fir.array_load %arg1(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
   %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) {
     %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32
     %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
     fir.result %6 : !fir.array<100xf32>
   }
   fir.array_merge_store %3, %4 to %arg1 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ptr<!fir.array<100xf32>>
   return
 }
 
 // -----
 
 // Test derived_target(:)%i = integer_pointer(:)
 // The integer pointer may be aliasing the derived target component.
-// CHECK-LABEL: func @derived_whose_component_may_be_aliased
-// CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<4x!fir.type<some_type{i:i32}>>
-// CHECK-COUNT-3: fir.do_loop
-// CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<4x!fir.type<some_type{i:i32}>>>
+// ALL-LABEL: func @derived_whose_component_may_be_aliased
+// ALL: %[[ALLOC:.*]] = fir.allocmem !fir.array<4x!fir.type<some_type{i:i32}>>
+// ALL-COUNT-3: fir.do_loop
+// ALL: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<4x!fir.type<some_type{i:i32}>>>
 func.func @derived_whose_component_may_be_aliased(%arg0: !fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>> {fir.target}, %arg1: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) {
   %c4 = arith.constant 4 : index
   %0 = fir.field_index i, !fir.type<some_type{i:i32}>
   %c1 = arith.constant 1 : index
   %1 = fir.slice %c1, %c4, %c1 path %0 : (index, index, index, !fir.field) -> !fir.slice<1>
   %2 = fir.array_load %arg0 [%1] : (!fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>>, !fir.slice<1>) -> !fir.array<4xi32>
   %3 = fir.load %arg1 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>
   %c0 = arith.constant 0 : index
func.func @derived_whose_component_may_be_aliased(%arg0: !fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>> {fir.target}, %arg1: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xi32>>>>) {
   fir.array_merge_store %2, %8 to %arg0[%1] : !fir.array<4xi32>, !fir.array<4xi32>, !fir.box<!fir.array<4x!fir.type<some_type{i:i32}>>>, !fir.slice<1>
   return
 }
 
 // -----
 
 // Test real_target = complex_target(:)%re
 // The real pointer may be aliasing the complex real part.
-// CHECK-LABEL: func @complex_real_aliasing
-// CHECK: %[[ALLOC:.*]] = fir.allocmem !fir.array<?xf32>
-// CHECK-COUNT-3: fir.do_loop
-// CHECK: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<?xf32>>
+// ALL-LABEL: func @complex_real_aliasing
+// ALL: %[[ALLOC:.*]] = fir.allocmem !fir.array<?xf32>
+// ALL-COUNT-3: fir.do_loop
+// ALL: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<?xf32>>
 func.func @complex_real_aliasing(%arg0: !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>, %arg1: !fir.ref<!fir.array<4x!fir.complex<4>>> {fir.target}) {
   %c4 = arith.constant 4 : index
   %0 = fir.load %arg0 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?xf32>>>>
   %c0 = arith.constant 0 : index
   %1:3 = fir.box_dims %0, %c0 : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, index) -> (index, index, index)
   %2 = fir.shift %1#0 : (index) -> !fir.shift<1>
   %3 = fir.array_load %0(%2) : (!fir.box<!fir.ptr<!fir.array<?xf32>>>, !fir.shift<1>) -> !fir.array<?xf32>
   %c0_i32 = arith.constant 0 : i32
   %4 = fir.shape %c4 : (index) -> !fir.shape<1>
   %c1 = arith.constant 1 : index
   %5 = fir.slice %c1, %c4, %c1 path %c0_i32 : (index, index, index, i32) -> !fir.slice<1>
   %6 = fir.array_load %arg1(%4) [%5] : (!fir.ref<!fir.array<4x!fir.complex<4>>>, !fir.shape<1>, !fir.slice<1>) -> !fir.array<4xf32>
   %7 = arith.subi %c4, %c1 : index
   %8 = fir.do_loop %arg2 = %c0 to %7 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<?xf32>) {
     %9 = fir.array_fetch %6, %arg2 : (!fir.array<4xf32>, index) -> f32
     %10 = fir.array_update %arg3, %9, %arg2 : (!fir.array<?xf32>, f32, index) -> !fir.array<?xf32>
     fir.result %10 : !fir.array<?xf32>
   }
   fir.array_merge_store %3, %8 to %0 : !fir.array<?xf32>, !fir.array<?xf32>, !fir.box<!fir.ptr<!fir.array<?xf32>>>
   return
 }
+
+// -----
+
+// Test `array(:) = pointer(:)`
+// ALL-LABEL: func @maybe_overlap_3
+// ALL: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.do_loop
+// ALL: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
+fir.global @_QMdataEglob target : !fir.array<100xf32> {
+  %0 = fir.undefined !fir.array<100xf32>
+  fir.has_value %0 : !fir.array<100xf32>
+}
+
+func.func @maybe_overlap_3(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>> {fir.target}) {
+  %c100 = arith.constant 100 : index
+  %c99 = arith.constant 99 : index
+  %c1 = arith.constant 1 : index
+  %c0 = arith.constant 0 : index
+  %0 = fir.address_of(@_QMdataEglob) : !fir.ref<!fir.array<100xf32>>
+  %1 = fir.shape %c100 : (index) -> !fir.shape<1>
+  %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %3 = fir.array_load %0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) {
+    %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32
+    %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
+    fir.result %6 : !fir.array<100xf32>
+  }
+  fir.array_merge_store %3, %4 to %0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
+  return
+}
+
+// -----
+
+// Test `array(:) = pointer(:)`
+// ALL-LABEL: func @no_overlap_3
+// OPT-NOT: fir.allocmem
+// NOOPT: %[[ALLOC:.*]] = fir.allocmem !fir.array<100xf32>
+// NOOPT: fir.do_loop
+// NOOPT: fir.do_loop
+// NOOPT: fir.do_loop
+// NOOPT: fir.freemem %[[ALLOC]] : !fir.heap<!fir.array<100xf32>>
+fir.global @_QMdataEglob : !fir.array<100xf32> {
+  %0 = fir.undefined !fir.array<100xf32>
+  fir.has_value %0 : !fir.array<100xf32>
+}
+
+func.func @no_overlap_3(%arg0: !fir.ptr<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>> {fir.target}) {
+  %c100 = arith.constant 100 : index
+  %c99 = arith.constant 99 : index
+  %c1 = arith.constant 1 : index
+  %c0 = arith.constant 0 : index
+  %0 = fir.address_of(@_QMdataEglob) : !fir.ref<!fir.array<100xf32>>
+  %1 = fir.shape %c100 : (index) -> !fir.shape<1>
+  %2 = fir.array_load %arg0(%1) : (!fir.ptr<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %3 = fir.array_load %0(%1) : (!fir.ref<!fir.array<100xf32>>, !fir.shape<1>) -> !fir.array<100xf32>
+  %4 = fir.do_loop %arg2 = %c0 to %c99 step %c1 unordered iter_args(%arg3 = %3) -> (!fir.array<100xf32>) {
+    %5 = fir.array_fetch %2, %arg2 : (!fir.array<100xf32>, index) -> f32
+    %6 = fir.array_update %arg3, %5, %arg2 : (!fir.array<100xf32>, f32, index) -> !fir.array<100xf32>
+    fir.result %6 : !fir.array<100xf32>
+  }
+  fir.array_merge_store %3, %4 to %0 : !fir.array<100xf32>, !fir.array<100xf32>, !fir.ref<!fir.array<100xf32>>
+  return
+}

flang/test/Fir/array-modify.fir

 // Test array-copy-value pass (copy elision) with fir.array_modify
 // RUN: fir-opt %s --array-value-copy | FileCheck %s
+// RUN: fir-opt %s --array-value-copy="optimize-conflicts=true" | FileCheck %s
 
 // Test user_defined_assignment(arg0(:), arg1(:))
 func.func @no_overlap(%arg0: !fir.ref<!fir.array<100xf32>>, %arg1: !fir.ref<!fir.array<100xf32>>) {
   %c100 = arith.constant 100 : index
   %c99 = arith.constant 99 : index
   %c1 = arith.constant 1 : index
   %c0 = arith.constant 0 : index
   %0 = fir.alloca f32

flang/test/Fir/array-value-copy-2.fir

 // RUN: fir-opt --array-value-copy --cfg-conversion %s | FileCheck %s
+// RUN: fir-opt --array-value-copy="optimize-conflicts=true" --cfg-conversion %s | FileCheck %s
 
 // CHECK-LABEL: func @_QPslice1(
 // CHECK-NOT: fir.allocmem
 // CHECK: ^bb{{[0-9]+}}(%{{[0-9]+}}: index,
 // CHECK-NOT: ^bb{{[0-9]+}}(%{{[0-9]+}}: index,
 // CHECK: return
 func.func @_QPslice1(%arg0: !fir.box<!fir.array<?xf32>>, %arg1: !fir.ref<i32>, %arg2: !fir.ref<i32>) {
   %c1_i64 = arith.constant 1 : i64

flang/test/Fir/array-value-copy-3.fir

 // Test overlapping assignment of derived type arrays with allocatable components.
 // This requires initializing the allocatable components to an unallocated status
 // before they can be used in component assignments, and to deallocate the components
 // that may have been allocated in the end.
 
 // RUN: fir-opt --array-value-copy %s | FileCheck %s
+// RUN: fir-opt --array-value-copy="optimize-conflicts=true" %s | FileCheck %s
 
 
 !t_with_alloc_comp = !fir.type<t{i:!fir.box<!fir.heap<!fir.array<?xi32>>>}>
 func.func private @custom_assign(!fir.ref<!t_with_alloc_comp>, !fir.ref<!t_with_alloc_comp>)
 func.func @test_overlap_with_alloc_components(%arg0: !fir.ref<!fir.array<10x!t_with_alloc_comp>>) {
   %0 = fir.alloca !fir.box<!t_with_alloc_comp>
   %c10 = arith.constant 10 : index
   %c9 = arith.constant 9 : index

flang/test/Fir/array-value-copy-4.fir

 // Test conversion of array_load with array of derived-type.
 // Conversion was previously crashing as reported in
 // https://github.com/llvm/llvm-project/issues/59342.
 
 // RUN: fir-opt --array-value-copy %s | FileCheck %s
+// RUN: fir-opt --array-value-copy="optimize-conflicts=true" %s | FileCheck %s
 
 func.func @_QMmodPsub1(%arg0: !fir.box<!fir.array<?x!fir.type<_QMmodTrec1{dat:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>> {fir.bindc_name = "x"}) {
   %0 = fir.alloca !fir.box<!fir.type<_QMmodTrec1{dat:!fir.box<!fir.heap<!fir.array<?xi32>>>}>>
   %c3_i64 = arith.constant 3 : i64
   %1 = fir.convert %c3_i64 : (i64) -> index
   %c1_i64 = arith.constant 1 : i64
   %2 = fir.convert %c1_i64 : (i64) -> index
   %c4_i64 = arith.constant 4 : i64

flang/test/Fir/array-value-copy-cam4.fir

+// RUN: fir-opt --array-value-copy %s | FileCheck --check-prefix=NOOPT %s
+// RUN: fir-opt --array-value-copy="optimize-conflicts=true" %s | FileCheck --check-prefix=OPT %s
+
+// Reproducer from SPEC CPU2017/527.cam4_r:
+// module cam4
+//   type, public :: pbuf_fld
+//      real*8, pointer, dimension(:,:,:,:,:) :: fld_ptr
+//   end type pbuf_fld
+// contains
+//   subroutine test(pbuf, ncol, lchnk, time_index, kvh_idx)
+//     implicit none
+//     interface
+//        subroutine init(kvh)
+//          real*8, intent(out) :: kvh(4,27)
+//        end subroutine init
+//     end interface
+//     type(pbuf_fld), intent(inout), dimension(1000) :: pbuf
+//     real*8 :: kvh(4,27)
+//     integer kvh_idx, ncol, lchnk, time_index
+//     call init(kvh)
+//     pbuf(kvh_idx)%fld_ptr(1,1:ncol,1:27,lchnk,time_index) = kvh(:ncol,:)
+//   end subroutine test
+// end module cam4
+
+// Verify that no memory is allocated for the temporary array,
+// when compiling with optimizations:
+// OPT-NOT: fir.allocmem
+// NOOPT: fir.allocmem
+
+module {
+  func.func @_QMcam4Ptest(%arg0: !fir.ref<!fir.array<1000x!fir.type<_QMcam4Tpbuf_fld{fld_ptr:!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>}>>> {fir.bindc_name = "pbuf"}, %arg1: !fir.ref<i32> {fir.bindc_name = "ncol"}, %arg2: !fir.ref<i32> {fir.bindc_name = "lchnk"}, %arg3: !fir.ref<i32> {fir.bindc_name = "time_index"}, %arg4: !fir.ref<i32> {fir.bindc_name = "kvh_idx"}) {
+    %c4 = arith.constant 4 : index
+    %c27 = arith.constant 27 : index
+    %0 = fir.alloca !fir.array<4x27xf64> {bindc_name = "kvh", uniq_name = "_QMcam4FtestEkvh"}
+    fir.call @_QPinit(%0) fastmath<contract> : (!fir.ref<!fir.array<4x27xf64>>) -> ()
+    %1 = fir.load %arg4 : !fir.ref<i32>
+    %2 = fir.convert %1 : (i32) -> i64
+    %c1_i64 = arith.constant 1 : i64
+    %3 = arith.subi %2, %c1_i64 : i64
+    %4 = fir.coordinate_of %arg0, %3 : (!fir.ref<!fir.array<1000x!fir.type<_QMcam4Tpbuf_fld{fld_ptr:!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>}>>>, i64) -> !fir.ref<!fir.type<_QMcam4Tpbuf_fld{fld_ptr:!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>}>>
+    %5 = fir.field_index fld_ptr, !fir.type<_QMcam4Tpbuf_fld{fld_ptr:!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>}>
+    %6 = fir.coordinate_of %4, %5 : (!fir.ref<!fir.type<_QMcam4Tpbuf_fld{fld_ptr:!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>}>>, !fir.field) -> !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>>
+    %7 = fir.load %6 : !fir.ref<!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>>
+    %c0 = arith.constant 0 : index
+    %8:3 = fir.box_dims %7, %c0 : (!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>, index) -> (index, index, index)
+    %c1 = arith.constant 1 : index
+    %9:3 = fir.box_dims %7, %c1 : (!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>, index) -> (index, index, index)
+    %c2 = arith.constant 2 : index
+    %10:3 = fir.box_dims %7, %c2 : (!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>, index) -> (index, index, index)
+    %c3 = arith.constant 3 : index
+    %11:3 = fir.box_dims %7, %c3 : (!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>, index) -> (index, index, index)
+    %12:3 = fir.box_dims %7, %c4 : (!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>, index) -> (index, index, index)
+    %13 = fir.undefined index
+    %14 = fir.convert %c1_i64 : (i64) -> index
+    %15 = arith.subi %14, %8#0 : index
+    %16 = fir.load %arg1 : !fir.ref<i32>
+    %17 = fir.convert %16 : (i32) -> i64
+    %18 = fir.convert %17 : (i64) -> index
+    %19 = arith.subi %18, %14 : index
+    %20 = arith.addi %19, %14 : index
+    %21 = arith.divsi %20, %14 : index
+    %22 = arith.cmpi sgt, %21, %c0 : index
+    %23 = arith.select %22, %21, %c0 : index
+    %c27_i64 = arith.constant 27 : i64
+    %24 = fir.convert %c27_i64 : (i64) -> index
+    %25 = arith.subi %24, %14 : index
+    %26 = arith.addi %25, %14 : index
+    %27 = arith.divsi %26, %14 : index
+    %28 = arith.cmpi sgt, %27, %c0 : index
+    %29 = arith.select %28, %27, %c0 : index
+    %30 = fir.load %arg2 : !fir.ref<i32>
+    %31 = fir.convert %30 : (i32) -> i64
+    %32 = fir.convert %31 : (i64) -> index
+    %33 = arith.subi %32, %11#0 : index
+    %34 = fir.load %arg3 : !fir.ref<i32>
+    %35 = fir.convert %34 : (i32) -> i64
+    %36 = fir.convert %35 : (i64) -> index
+    %37 = arith.subi %36, %12#0 : index
+    %38 = fir.shift %8#0, %9#0, %10#0, %11#0, %12#0 : (index, index, index, index, index) -> !fir.shift<5>
+    %39 = fir.slice %c1_i64, %13, %13, %14, %18, %14, %14, %24, %14, %31, %13, %13, %35, %13, %13 : (i64, index, index, index, index, index, index, index, index, i64, index, index, i64, index, index) -> !fir.slice<5>
+    %40 = fir.array_load %7(%38) [%39] : (!fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>, !fir.shift<5>, !fir.slice<5>) -> !fir.array<?x?x?x?x?xf64>
+    %41 = arith.addi %c1, %c27 : index
+    %42 = arith.subi %41, %c1 : index
+    %43 = fir.shape %c4, %c27 : (index, index) -> !fir.shape<2>
+    %44 = fir.slice %c1, %18, %14, %c1, %42, %14 : (index, index, index, index, index, index) -> !fir.slice<2>
+    %45 = fir.array_load %0(%43) [%44] : (!fir.ref<!fir.array<4x27xf64>>, !fir.shape<2>, !fir.slice<2>) -> !fir.array<4x27xf64>
+    %46 = arith.subi %23, %c1 : index
+    %47 = arith.subi %29, %c1 : index
+    %48 = fir.do_loop %arg5 = %c0 to %47 step %c1 unordered iter_args(%arg6 = %40) -> (!fir.array<?x?x?x?x?xf64>) {
+      %49 = fir.do_loop %arg7 = %c0 to %46 step %c1 unordered iter_args(%arg8 = %arg6) -> (!fir.array<?x?x?x?x?xf64>) {
+        %50 = fir.array_fetch %45, %arg7, %arg5 : (!fir.array<4x27xf64>, index, index) -> f64
+        %51 = fir.array_update %arg8, %50, %15, %arg7, %arg5, %33, %37 : (!fir.array<?x?x?x?x?xf64>, f64, index, index, index, index, index) -> !fir.array<?x?x?x?x?xf64>
+        fir.result %51 : !fir.array<?x?x?x?x?xf64>
+      }
+      fir.result %49 : !fir.array<?x?x?x?x?xf64>
+    }
+    fir.array_merge_store %40, %48 to %7[%39] : !fir.array<?x?x?x?x?xf64>, !fir.array<?x?x?x?x?xf64>, !fir.box<!fir.ptr<!fir.array<?x?x?x?x?xf64>>>, !fir.slice<5>
+    return
+  }
+  func.func private @_QPinit(!fir.ref<!fir.array<4x27xf64>>)
+  fir.dispatch_table @_QMcam4Tpbuf_fld
+}