WIP: abstract results on GlobalOp

[clementval]

Overall it feels a bit weird to have the same pass dealing with two different things. Maybe having two passes or a single pass on module would be better.

flang/include/flang/Tools/CLOptions.inc

186

Maybe a single pass on module can do th trick?

flang/lib/Optimizer/Transforms/AbstractResult.cpp

262

This is not super clear what it tries to achieve. At least a comment would be good..

[unterumarmung]

flang/include/flang/Tools/CLOptions.inc

186

Yeah! I thought that too..
But when I refactored code to be the pass on module, all tests that include functions with abstract results that should be converted were failing. I do not know why but the pass stopped them converting.
I guessed that since there is no module declaration in the tests (like in abstract-results.fir), the pass doesn't convert functions, because they are not in a module.
Could that be a reason?

flang/lib/Optimizer/Transforms/AbstractResult.cpp

262

Yeah, I'll add comments when I get things working

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

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FLANG_OPTIMIZER_TRANSFORMS_PASSES
 #define FLANG_OPTIMIZER_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
-def AbstractResultOpt : Pass<"abstract-result-opt", "mlir::func::FuncOp"> {
+def AbstractResultOpt : Pass<"abstract-result-opt"> {
   let summary = "Convert fir.array, fir.box and fir.rec function result to "
                 "function argument";
   let description = [{
     This pass is required before code gen to the LLVM IR dialect,
     including the pre-cg rewrite pass.
   }];
   let constructor = "::fir::createAbstractResultOptPass()";
   let dependentDialects = [

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 "flang/Optimizer/Dialect/FIROps.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
inline void createDefaultFIROptimizerPassPipeline(mlir::PassManager &pm) {
   pm.addPass(fir::createSimplifyRegionLitePass());
   pm.addPass(mlir::createCSEPass());
 }
 
 #if !defined(FLANG_EXCLUDE_CODEGEN)
 inline void createDefaultFIRCodeGenPassPipeline(mlir::PassManager &pm) {
   fir::addBoxedProcedurePass(pm);
   pm.addNestedPass<mlir::func::FuncOp>(fir::createAbstractResultOptPass());
+  pm.addNestedPass<fir::GlobalOp>(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
 ///

flang/lib/Optimizer/Transforms/AbstractResult.cpp

 #include "flang/Optimizer/Dialect/FIRType.h"
 #include "flang/Optimizer/Transforms/Passes.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/TypeSwitch.h"
+#include <mlir/IR/MLIRContext.h>
 
 #define DEBUG_TYPE "flang-abstract-result-opt"
 
 namespace fir {
 namespace {
 
 struct AbstractResultOptions {
   // Always pass result as a fir.box argument.
matchAndRewrite(fir::AddrOfOp addrOf,
     return mlir::success();
   }
 
 private:
   const AbstractResultOptions &options;
 };
 
 class AbstractResultOpt : public fir::AbstractResultOptBase<AbstractResultOpt> {
-public:
-  void runOnOperation() override {
-    auto *context = &getContext();
-    auto func = getOperation();
-    auto loc = func.getLoc();
-    mlir::RewritePatternSet patterns(context);
-    mlir::ConversionTarget target = *context;
-    AbstractResultOptions options{passResultAsBox.getValue(),
-                                  /*newArg=*/{}};
-
+  /// Returns true if should run conversions, e. g. function body is not empty
+  bool runOnFuncOp(mlir::MLIRContext *context, mlir::Operation *op,
+                   mlir::RewritePatternSet &patterns,
+                   mlir::ConversionTarget &target,
+                   AbstractResultOptions &options) const {
+    if (auto func = mlir::dyn_cast<mlir::func::FuncOp>(op)) {
+      const auto loc = func.getLoc();
       // Convert function type itself if it has an abstract result
       auto funcTy = func.getFunctionType().cast<mlir::FunctionType>();
       if (hasAbstractResult(funcTy)) {
         func.setType(getNewFunctionType(funcTy, options));
         unsigned zero = 0;
         if (!func.empty()) {
           // Insert new argument
           mlir::OpBuilder rewriter(context);
           auto resultType = funcTy.getResult(0);
           auto argTy = getResultArgumentType(resultType, options);
           options.newArg = func.front().insertArgument(zero, argTy, loc);
           if (mustEmboxResult(resultType, options)) {
             auto bufferType = fir::ReferenceType::get(resultType);
             rewriter.setInsertionPointToStart(&func.front());
-          options.newArg =
-              rewriter.create<fir::BoxAddrOp>(loc, bufferType, options.newArg);
+            options.newArg = rewriter.create<fir::BoxAddrOp>(loc, bufferType,
+                                                             options.newArg);
           }
           patterns.insert<ReturnOpConversion>(context, options);
           target.addDynamicallyLegalOp<mlir::func::ReturnOp>(
               [](mlir::func::ReturnOp ret) { return ret.operands().empty(); });
         }
       }
+      return !func.empty();
+    }
+    // Only GlobalOp can reach here
+    return true;
+  }
+
+  bool shouldRunConversionsOn(mlir::Operation *op) const {
+    return mlir::dyn_cast<mlir::func::FuncOp>(op) ||
+           mlir::dyn_cast<fir::GlobalOp>(op);
+  }
+
+public:
+  void runOnOperation() override {
+    auto *context = &getContext();
+    auto *op = getOperation();
+    // llvm::errs() << op->getName() << '\n';
+    mlir::RewritePatternSet patterns(context);
+    mlir::ConversionTarget target = *context;
+    AbstractResultOptions options{passResultAsBox.getValue(), /*newArg=*/{}};
 
-    if (func.empty())
+    // if (!shouldRunConversionsOn(op)) {
+    //   return;
+    // }
+
+    if (const bool shouldContinue =
+            runOnFuncOp(context, op, patterns, target, options);
+        !shouldContinue) {
       return;
+    }
 
-    // Convert the calls and, if needed,  the ReturnOp in the function body.
+    // Convert the calls and, if needed, the ReturnOp in the function body.
     target.addLegalDialect<fir::FIROpsDialect, mlir::arith::ArithmeticDialect,
                            mlir::func::FuncDialect>();
     target.addIllegalOp<fir::SaveResultOp>();
     target.addDynamicallyLegalOp<fir::CallOp>([](fir::CallOp call) {
       return !hasAbstractResult(call.getFunctionType());
     });
     target.addDynamicallyLegalOp<fir::AddrOfOp>([](fir::AddrOfOp addrOf) {
       if (auto funTy = addrOf.getType().dyn_cast<mlir::FunctionType>())
target.addDynamicallyLegalOp<fir::DispatchOp>([](fir::DispatchOp dispatch) {
         return false;
       }
       return true;
     });
 
     patterns.insert<CallOpConversion>(context, options);
     patterns.insert<SaveResultOpConversion>(context);
     patterns.insert<AddrOfOpConversion>(context, options);
-    if (mlir::failed(
-            mlir::applyPartialConversion(func, target, std::move(patterns)))) {
-      mlir::emitError(func.getLoc(), "error in converting abstract results\n");
+
+    if (const auto conversionResult =
+            mlir::applyPartialConversion(op, target, std::move(patterns));
+        mlir::failed(conversionResult)) {
+      mlir::emitError(op->getLoc(), "error in converting abstract results\n");
       signalPassFailure();
     }
   }
 };
 } // end anonymous namespace
 } // namespace fir
 
 std::unique_ptr<mlir::Pass> fir::createAbstractResultOptPass() {
   return std::make_unique<AbstractResultOpt>();
 }