[flang][HLFIR] add more memory effects interfaces

[tblah]

Summary

Anything that produces a hlfir.expr should have an allocation side
effect so that it is not removed by CSE (which would result in two
hlfir.destroy operations for the same expression). Similarly for
hlfir.associate, which has hlfir.end_associate.

I see no regressions from this change when running llvm-testsuite with
optimization enabled, or from SPEC2017 rate benchmarks.

To test this, I have added MLIR's pass for testing side effect
interfaces to fir-opt.

[tblah]

I'm posting this to start a discussion on what these memory effects should be. I'm more than happy to reduce the scope and some back to come trickier operations later.

[vzakhari]

Thank you for the changes! I think adding MemAlloc and MemFree is a good idea to make MLIR optimizations aware of the paired nature of some HLFIR operations.

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

352

Should this depend on the kind of the argument? For example, reporting MemRead for hlfir.expr argument seems imprecise.

606

I do not think we need to model MemRead for the hlfir.expr operand here.

[tblah]

• Made effects dependent upon argument and return types of transformational intrinsics (allocation effect if returning a hlfir.expr; read effect if an argument is a box or is pointer-like).
• Filled in tests

[jeanPerier]

Thank you! This looks great to me.
Long term, I would try replace hlfir.destroy by an analysis in bufferization that automatically finds when an hlfir.expr buffer must be freed so that we can optimize hlfir.expr more easily. This would allow the alloca side effects of hlfir.expr to be removed (CSE would be OK, and this would allow unused operations to be dropped by dead code elimination at the HLFIR level). But this is not on the hot list, so I like your approach to solve the CSE problem.

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

329

Can't DeclareOpInterfaceMethods<MemoryEffectsOpInterface> and getIntrinsicEffects

1007

I think a MemRead is needed for "temp" that may be read.

[tblah]

Thanks for review, and welcome back @jeanPerier!

Changes:

• Add tests for hlfir.{copy_in, copy_out}
• fix effects on hlfir.{copy_out, concat}

flang/include/flang/Optimizer/HLFIR/HLFIROps.td

