[flang] Run algebraic simplification optimization pass.

[vzakhari]

Summary

[flang] Run algebraic simplification optimization pass.

Flang algebraic simplification pass will run algebraic simplification
rewrite patterns for Math/Complex/etc. dialects. It is enabled
under opt-for-speed optimization levels (i.e. for O1/O2/O3; Os/Oz will not
enable it).

With this change the FIR/MLIR optimization pipeline becomes affected
by the -O* optimization level switches. Until now these switches
only affected the middle-end and back-end.

[tschuett]

flang/lib/Optimizer/Transforms/AlgebraicSimplification.cpp

21

I assume that this is Flang coding style. Otherwise, you may have a look if you want:
https://llvm.org/docs/CodingStandards.html#anonymous-namespaces

[clementval]

LGTM

[vzakhari]

flang/lib/Optimizer/Transforms/AlgebraicSimplification.cpp

21

Thanks for catching! Will fix soon.

[vzakhari]

In D130035#3660686, @clementval wrote:

LGTM

Thank you, @clementval! I will wait to see if @awarzynski has any comments.

[vzakhari]

clang-format

[awarzynski]

Makes sense, thanks for working on this @vzakhari !

This patch introduces the concept of optimisation levels in FIR/MLIR (until now -O{n} would only tweak the middle-end and back-end pipelines). This is a rather large design update - could you mention it in the summary? Also, I would be tempted to move your fix for parseCodeGenArgs to a dedicated patch. More comments inline/below.

From the summary:

[flang] Run algebraic simplification optimization pass.

This patch will only add a placeholder for now, right? Could you point that out?

It is enabled under opt-for-speed optimization levels.

Could you clarify this? In particular, this pass won't be enabled when optimizing for speed and size, right? It's worth mentioning that too.

flang/include/flang/Tools/CLOptions.inc

55

Shouldn't this be consistent with flang-new and set to -O0 instead?

199

UPDATEME ;-) (the signature of the method has changed)

flang/lib/Frontend/CompilerInvocation.cpp

106–112