def hlfir_ParentComponentOp : hlfir_Op<"parent_comp", [AttrSizedOperandSegments,
   let assemblyFormat = [{
     $memref (`shape` $shape^)? (`typeparams` $typeparams^)?
     attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
-def hlfir_ConcatOp : hlfir_Op<"concat", []> {
+def hlfir_ConcatOp : hlfir_Op<"concat",
+    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "concatenate characters";
   let description = [{
     Concatenate two or more character strings of a same character kind.
   }];
 
   let arguments = (ins Variadic<AnyScalarCharacterEntity>:$strings,
                    AnyIntegerType:$length);
 
   let results = (outs AnyScalarCharacterExpr);
 
   let assemblyFormat = [{
     $strings `len` $length
      attr-dict `:` functional-type(operands, results)
   }];
 
   let builders = [OpBuilder<(ins "mlir::ValueRange":$strings,"mlir::Value":$len)>];
 
   let hasVerifier = 1;
 }
 
-def hlfir_AllOp : hlfir_Op<"all", []> {
+def hlfir_AllOp : hlfir_Op<"all", [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "ALL transformational intrinsic";
   let description = [{
     Takes a logical array MASK as argument, optionally along a particular dimension,
     and returns true if all elements of MASK are true.
   }];
 
   let arguments = (ins
     AnyFortranLogicalArrayObject:$mask,
     Optional<AnyIntegerType>:$dim
   );
 
   let results = (outs AnyFortranValue);
 
   let assemblyFormat = [{
     $mask  (`dim` $dim^)?  attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
-def hlfir_AnyOp : hlfir_Op<"any", []> {
+def hlfir_AnyOp : hlfir_Op<"any", [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "ANY transformational intrinsic";
   let description = [{
     Takes a logical array MASK as argument, optionally along a particular dimension,
     and returns true if any element of MASK is true.
   }];
 
   let arguments = (ins
     AnyFortranLogicalArrayObject:$mask,
     Optional<AnyIntegerType>:$dim
   );
 
   let results = (outs AnyFortranValue);
 
   let assemblyFormat = [{
     $mask  (`dim` $dim^)?  attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
-def hlfir_CountOp : hlfir_Op<"count", [AttrSizedOperandSegments]> {
+def hlfir_CountOp : hlfir_Op<"count", [AttrSizedOperandSegments, DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "COUNT transformational intrinsic";
   let description = [{
     Takes a logical and counts the number of true values.
   }];
 
   let arguments = (ins
     AnyFortranLogicalArrayObject:$mask,
     Optional<AnyIntegerType>:$dim,
     Optional<AnyIntegerType>:$kind
   );
 
   let results = (outs AnyFortranValue);
 
   let assemblyFormat = [{
     $mask  (`dim` $dim^)? (`kind` $kind^)?  attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
-
 def hlfir_ProductOp : hlfir_Op<"product", [AttrSizedOperandSegments,
-    DeclareOpInterfaceMethods<ArithFastMathInterface>]> {
+    DeclareOpInterfaceMethods<ArithFastMathInterface>,
+    DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "PRODUCT transformational intrinsic";
   let description = [{
     Multiplies the elements of an array, optionally along a particular dimension,
     optionally if a mask is true.
   }];
 
   let arguments = (ins
     AnyFortranNumericalArrayObject:$array,
     Optional<AnyIntegerType>:$dim,
     Optional<AnyFortranLogicalOrI1ArrayObject>:$mask,
     DefaultValuedAttr<Arith_FastMathAttr,
                       "::mlir::arith::FastMathFlags::none">:$fastmath
   );
 
   let results = (outs AnyFortranValue);
 
   let assemblyFormat = [{
     $array (`dim` $dim^)? (`mask` $mask^)? attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
-def hlfir_SetLengthOp : hlfir_Op<"set_length", []> {
+def hlfir_SetLengthOp : hlfir_Op<"set_length",
+  [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "change the length of a character entity";
   let description = [{
     Change the length of character entity. This trims or pads the
     character argument according to the new length.
   }];
 
   let arguments = (ins AnyScalarCharacterEntity:$string,
                    AnyIntegerType:$length);
def hlfir_GetLengthOp : hlfir_Op<"get_length", [Pure]> {
   }];
 
   // If character length is know via the type, then the operation
   // may be immediately canonicalized into arith::ConstantOp.
   let hasCanonicalizeMethod = 1;
 }
 
 def hlfir_SumOp : hlfir_Op<"sum", [AttrSizedOperandSegments,
-    DeclareOpInterfaceMethods<ArithFastMathInterface>]> {
+    DeclareOpInterfaceMethods<ArithFastMathInterface>,
+    DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "SUM transformational intrinsic";
   let description = [{
     Sums the elements of an array, optionally along a particular dimension,
     optionally if a mask is true.
   }];
 
   let arguments = (ins
     AnyFortranNumericalArrayObject:$array,
     Optional<AnyIntegerType>:$dim,
     Optional<AnyFortranLogicalOrI1ArrayObject>:$mask,
     DefaultValuedAttr<Arith_FastMathAttr,
                       "::mlir::arith::FastMathFlags::none">:$fastmath
   );
 
   let results = (outs AnyFortranValue);
 
   let assemblyFormat = [{
     $array (`dim` $dim^)? (`mask` $mask^)? attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
 def hlfir_DotProductOp : hlfir_Op<"dot_product",
-    [DeclareOpInterfaceMethods<ArithFastMathInterface>]> {
+    [DeclareOpInterfaceMethods<ArithFastMathInterface>,
+    DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "DOT_PRODUCT transformational intrinsic";
   let description = [{
     Dot product of two vectors
   }];
 
   let arguments = (ins
     AnyFortranNumericalOrLogicalArrayObject:$lhs,
     AnyFortranNumericalOrLogicalArrayObject:$rhs,
     DefaultValuedAttr<Arith_FastMathAttr,
                       "::mlir::arith::FastMathFlags::none">:$fastmath
   );
 
   let results = (outs AnyFortranValue);
 
   let assemblyFormat = [{
     $lhs $rhs attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
 def hlfir_MatmulOp : hlfir_Op<"matmul",
-    [DeclareOpInterfaceMethods<ArithFastMathInterface>]> {
+    [DeclareOpInterfaceMethods<ArithFastMathInterface>,
+    DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "MATMUL transformational intrinsic";
   let description = [{
     Matrix multiplication
   }];
 
   let arguments = (ins
     AnyFortranNumericalOrLogicalArrayObject:$lhs,
     AnyFortranNumericalOrLogicalArrayObject:$rhs,
     DefaultValuedAttr<Arith_FastMathAttr,
                       "::mlir::arith::FastMathFlags::none">:$fastmath
   );
 
   let results = (outs hlfir_ExprType);
 
   let assemblyFormat = [{
     $lhs $rhs attr-dict `:` functional-type(operands, results)
   }];
 
   // MATMUL(TRANSPOSE(...), ...) => hlfir.matmul_transpose
   let hasCanonicalizeMethod = 1;
 
   let hasVerifier = 1;
 }
 
-def hlfir_TransposeOp : hlfir_Op<"transpose", []> {
+def hlfir_TransposeOp : hlfir_Op<"transpose",
+    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "TRANSPOSE transformational intrinsic";
   let description = [{
     Transpose a rank 2 array
   }];
 
   let arguments = (ins AnyFortranArrayObject:$array);
 
   let results = (outs hlfir_ExprType);
 
   let assemblyFormat = [{
     $array attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
 def hlfir_MatmulTransposeOp : hlfir_Op<"matmul_transpose",
-    [DeclareOpInterfaceMethods<ArithFastMathInterface>]> {
+    [DeclareOpInterfaceMethods<ArithFastMathInterface>,
+    DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "Optimized MATMUL(TRANSPOSE(...), ...)";
   let description = [{
     Matrix multiplication where the left hand side is transposed
   }];
 
   let arguments = (ins
     AnyFortranNumericalOrLogicalArrayObject:$lhs,
     AnyFortranNumericalOrLogicalArrayObject:$rhs,
     DefaultValuedAttr<Arith_FastMathAttr,
                       "::mlir::arith::FastMathFlags::none">:$fastmath
   );
 
   let results = (outs hlfir_ExprType);
 
   let assemblyFormat = [{
     $lhs $rhs attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 }
 
+// An allocation effect is needed because the value produced by the associate
+// is "deallocated" by hlfir.end_associate (the end_associate must not be
+// removed, and there must be only one hlfir.end_associate).
 def hlfir_AssociateOp : hlfir_Op<"associate", [AttrSizedOperandSegments,
-    DeclareOpInterfaceMethods<fir_FortranVariableOpInterface>]> {
+    DeclareOpInterfaceMethods<fir_FortranVariableOpInterface>,
+    MemoryEffects<[MemAlloc]>]> {
   let summary = "Create a variable from an expression value";
   let description = [{
     Create a variable from an expression value.
     For expressions, this operation is an incentive to re-use the expression
     storage, if any, after the bufferization pass when possible (if the
     expression is not used afterwards).
   }];
 
   let arguments = (ins
     AnyFortranValue:$source,
     Optional<AnyShapeOrShiftType>:$shape,
     Variadic<AnyIntegerType>:$typeparams,
     Builtin_StringAttr:$uniq_name,
     OptionalAttr<fir_FortranVariableFlagsAttr>:$fortran_attrs
   );
 
   let results = (outs AnyFortranVariable, AnyRefOrBoxLike, I1);
 
let extraClassDeclaration = [{
     /// was allocated on the heap. At the HLFIR level, this may not be
     /// known yet, and lowering will need to conditionally free the storage.
     mlir::Value getMustFreeStrorageFlag() {
       return getResult(2);
     }
   }];
 }
 
-def hlfir_EndAssociateOp : hlfir_Op<"end_associate", []> {
+def hlfir_EndAssociateOp : hlfir_Op<"end_associate", [MemoryEffects<[MemFree]>]> {
   let summary = "Mark the end of life of a variable associated to an expression";
 
   let description = [{
     Mark the end of life of a variable associated to an expression.
   }];
 
   let arguments = (ins AnyRefOrBoxLike:$var,
                    I1:$must_free);
 
   let assemblyFormat = [{
     $var `,` $must_free attr-dict `:` type(operands)
   }];
 
   let builders = [OpBuilder<(ins "hlfir::AssociateOp":$associate)>];
 }
 
-def hlfir_AsExprOp : hlfir_Op<"as_expr", []> {
+def hlfir_AsExprOp : hlfir_Op<"as_expr",
+    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "Take the value of an array, character or derived variable";
 
   let description = [{
     Take the value of an array, character or derived variable.
     In general, this operation will lead to a copy of the variable
     in the bufferization pass if it was not transformed.
 
     However, if it is known that the variable storage will not be used anymore
let description = [{
     in bufferization instead.
   }];
 
   let arguments = (ins hlfir_ExprType:$expr);
 
   let assemblyFormat = "$expr attr-dict `:` qualified(type($expr))";
 }
 
-def hlfir_CopyInOp : hlfir_Op<"copy_in", []> {
+def hlfir_CopyInOp : hlfir_Op<"copy_in", [MemoryEffects<[MemAlloc]>]> {
   let summary = "copy a variable into a contiguous temporary if it is not contiguous";
   let description = [{
     Copy a variable into a contiguous temporary if the variable is not
     an absent optional and is not contiguous at runtime. When a copy is made this
     operation returns the temporary as first result, otherwise, it returns the
     potentially absent variable storage. The second result indicates if a copy
     was made.
 
     This operation is meant to be used in combination with the hlfir.copy_out
     operation that deletes the temporary if it was created and copies the data
     back if needed.
     This operation allows passing non contiguous arrays to contiguous dummy
     arguments, which is possible in Fortran procedure references.
 
     To deal with the optional case, an extra boolean value can be pass to the
     operation. In such cases, the copy-in will only be done if "var_is_present"
     is true and, when it is false, the original value will be returned instead.
   }];
 
-  let arguments = (ins fir_BaseBoxType:$var,
+  let arguments = (ins Arg<fir_BaseBoxType, "", [MemRead]>:$var,
                    Optional<I1>:$var_is_present);
 
   let results = (outs fir_BaseBoxType, I1);
 
   let assemblyFormat = [{
     $var (`handle_optional` $var_is_present^)?
     attr-dict `:` functional-type(operands, results)
   }];
let extraClassDeclaration = [{
 
     /// Get the result indicating if a copy was made.
     mlir::Value getWasCopied() {
       return getResult(1);
     }
   }];
 }
 
-def hlfir_CopyOutOp : hlfir_Op<"copy_out", []> {
+def hlfir_CopyOutOp : hlfir_Op<"copy_out", [MemoryEffects<[MemFree]>]> {
   let summary = "copy out a variable after a copy in";
   let description = [{
     If the variable was copied in a temporary in the related hlfir.copy_in,
     optionally copy back the temporary value to it (that may have been
     modified between the hlfir.copy_in and hlfir.copy_out). Then deallocate
     the temporary.
     The copy back is done if $var is provided and $was_copied is true.
     The deallocation of $temp is done if $was_copied is true.
   }];
 
-  let arguments = (ins fir_BaseBoxType:$temp,
+  let arguments = (ins Arg<fir_BaseBoxType, "", [MemRead]>:$temp,
                        I1:$was_copied,
-                       Optional<fir_BaseBoxType>:$var);
+                       Arg<Optional<fir_BaseBoxType>, "", [MemWrite]>:$var);
 
   let assemblyFormat = [{
     $temp `,` $was_copied (`to` $var^)?
     attr-dict `:` functional-type(operands, results)
   }];
 }
 
 def hlfir_ShapeOfOp : hlfir_Op<"shape_of", [Pure]> {
let extraClassDeclaration = [{
     /// Implement OrderedAssignmentTreeOpInterface interface.
     void getLeafRegions(llvm::SmallVectorImpl<mlir::Region*>& regions) {}
     mlir::Region* getSubTreeRegion() { return nullptr; }
   }];
 
   let hasCanonicalizeMethod = 1;
 }
 
-def hlfir_CharExtremumOp : hlfir_Op<"char_extremum", []> {
+def hlfir_CharExtremumOp : hlfir_Op<"char_extremum",
+    [DeclareOpInterfaceMethods<MemoryEffectsOpInterface>]> {
   let summary = "Find max/min from given character strings";
   let description = [{
     Find the lexicographical minimum or maximum of two or more character 
     strings of the same character kind and return the string with the lexicographical 
     minimum or maximum number of characters. Example:
 
     %0 = hlfir.char_extremum min, %arg0, %arg1 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,10>>
   }];

flang/lib/Optimizer/HLFIR/IR/HLFIROps.cpp

 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpImplementation.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include <iterator>
+#include <mlir/Interfaces/SideEffectInterfaces.h>
 #include <optional>
 #include <tuple>
 
+/// generic implementation of the memory side effects interface for hlfir
+/// transformational intrinsic operations
+static void
+getIntrinsicEffects(mlir::Operation *self,
+                    llvm::SmallVectorImpl<mlir::SideEffects::EffectInstance<
+                        mlir::MemoryEffects::Effect>> &effects) {
+  // allocation effect if we return an expr
+  assert(self->getNumResults() == 1 &&
+         "hlfir intrinsic ops only produce 1 result");
+  if (mlir::isa<hlfir::ExprType>(self->getResult(0).getType()))
+    effects.emplace_back(mlir::MemoryEffects::Allocate::get(),
+                         self->getResult(0),
+                         mlir::SideEffects::DefaultResource::get());
+
+  // read effect if we read from a pointer or refference type
+  // or a box who'se pointer is read from inside of the intrinsic so that
+  // loop conflicts can be detected in code like
+  // hlfir.region_assign {
+  //   %2 = hlfir.transpose %0#0 : (!fir.box<!fir.array<?x?xf32>>) ->
+  //   !hlfir.expr<?x?xf32> hlfir.yield %2 : !hlfir.expr<?x?xf32> cleanup {
+  //     hlfir.destroy %2 : !hlfir.expr<?x?xf32>
+  //   }
+  // } to {
+  //   hlfir.yield %0#0 : !fir.box<!fir.array<?x?xf32>>
+  // }
+  for (mlir::Value operand : self->getOperands()) {
+    mlir::Type opTy = operand.getType();
+    if (fir::isa_ref_type(opTy) || fir::isa_box_type(opTy))
+      effects.emplace_back(mlir::MemoryEffects::Read::get(), operand,
+                           mlir::SideEffects::DefaultResource::get());
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // DeclareOp
 //===----------------------------------------------------------------------===//
 
 /// Is this a fir.[ref/ptr/heap]<fir.[box/class]<fir.heap<T>>> type?
 static bool isAllocatableBoxRef(mlir::Type type) {
   fir::BaseBoxType boxType =
       fir::dyn_cast_ptrEleTy(type).dyn_cast_or_null<fir::BaseBoxType>();

 //===----------------------------------------------------------------------===//
 // AllOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::AllOp::verify() {
   return verifyLogicalReductionOp<hlfir::AllOp *>(this);
 }
 
+void hlfir::AllOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // AnyOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::AnyOp::verify() {
   return verifyLogicalReductionOp<hlfir::AnyOp *>(this);
 }
 
+void hlfir::AnyOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // CountOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::CountOp::verify() {
   mlir::Operation *op = getOperation();
 
   auto results = op->getResultTypes();
if (auto resultExpr = mlir::dyn_cast_or_null<hlfir::ExprType>(resultType)) {
     }
   } else if (!hlfir::isFortranScalarNumericalType(resultType)) {
     return emitOpError("result must be of numerical scalar type");
   }
 
   return mlir::success();
 }
 
+void hlfir::CountOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // ConcatOp
 //===----------------------------------------------------------------------===//
 
 static unsigned getCharacterKind(mlir::Type t) {
   return hlfir::getFortranElementType(t).cast<fir::CharacterType>().getFKind();
 }
 
for (auto string : strings)
     }
   auto resultType = hlfir::ExprType::get(
       builder.getContext(), hlfir::ExprType::Shape{},
       fir::CharacterType::get(builder.getContext(), kind, resultTypeLen),
       false);
   build(builder, result, resultType, strings, len);
 }
 
+void hlfir::ConcatOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // NumericalReductionOp
 //===----------------------------------------------------------------------===//
 
 template <typename NumericalReductionOp>
 static mlir::LogicalResult
 verifyNumericalReductionOp(NumericalReductionOp reductionOp) {
   mlir::Operation *op = reductionOp->getOperation();

 //===----------------------------------------------------------------------===//
 // ProductOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::ProductOp::verify() {
   return verifyNumericalReductionOp<hlfir::ProductOp *>(this);
 }
 
+void hlfir::ProductOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // SetLengthOp
 //===----------------------------------------------------------------------===//
 
 void hlfir::SetLengthOp::build(mlir::OpBuilder &builder,
                                mlir::OperationState &result, mlir::Value string,
                                mlir::Value len) {
   fir::CharacterType::LenType resultTypeLen = fir::CharacterType::unknownLen();
   if (auto cstLen = fir::getIntIfConstant(len))
     resultTypeLen = *cstLen;
   unsigned kind = getCharacterKind(string.getType());
   auto resultType = hlfir::ExprType::get(
       builder.getContext(), hlfir::ExprType::Shape{},
       fir::CharacterType::get(builder.getContext(), kind, resultTypeLen),
       false);
   build(builder, result, resultType, string, len);
 }
 
+void hlfir::SetLengthOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // SumOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::SumOp::verify() {
   return verifyNumericalReductionOp<hlfir::SumOp *>(this);
 }
 
+void hlfir::SumOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // DotProductOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::DotProductOp::verify() {
   mlir::Value lhs = getLhs();
   mlir::Value rhs = getRhs();
   fir::SequenceType lhsTy =
mlir::LogicalResult hlfir::DotProductOp::verify() {
   if (!hlfir::isFortranScalarNumericalType(resultTy) &&
       !mlir::isa<fir::LogicalType>(resultTy))
     return emitOpError(
         "the result must be of scalar numerical or logical type");
 
   return mlir::success();
 }
 
+void hlfir::DotProductOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // MatmulOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::MatmulOp::verify() {
   mlir::Value lhs = getLhs();
   mlir::Value rhs = getRhs();
   fir::SequenceType lhsTy =
if (isOtherwiseUnused(transposeOp)) {
 
       return mlir::success();
     }
   }
 
   return mlir::failure();
 }
 
+void hlfir::MatmulOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::TransposeOp::verify() {
   mlir::Value array = getArray();
   fir::SequenceType arrayTy =
       hlfir::getFortranElementOrSequenceType(array.getType())
mlir::LogicalResult hlfir::TransposeOp::verify() {
 
   if (eleTy != resultEleTy)
     return emitOpError(
         "input and output arrays should have the same element type");
 
   return mlir::success();
 }
 
+void hlfir::TransposeOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // MatmulTransposeOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult hlfir::MatmulTransposeOp::verify() {
   mlir::Value lhs = getLhs();
   mlir::Value rhs = getRhs();
   fir::SequenceType lhsTy =
mlir::LogicalResult hlfir::MatmulTransposeOp::verify() {
   if (resultShape[0] != expectedResultShape[0])
     return emitOpError("incorrect result shape");
   if (resultShape.size() == 2 && resultShape[1] != expectedResultShape[1])
     return emitOpError("incorrect result shape");
 
   return mlir::success();
 }
 
+void hlfir::MatmulTransposeOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // AssociateOp
 //===----------------------------------------------------------------------===//
 
 void hlfir::AssociateOp::build(mlir::OpBuilder &builder,
                                mlir::OperationState &result, mlir::Value source,
                                llvm::StringRef uniq_name, mlir::Value shape,
                                mlir::ValueRange typeparams,
if (auto seqType = type.dyn_cast<fir::SequenceType>()) {
     type = seqType.getEleTy();
   }
 
   auto resultType = hlfir::ExprType::get(builder.getContext(), typeShape, type,
                                          isPolymorphic);
   return build(builder, result, resultType, var, mustFree);
 }
 
+void hlfir::AsExprOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  // this isn't a transformational intrinsic but follows the same pattern: it
+  // creates a hlfir.expr and so needs to have an allocation effect, plus it
+  // might have a pointer-like argument, in which case it has a read effect
+  // upon those
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // ElementalOp
 //===----------------------------------------------------------------------===//
 
 void hlfir::ElementalOp::build(mlir::OpBuilder &builder,
                                mlir::OperationState &odsState,
                                mlir::Type resultType, mlir::Value shape,
                                mlir::Value mold, mlir::ValueRange typeparams,
void hlfir::CharExtremumOp::build(mlir::OpBuilder &builder,
   auto resultType = hlfir::ExprType::get(
       builder.getContext(), hlfir::ExprType::Shape{},
       fir::CharacterType::get(builder.getContext(), kind, resultTypeLen),
       false);
 
   build(builder, result, resultType, predicate, strings);
 }
 
+void hlfir::CharExtremumOp::getEffects(
+    llvm::SmallVectorImpl<
+        mlir::SideEffects::EffectInstance<mlir::MemoryEffects::Effect>>
+        &effects) {
+  getIntrinsicEffects(getOperation(), effects);
+}
+
 //===----------------------------------------------------------------------===//
 // GetLength
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult
 hlfir::GetLengthOp::canonicalize(GetLengthOp getLength,
                                  mlir::PatternRewriter &rewriter) {
   mlir::Location loc = getLength.getLoc();

flang/test/HLFIR/memory-effects.fir

+// RUN: fir-opt %s --test-side-effects --verify-diagnostics
+
+func.func @concat(%arg0: !fir.ref<!fir.char<1,10>>, %arg1: !fir.ref<!fir.char<1, 20>>) {
+// expected-remark@+1 {{operation has no memory effects}}
+  %c30 = arith.constant 30 : index
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.concat %arg0, %arg1 len %c30 : (!fir.ref<!fir.char<1,10>>, !fir.ref<!fir.char<1,20>>, index) -> (!hlfir.expr<!fir.char<1,30>>)
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @all_no_effects(%arg0: !hlfir.expr<2x!fir.logical<4>>) {
+// expected-remark@+1 {{operation has no memory effects}}
+  %all = hlfir.all %arg0 : (!hlfir.expr<2x!fir.logical<4>>) -> !fir.logical<4>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @all_effects(%arg0: !fir.ref<!fir.array<2x10x!fir.logical<4>>>, %arg1: i32) {
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %all = hlfir.all %arg0 dim %arg1 : (!fir.ref<!fir.array<2x10x!fir.logical<4>>>, i32) -> !hlfir.expr<?x!fir.logical<4>>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @any_no_effects(%arg0: !hlfir.expr<2x!fir.logical<4>>) {
+// expected-remark@+1 {{operation has no memory effects}}
+  %all = hlfir.any %arg0 : (!hlfir.expr<2x!fir.logical<4>>) -> !fir.logical<4>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @any_effects(%arg0: !fir.ref<!fir.array<2x10x!fir.logical<4>>>, %arg1: i32) {
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %all = hlfir.any %arg0 dim %arg1 : (!fir.ref<!fir.array<2x10x!fir.logical<4>>>, i32) -> !hlfir.expr<?x!fir.logical<4>>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @count_no_effects(%arg0: !hlfir.expr<2x!fir.logical<4>>) {
+// expected-remark@+1 {{operation has no memory effects}}
+  %all = hlfir.count %arg0 : (!hlfir.expr<2x!fir.logical<4>>) -> i32
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @count_effects(%arg0: !fir.ref<!fir.array<2x10x!fir.logical<4>>>, %arg1: i32) {
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %all = hlfir.count %arg0 dim %arg1 : (!fir.ref<!fir.array<2x10x!fir.logical<4>>>, i32) -> i32
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @product_no_effects(%arg0: !hlfir.expr<?xf32>) {
+// expected-remark@+1 {{operation has no memory effects}}
+  %product = hlfir.product %arg0 : (!hlfir.expr<?xf32>) -> f32
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @product_effects(%arg0: !fir.ref<!fir.array<2x2xf32>>, %arg1: i32) {
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %product = hlfir.product %arg0 dim %arg1 : (!fir.ref<!fir.array<2x2xf32>>, i32) -> !hlfir.expr<2xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @set_length_read(%arg0: !fir.ref<!fir.char<1,10>>, %arg1: index) {
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.set_length %arg0 len %arg1 : (!fir.ref<!fir.char<1,10>>, index) -> !hlfir.expr<!fir.char<1,?>>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @sum_no_effects(%arg0: !hlfir.expr<?xf32>) {
+// expected-remark@+1 {{operation has no memory effects}}
+  %sum = hlfir.sum %arg0 : (!hlfir.expr<?xf32>) -> f32
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @sum_effects(%arg0: !fir.ref<!fir.array<2x2xf32>>, %arg1: i32) {
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %sum = hlfir.sum %arg0 dim %arg1 : (!fir.ref<!fir.array<2x2xf32>>, i32) -> !hlfir.expr<2xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @dot_product_no_effects(%arg0: !hlfir.expr<?xf32>, %arg1: !hlfir.expr<?xf32>) {
+// expected-remark@+1 {{operation has no memory effects}}
+  %0 = hlfir.dot_product %arg0 %arg1 : (!hlfir.expr<?xf32>, !hlfir.expr<?xf32>) -> f32
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @dot_product_effects(%arg0: !fir.ref<!fir.array<10xf32>>, %arg1: !fir.ref<!fir.array<10xf32>>) {
+// there are read effects on both arguments - the diagnostic verification just doesn't register duplicate identical diagnostics
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.dot_product %arg0 %arg1 : (!fir.ref<!fir.array<10xf32>>, !fir.ref<!fir.array<10xf32>>) -> f32
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @matmul_no_reads(%arg0: !hlfir.expr<?x?xf32>, %arg1: !hlfir.expr<?x?xf32>) {
+// expected-remark@+1 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+  %0 = hlfir.matmul %arg0 %arg1 : (!hlfir.expr<?x?xf32>, !hlfir.expr<?x?xf32>) -> !hlfir.expr<?x?xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @matmul_reads(%arg0: !fir.ref<!fir.array<10x5xf32>>, %arg1: !fir.ref<!fir.array<5x10xf32>>) {
+// expected-remark@+3 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// there are read effects on both arguments - the diagnostic verification just doesn't register duplicate identical diagnostics
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.matmul %arg0 %arg1 : (!fir.ref<!fir.array<10x5xf32>>, !fir.ref<!fir.array<5x10xf32>>) -> !hlfir.expr<10x10xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @transpose_no_reads(%arg0: !hlfir.expr<?x?xf32>) {
+// expected-remark@+1 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+  %0 = hlfir.transpose %arg0 : (!hlfir.expr<?x?xf32>) -> !hlfir.expr<?x?xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @transpose_read(%arg0: !fir.ref<!fir.array<10x5xf32>>) {
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.transpose %arg0 : (!fir.ref<!fir.array<10x5xf32>>) -> !hlfir.expr<5x10xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @matmul_transpose_no_reads(%arg0: !hlfir.expr<?x?xf32>, %arg1: !hlfir.expr<?x?xf32>) {
+// expected-remark@+1 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+  %0 = hlfir.matmul_transpose %arg0 %arg1 : (!hlfir.expr<?x?xf32>, !hlfir.expr<?x?xf32>) -> !hlfir.expr<?x?xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @matmul_transpose_reads(%arg0: !fir.ref<!fir.array<5x10xf32>>, %arg1: !fir.ref<!fir.array<5x10xf32>>) {
+// expected-remark@+3 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// there are read effects on both arguments - the diagnostic verification just doesn't register duplicate identical diagnostics
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.matmul_transpose %arg0 %arg1 : (!fir.ref<!fir.array<5x10xf32>>, !fir.ref<!fir.array<5x10xf32>>) -> !hlfir.expr<10x10xf32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @associate(%arg0: i32) {
+// expected-remark@+1 {{found an instance of 'allocate' on resource '<Default>'}}
+  %0:3 = hlfir.associate %arg0 {uniq_name = "x"} : (i32) -> (!fir.ref<i32>, !fir.ref<i32>, i1)
+// expected-remark@+1 {{found an instance of 'free' on resource '<Default>'}}
+  hlfir.end_associate %0#1, %0#2 : !fir.ref<i32>, i1
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @as_expr_read(%arg0: !fir.ref<!fir.array<2xi32>>) {
+// expected-remark@+2 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.as_expr %arg0 : (!fir.ref<!fir.array<2xi32>>) -> !hlfir.expr<?xi32>
+// expected-remark@+1 {{found an instance of 'free' on resource '<Default>'}}
+  hlfir.destroy %0 : !hlfir.expr<?xi32>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @char_extremum(%arg0: !fir.ref<!fir.char<1,10>>, %arg1: !fir.ref<!fir.char<1,20>>) {
+// expected-remark@+3 {{found an instance of 'allocate' on a value, on resource '<Default>'}}
+// there are read effects on both arguments - the diagnostic verification just doesn't register duplicate identical diagnostics
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0 = hlfir.char_extremum min, %arg0, %arg1 : (!fir.ref<!fir.char<1, 10>>, !fir.ref<!fir.char<1,20>>) -> !hlfir.expr<!fir.char<1,10>>
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @copy_in(%box: !fir.box<!fir.array<?xf64>>, %is_present: i1) {
+// expected-remark@+2 {{found an instance of 'allocate' on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  %0:2 = hlfir.copy_in %box : (!fir.box<!fir.array<?xf64>>) -> (!fir.box<!fir.array<?xf64>>, i1)
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}
+
+func.func @copy_out(%box: !fir.box<!fir.array<?xf64>>, %temp: !fir.box<!fir.array<?xf64>>, %was_copied: i1) {
+// expected-remark@+2 {{found an instance of 'free' on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'read' on a value, on resource '<Default>'}}
+  hlfir.copy_out %temp, %was_copied : (!fir.box<!fir.array<?xf64>>, i1) -> ()
+// expected-remark@+3 {{found an instance of 'free' on resource '<Default>'}}
+// expected-remark@+2 {{found an instance of 'read' on a value, on resource '<Default>'}}
+// expected-remark@+1 {{found an instance of 'write' on a value, on resource '<Default>'}}
+  hlfir.copy_out %temp, %was_copied to %box : (!fir.box<!fir.array<?xf64>>, i1, !fir.box<!fir.array<?xf64>>) -> ()
+// expected-remark@+1 {{operation has no memory effects}}
+  return
+}

flang/test/HLFIR/order_assignments/where-scheduling.f90

 !CHECK-NEXT: run 1 save    : where/mask
 !CHECK-NEXT: run 2 evaluate: where/region_assign1
 !CHECK-LABEL: ------------ scheduling where in _QPonly_once ------------
 !CHECK-NEXT: unknown effect: %9 = fir.call @llvm.stacksave.p0() fastmath<contract> : () -> !fir.ref<i8>
 !CHECK-NEXT: run 1 save  (w): where/mask
 !CHECK-NEXT: run 2 evaluate: where/region_assign1
 !CHECK-NEXT: run 3 evaluate: where/region_assign2
 !CHECK-LABEL: ------------ scheduling where in _QPrhs_lhs_conflict ------------
-!CHECK-NEXT: unknown effect: %{{.*}} = hlfir.transpose %{{.*}} : (!fir.box<!fir.array<?x?xf32>>) -> !hlfir.expr<?x?xf32>
-!CHECK-NEXT: conflict: R/W: %6 = hlfir.designate %{{.*}} (%{{.*}}, %{{.*}})  : (!fir.box<!fir.array<?x?xf32>>, index, index) -> !fir.ref<f32> W:<unknown>
-!CHECK-NEXT: run 1 save    : where/mask
-!CHECK-NEXT: unknown effect: %{{.*}} = hlfir.transpose %{{.*}} : (!fir.box<!fir.array<?x?xf32>>) -> !hlfir.expr<?x?xf32>
-!CHECK-NEXT: run 2 save  (w): where/region_assign1/rhs
-!CHECK-NEXT: run 3 evaluate: where/region_assign1
+!CHECK-NEXT: conflict: R/W: <block argument> of type '!fir.box<!fir.array<?x?xf32>>' at index: 0 W:<block argument> of type '!fir.box<!fir.array<?x?xf32>>' at index: 0
+!CHECK-NEXT: run 1 save    : where/region_assign1/rhs
+!CHECK-NEXT: run 2 evaluate: where/region_assign1
 !CHECK-LABEL: ------------ scheduling where in _QPwhere_construct_no_conflict ------------
 !CHECK-NEXT: run 1 evaluate: where/region_assign1
 !CHECK-NEXT: run 2 evaluate: where/elsewhere1/region_assign1
 !CHECK-LABEL: ------------ scheduling where in _QPwhere_construct_conflict ------------
 !CHECK-NEXT: run 1 evaluate: where/region_assign1
 !CHECK-NEXT: conflict: R/W: <block argument> of type '!fir.box<!fir.array<?x?xf32>>' at index: 1 W:<block argument> of type '!fir.box<!fir.array<?x?xf32>>' at index: 1
 !CHECK-NEXT: run 2 save    : where/mask
 !CHECK-NEXT: run 3 evaluate: where/elsewhere1/region_assign1

flang/tools/fir-opt/CMakeLists.txt

 add_flang_tool(fir-opt fir-opt.cpp)
 llvm_update_compile_flags(fir-opt)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
 if(FLANG_INCLUDE_TESTS)
   set(test_libs
     FIRTestAnalysis
+    MLIRTestIR
     )
 endif()
 
 target_link_libraries(fir-opt PRIVATE
   FIRDialect
   FIRSupport
   FIRTransforms
   FIRCodeGen
target_link_libraries(fir-opt PRIVATE
   MLIRTransforms
   MLIRAffineToStandard
   MLIRAnalysis
   MLIRSCFToControlFlow
   MLIRParser
   MLIRSupport
   MLIRVectorToLLVM
   MLIROptLib
-
 )

flang/tools/fir-opt/fir-opt.cpp

 
 using namespace mlir;
 namespace fir {
 namespace test {
 void registerTestFIRAliasAnalysisPass();
 } // namespace test
 } // namespace fir
 
+// Defined in mlir/test, no pulic header.
+namespace mlir {
+void registerSideEffectTestPasses();
+}
+
 int main(int argc, char **argv) {
   fir::support::registerMLIRPassesForFortranTools();
   fir::registerOptCodeGenPasses();
   fir::registerOptTransformPasses();
   hlfir::registerHLFIRPasses();
 #ifdef FLANG_INCLUDE_TESTS
   fir::test::registerTestFIRAliasAnalysisPass();
+  mlir::registerSideEffectTestPasses();
 #endif
   DialectRegistry registry;
   fir::support::registerDialects(registry);
   return failed(MlirOptMain(argc, argv, "FIR modular optimizer driver\n",
       registry));
 }