This is a bug, which I introduced :( Thanks for catching and fixing it! I would create a separate patch with this fix - this is an unrelated change, isn't it? I.e., it applies to -O2 and other optimization flags in general rather than to "AlgebraicSimplification".

Also, I think that this would be a bit more straightforward (at the top of this method):

if (llvm::opt::Arg *a = Args.getLastArg(options::OPT_O_Group)) {
  if (a->getOption().matches(options::OPT_O0))
    return llvm::CodeGenOpt::None;

This way, you will always grab the left-most optimisation flag. Similar code in Clang.

flang/lib/Optimizer/Transforms/AlgebraicSimplification.cpp

10–12

flang/test/Driver/mlir-pass-pipeline.f90

1

You may want to update basic-program.fir as well.

21

Why not keep ALL-LABEL here? Also, an empty line improves readability. At least for me :)

[clementval]

In D130035#3662076, @awarzynski wrote:

[flang] Run algebraic simplification optimization pass.

This patch will only add a placeholder for now, right? Could you point that out?

It's actually running some simplification if enabled.

[vzakhari]

In D130035#3662841, @clementval wrote:

In D130035#3662076, @awarzynski wrote:

[flang] Run algebraic simplification optimization pass.

This patch will only add a placeholder for now, right? Could you point that out?

It's actually running some simplification if enabled.

@clementval is right, the pass does apply Math dialect algebraic simplification patterns.

In D130035#3662076, @awarzynski wrote:

Makes sense, thanks for working on this @vzakhari !

This patch introduces the concept of optimisation levels in FIR/MLIR (until now -O{n} would only tweak the middle-end and back-end pipelines). This is a rather large design update - could you mention it in the summary? Also, I would be tempted to move your fix for parseCodeGenArgs to a dedicated patch. More comments inline/below.

Thanks for the review! I will update the summary.

From the summary:

[flang] Run algebraic simplification optimization pass.

This patch will only add a placeholder for now, right? Could you point that out?

Replied above.

It is enabled under opt-for-speed optimization levels.

Could you clarify this? In particular, this pass won't be enabled when optimizing for speed and size, right? It's worth mentioning that too.

Correct, it won't be enabled for -Os and -Oz.

flang/include/flang/Tools/CLOptions.inc

55

Makes sense.

199

Thanks! Will fix.

flang/lib/Frontend/CompilerInvocation.cpp

106–112

OK, I will extract it into a separate patch, but can you please explain what change you suggest? Note that I cannot return early due to opts.DebugPassManager setting below.

flang/test/Driver/mlir-pass-pipeline.f90

21

I want to use -NEXT to verify the order of passes precisely. If I use ALL-LABEL, then some passes can sneak in between line 20 and line 21.

[awarzynski]

flang/lib/Frontend/CompilerInvocation.cpp

106–112

Not a fan of creating extra work for people. How about this: https://reviews.llvm.org/D130104? Hope you don't mind me taking the liberty to extract that.

flang/test/Driver/mlir-pass-pipeline.f90

21

Ack

[vzakhari]

Ordering of statistics by name is broken here: https://github.com/llvm/llvm-project/blob/9451440f820a497bd3f9ad0b3a85a7edc7ec67aa/mlir/lib/Pass/PassStatistics.cpp#L38

I believe std::less used by llvm::array_pod_sort_comparator does not make any good for const char *. I will have to fix it, before merging this, otherwise, the LIT tests will sporadicaly fail due to CSE statistics printed in an arbitrary order.

[vzakhari]

Fixed order of statistics checks in the tests.

flang/lib/Frontend/CompilerInvocation.cpp

106–112

Thanks!

[vzakhari]

This should be good to go now. Please let me know if bbc/tco changes look good to you. In particular, I used O3 as default for them, since they do not have any opt-level options, and I think the expecation is that they will run as many passes as available by default.

[awarzynski]

Thanks for addressing my comments!

In D130035#3664125, @vzakhari wrote:

This should be good to go now. Please let me know if bbc/tco changes look good to you. In particular, I used O3 as default for them, since they do not have any opt-level options, and I think the expecation is that they will run as many passes as available by default.

We pledged to retire bbc/tco and that's what I would like for us to aim for long term. Defaulting to -O3 is a bit counter-intuitive - as in, why is this hard-coded? But I don't want to suggest adding support for -O{n} - that would be counter-productive, IMHO. We need -O2, so perhaps that's what we should use here? And if at some point we discover that -O3 is needed instead, then bbc/tco can be updated accordingly.

[vzakhari]

In D130035#3665440, @awarzynski wrote:

Thanks for addressing my comments!

In D130035#3664125, @vzakhari wrote:

This should be good to go now. Please let me know if bbc/tco changes look good to you. In particular, I used O3 as default for them, since they do not have any opt-level options, and I think the expecation is that they will run as many passes as available by default.

We pledged to retire bbc/tco and that's what I would like for us to aim for long term. Defaulting to -O3 is a bit counter-intuitive - as in, why is this hard-coded? But I don't want to suggest adding support for -O{n} - that would be counter-productive, IMHO. We need -O2, so perhaps that's what we should use here? And if at some point we discover that -O3 is needed instead, then bbc/tco can be updated accordingly.

Okay, some compilers use -O2 as a default, so I think it is a little bit better than -O3, though, right now it does not make a difference. I will change the default.

[vzakhari]

Uploading final changes before the merge.

[vzakhari]

I am reopening this for review because of additional changes in CMake files (to fix buildbots failures). Usage of llvm::OptimizationLevel::O2 requires linking with LLVMPasses. Let me know if you have concerns about this.

[awarzynski]

In D130035#3667055, @vzakhari wrote:

Uploading final changes before the merge.

Next time, could you wait for all active reviewers to accept first?

Please address the feedback and re-post an updated version of your patch. This cycle continues until all requests and comments have been addressed and a reviewer accepts the patch with a Looks good to me or LGTM.

From how-to-submit-a-patch. LGTM :)

[vzakhari]

In D130035#3668540, @awarzynski wrote:

In D130035#3667055, @vzakhari wrote:

Uploading final changes before the merge.

Next time, could you wait for all active reviewers to accept first?

Yes, I can :) I just thought replacing O3 with O2 was your only concern. The changes seemed straightforward to me, so I went ahead with the merge.

Please address the feedback and re-post an updated version of your patch. This cycle continues until all requests and comments have been addressed and a reviewer accepts the patch with a Looks good to me or LGTM.

From how-to-submit-a-patch. LGTM :)

Thanks!

[awarzynski]

In D130035#3669588, @vzakhari wrote:

Next time, could you wait for all active reviewers to accept first?

Yes, I can :) I just thought replacing O3 with O2 was your only concern. The changes seemed straightforward to me, so I went ahead with the merge.

That's fair enough. I only asked because my first reaction was that "I haven't approved it yet and this is already merged" :) My bad for not being explicit when I left that comment!

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

 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>
 createMemoryAllocationPass(bool dynOnHeap, std::size_t maxStackSize);
 std::unique_ptr<mlir::Pass> createAnnotateConstantOperandsPass();
 std::unique_ptr<mlir::Pass> createSimplifyRegionLitePass();
+std::unique_ptr<mlir::Pass> createAlgebraicSimplificationPass();
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H

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

 def SimplifyRegionLite : Pass<"simplify-region-lite", "mlir::ModuleOp"> {
   let summary = "Region simplification";
   let description = [{
     Run region DCE and erase unreachable blocks in regions.
   }];
   let constructor = "::fir::createSimplifyRegionLitePass()";
 }
 
+def AlgebraicSimplification : Pass<"flang-algebraic-simplification"> {
+  let summary = "";
+  let description = [{
+    Run algebraic simplifications for Math/Complex/etc. dialect operations.
+    This is a flang specific pass, because we may want to "tune"
+    the rewrite patterns specifically for Fortran (e.g. increase
+    the limit for constant exponent value that defines the cases
+    when pow(x, constant) is transformed into a set of multiplications, etc.).
+  }];
+  let dependentDialects = [ "mlir::math::MathDialect" ];
+  let constructor = "::fir::createAlgebraicSimplificationPass()";
+}
+
 #endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES

flang/include/flang/Tools/CLOptions.inc

 /// debugging the test tools. This file must be included into the tool.
 
 #include "mlir/Conversion/SCFToControlFlow/SCFToControlFlow.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 #include "flang/Optimizer/CodeGen/CodeGen.h"
 #include "flang/Optimizer/Transforms/Passes.h"
+#include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CommandLine.h"
 
 #define DisableOption(DOName, DOOption, DODescription) \
   static llvm::cl::opt<bool> disable##DOName("disable-" DOOption, \
       llvm::cl::desc("disable " DODescription " pass"), llvm::cl::init(false), \
       llvm::cl::Hidden)
 
 /// Shared option in tools to control whether dynamically sized array

 /// generated by the frontend.
 static llvm::cl::opt<bool> ignoreMissingTypeDescriptors(
     "ignore-missing-type-desc",
     llvm::cl::desc("ignore failures to find derived type descriptors when "
                    "translating FIR to LLVM"),
     llvm::cl::init(false), llvm::cl::Hidden);
 
 namespace {
+const static llvm::OptimizationLevel &defaultOptLevel{
+    llvm::OptimizationLevel::O2};
+
 /// Optimizer Passes
 DisableOption(CfgConversion, "cfg-conversion", "disable FIR to CFG pass");
 DisableOption(FirAvc, "avc", "array value copy analysis and transformation");
 DisableOption(
     FirMao, "memory-allocation-opt", "memory allocation optimization");
 
 /// CodeGen Passes
 #if !defined(FLANG_EXCLUDE_CODEGEN)
inline void addExternalNameConversionPass(mlir::PassManager &pm) {
   addPassConditionally(pm, disableExternalNameConversion,
       [&]() { return fir::createExternalNameConversionPass(); });
 }
 
 /// Create a pass pipeline for running default optimization passes for
 /// incremental conversion of FIR.
 ///
 /// \param pm - MLIR pass manager that will hold the pipeline definition
-inline void createDefaultFIROptimizerPassPipeline(mlir::PassManager &pm) {
+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);
   pm.addNestedPass<mlir::func::FuncOp>(fir::createCharacterConversionPass());
   pm.addPass(mlir::createCanonicalizerPass(config));
   pm.addPass(fir::createSimplifyRegionLitePass());
+  // Algebraic simplifications may increase code size.
+  if (optLevel.isOptimizingForSpeed())
+    pm.addPass(fir::createAlgebraicSimplificationPass());
   pm.addPass(mlir::createCSEPass());
   fir::addMemoryAllocationOpt(pm);
 
   // The default inliner pass adds the canonicalizer pass with the default
   // configuration. Create the inliner pass with tco config.
   llvm::StringMap<mlir::OpPassManager> pipelines;
   pm.addPass(
       mlir::createInlinerPass(pipelines, defaultFlangInlinerOptPipeline));
inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm) {
   fir::addBoxedProcedurePass(pm);
   pm.addNestedPass<mlir::func::FuncOp>(fir::createAbstractResultOptPass());
   fir::addCodeGenRewritePass(pm);
   fir::addTargetRewritePass(pm);
   fir::addExternalNameConversionPass(pm);
   fir::addFIRToLLVMPass(pm);
 }
 
 /// Create a pass pipeline for lowering from MLIR to LLVM IR
 ///
 /// \param pm - MLIR pass manager that will hold the pipeline definition
-inline void createMLIRToLLVMPassPipeline(mlir::PassManager &pm) {
+inline void createMLIRToLLVMPassPipeline(
+    mlir::PassManager &pm, llvm::OptimizationLevel optLevel = defaultOptLevel) {
   // Add default optimizer pass pipeline.
-  fir::createDefaultFIROptimizerPassPipeline(pm);
+  fir::createDefaultFIROptimizerPassPipeline(pm, optLevel);
 
   // Add codegen pass pipeline.
   fir::createDefaultFIRCodeGenPassPipeline(pm);
 }
 #undef FLANG_EXCLUDE_CODEGEN
 #endif
 
 } // namespace fir

flang/lib/Frontend/CompilerInvocation.cpp

 }
 
 static void parseCodeGenArgs(Fortran::frontend::CodeGenOptions &opts,
                              llvm::opt::ArgList &args,
                              clang::DiagnosticsEngine &diags) {
   unsigned defaultOpt = llvm::CodeGenOpt::None;
   opts.OptimizationLevel = clang::getLastArgIntValue(
       args, clang::driver::options::OPT_O, defaultOpt, diags);
-
+  // -O0 is not classified as OPT_O, so we have to check for it
+  // explicitly, otherwise, "-O2 -O0" sets opts.OptimizationLevel
+  // to 2 above.
+  if (const llvm::opt::Arg *a =
+          args.getLastArg(clang::driver::options::OPT_O_Group))
+    if (a->getOption().matches(clang::driver::options::OPT_O0))
+      opts.OptimizationLevel = 0;
   if (args.hasFlag(clang::driver::options::OPT_fdebug_pass_manager,
                    clang::driver::options::OPT_fno_debug_pass_manager, false))
     opts.DebugPassManager = 1;
 }
 
 /// Parses all target input arguments and populates the target
 /// options accordingly.
 ///

flang/lib/Frontend/FrontendActions.cpp

 //===----------------------------------------------------------------------===//
 // CodeGenActions
 //===----------------------------------------------------------------------===//
 
 CodeGenAction::~CodeGenAction() = default;
 
 #include "flang/Tools/CLOptions.inc"
 
+static llvm::OptimizationLevel
+mapToLevel(const Fortran::frontend::CodeGenOptions &opts) {
+  switch (opts.OptimizationLevel) {
+  default:
+    llvm_unreachable("Invalid optimization level!");
+  case 0:
+    return llvm::OptimizationLevel::O0;
+  case 1:
+    return llvm::OptimizationLevel::O1;
+  case 2:
+    return llvm::OptimizationLevel::O2;
+  case 3:
+    return llvm::OptimizationLevel::O3;
+  }
+}
+
 // Lower the previously generated MLIR module into an LLVM IR module
 void CodeGenAction::generateLLVMIR() {
   assert(mlirModule && "The MLIR module has not been generated yet.");
 
   CompilerInstance &ci = this->getInstance();
+  auto opts = ci.getInvocation().getCodeGenOpts();
+  llvm::OptimizationLevel level = mapToLevel(opts);
 
   fir::support::loadDialects(*mlirCtx);
   fir::support::registerLLVMTranslation(*mlirCtx);
 
   // Set-up the MLIR pass manager
   mlir::PassManager pm(mlirCtx.get(), mlir::OpPassManager::Nesting::Implicit);
 
   pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
   pm.enableVerifier(/*verifyPasses=*/true);
 
   // Create the pass pipeline
-  fir::createMLIRToLLVMPassPipeline(pm);
+  fir::createMLIRToLLVMPassPipeline(pm, level);
   mlir::applyPassManagerCLOptions(pm);
 
   // run the pass manager
   if (!mlir::succeeded(pm.run(*mlirModule))) {
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "Lowering to LLVM IR failed");
     ci.getDiagnostics().Report(diagID);
   }
if (tm.addPassesToEmitFile(codeGenPasses, os, nullptr, cgft)) {
     diags.Report(diagID);
     return;
   }
 
   // Run the passes
   codeGenPasses.run(llvmModule);
 }
 
-static llvm::OptimizationLevel
-mapToLevel(const Fortran::frontend::CodeGenOptions &opts) {
-  switch (opts.OptimizationLevel) {
-  default:
-    llvm_unreachable("Invalid optimization level!");
-  case 0:
-    return llvm::OptimizationLevel::O0;
-  case 1:
-    return llvm::OptimizationLevel::O1;
-  case 2:
-    return llvm::OptimizationLevel::O2;
-  case 3:
-    return llvm::OptimizationLevel::O3;
-  }
-}
-
 void CodeGenAction::runOptimizationPipeline(llvm::raw_pwrite_stream &os) {
   auto opts = getInstance().getInvocation().getCodeGenOpts();
   llvm::OptimizationLevel level = mapToLevel(opts);
 
   // Create the analysis managers.
   llvm::LoopAnalysisManager lam;
   llvm::FunctionAnalysisManager fam;
   llvm::CGSCCAnalysisManager cgam;

flang/lib/Optimizer/Transforms/AlgebraicSimplification.cpp

+//===- AlgebraicSimplification.cpp - Simplify algebraic expressions -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// This file defines a pass that applies algebraic simplifications
+// to operations of Math/Complex/etc. dialects that are used by flang.
+// It is done as a flang specific pass, because we may want to tune
+// the parameters of the patterns for Fortran programs.
+//===----------------------------------------------------------------------===//
+
+
+#include "PassDetail.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/Math/Transforms/Passes.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
+
+using namespace mlir;
+
+namespace {
+struct AlgebraicSimplification
+    : public fir::AlgebraicSimplificationBase<AlgebraicSimplification> {
+
+  void runOnOperation() override;
+};
+} // namespace
+
+void AlgebraicSimplification::runOnOperation() {
+  RewritePatternSet patterns(&getContext());
+  populateMathAlgebraicSimplificationPatterns(patterns);
+  (void)applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
+}
+
+std::unique_ptr<mlir::Pass> fir::createAlgebraicSimplificationPass() {
+  return std::make_unique<AlgebraicSimplification>();
+}

flang/lib/Optimizer/Transforms/CMakeLists.txt

 add_flang_library(FIRTransforms
   AbstractResult.cpp
   AffinePromotion.cpp
   AffineDemotion.cpp
   AnnotateConstant.cpp
   CharacterConversion.cpp
   ArrayValueCopy.cpp
   ExternalNameConversion.cpp
   MemoryAllocation.cpp
   MemRefDataFlowOpt.cpp
   RewriteLoop.cpp
   SimplifyRegionLite.cpp
+  AlgebraicSimplification.cpp
 
   DEPENDS
   FIRBuilder
   FIRDialect
   FIRSupport
   FIROptTransformsPassIncGen
 
   LINK_LIBS
   FIRBuilder
   FIRDialect
   MLIRAffineUtils
   MLIRFuncDialect
   MLIRLLVMDialect
+  MLIRMathTransforms
   MLIROpenACCDialect
   MLIROpenMPDialect
   FIRSupport
 )

flang/lib/Optimizer/Transforms/PassDetail.h

 //===- PassDetail.h - Optimizer Transforms Pass class details ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
 #define FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H
 
 #include "flang/Optimizer/Dialect/FIRDialect.h"
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
+#include "mlir/Dialect/Math/IR/Math.h"
 #include "mlir/Dialect/OpenACC/OpenACC.h"
 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassRegistry.h"
 
 namespace fir {
 
 #define GEN_PASS_CLASSES
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTMIZER_TRANSFORMS_PASSDETAIL_H

flang/test/Driver/mlir-pass-pipeline.f90

 ! Test the MLIR pass pipeline
 
-! RUN: %flang_fc1 -S -mmlir --mlir-pass-statistics -mmlir --mlir-pass-statistics-display=pipeline %s -o - 2>&1 | FileCheck %s
+! RUN: %flang_fc1 -S -mmlir --mlir-pass-statistics -mmlir --mlir-pass-statistics-display=pipeline %s 2>&1 | FileCheck --check-prefixes=ALL %s
+! -O0 is the default:
+! RUN: %flang_fc1 -S -mmlir --mlir-pass-statistics -mmlir --mlir-pass-statistics-display=pipeline %s -O0 2>&1 | FileCheck --check-prefixes=ALL %s
+! RUN: %flang_fc1 -S -mmlir --mlir-pass-statistics -mmlir --mlir-pass-statistics-display=pipeline %s -O2 2>&1 | FileCheck --check-prefixes=ALL,O2 %s
+! Verify that -O0 overrides -O2:
+! RUN: %flang_fc1 -S -mmlir --mlir-pass-statistics -mmlir --mlir-pass-statistics-display=pipeline %s -O2 -O0 2>&1 | FileCheck --check-prefixes=ALL %s
 end program
 
-! CHECK: Pass statistics report
+! ALL: Pass statistics report
 
-! CHECK: CSE
-! CHECK-LABEL: 'func.func' Pipeline
-! CHECK: ArrayValueCopy
-! CHECK: CharacterConversion
-! CHECK: Canonicalizer
-! CHECK: SimplifyRegionLite
-! CHECK: CSE
-
-! CHECK-LABEL: 'func.func' Pipeline
-! CHECK: MemoryAllocationOpt
-! CHECK: Inliner
-! CHECK: CSE
-
-! CHECK-LABEL: 'func.func' Pipeline
-! CHECK: CFGConversion
-! CHECK: SCFToControlFlow
-! CHECK: Canonicalizer
-! CHECK: SimplifyRegionLite
-! CHECK: CSE
-! CHECK: BoxedProcedurePass
-
-! CHECK-LABEL: 'func.func' Pipeline
-! CHECK: AbstractResultOpt
-! CHECK: CodeGenRewrite
-! CHECK: TargetRewrite
-! CHECK: ExternalNameConversion
-! CHECK: FIRToLLVMLowering
-! CHECK-NOT: LLVMIRLoweringPass
+! ALL: Fortran::lower::VerifierPass
+! ALL-NEXT: CSE
+! Ideally, we need an output with only the pass names, but
+! there is currently no way to get that, so in order to
+! guarantee that the passes are in the expected order
+! (i.e. use -NEXT) we have to check the statistics output as well.
+! ALL-NEXT:   (S) 0 num-dce'd - Number of operations DCE'd
+! ALL-NEXT:   (S) 0 num-cse'd - Number of operations CSE'd
+! ALL-NEXT: 'func.func' Pipeline
+! ALL-NEXT:   ArrayValueCopy
+! ALL-NEXT:   CharacterConversion
+! ALL-NEXT: Canonicalizer
+! ALL-NEXT: SimplifyRegionLite
+!  O2-NEXT: AlgebraicSimplification
+! ALL-NEXT: CSE
+! ALL-NEXT:   (S) 0 num-dce'd - Number of operations DCE'd
+! ALL-NEXT:   (S) 0 num-cse'd - Number of operations CSE'd
+! ALL-NEXT: 'func.func' Pipeline
+! ALL-NEXT:   MemoryAllocationOpt
+! ALL-NEXT: Inliner
+! ALL-NEXT: CSE
+! ALL-NEXT:   (S) 0 num-dce'd - Number of operations DCE'd
+! ALL-NEXT:   (S) 0 num-cse'd - Number of operations CSE'd
+! ALL-NEXT: 'func.func' Pipeline
+! ALL-NEXT:   CFGConversion
+! ALL-NEXT: SCFToControlFlow
+! ALL-NEXT: Canonicalizer
+! ALL-NEXT: SimplifyRegionLite
+! ALL-NEXT: CSE
+! ALL-NEXT:   (S) 0 num-dce'd - Number of operations DCE'd
+! ALL-NEXT:   (S) 0 num-cse'd - Number of operations CSE'd
+! ALL-NEXT: BoxedProcedurePass
+! ALL-NEXT: 'func.func' Pipeline
+! ALL-NEXT:   AbstractResultOpt
+! ALL-NEXT: CodeGenRewrite
+! ALL-NEXT:   (S) 0 num-dce'd - Number of operations eliminated
+! ALL-NEXT: TargetRewrite
+! ALL-NEXT: ExternalNameConversion
+! ALL-NEXT: FIRToLLVMLowering
+! ALL-NOT: LLVMIRLoweringPass