[flang] add hlfir.noreassoc codegen

[jeanPerier]

Summary

Depends on D139533

[clementval]

LGTM

flang/lib/Optimizer/HLFIR/Transforms/BufferizeHLFIR.cpp

if (auto cstMustFree = fir::factory::getIntIfConstant(mustFree))
       if (*cstMustFree == 0) {
         rewriter.eraseOp(endAssociate);
         return mlir::success(); // nothing to do.
       }
     TODO(endAssociate.getLoc(), "conditional free");
   }
 };
 
+struct NoReassocOpConversion
+    : public mlir::OpConversionPattern<hlfir::NoReassocOp> {
+  using mlir::OpConversionPattern<hlfir::NoReassocOp>::OpConversionPattern;
+  explicit NoReassocOpConversion(mlir::MLIRContext *ctx)
+      : mlir::OpConversionPattern<hlfir::NoReassocOp>{ctx} {}
+  mlir::LogicalResult
+  matchAndRewrite(hlfir::NoReassocOp noreassoc, OpAdaptor adaptor,
+                  mlir::ConversionPatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<hlfir::NoReassocOp>(
+        noreassoc, getBufferizedExprStorage(adaptor.getVal()));
+    return mlir::success();
+  }
+};
+
 class BufferizeHLFIR : public hlfir::impl::BufferizeHLFIRBase<BufferizeHLFIR> {
 public:
   void runOnOperation() override {
     // TODO: make this a pass operating on FuncOp. The issue is that
     // FirOpBuilder helpers may generate new FuncOp because of runtime/llvm
     // intrinsics calls creation. This may create race conflict if the pass is
     // scheduled on FuncOp. A solution could be to provide an optional mutex
     // when building a FirOpBuilder and locking around FuncOp and GlobalOp
     // creation, but this needs a bit more thinking, so at this point the pass
     // is scheduled on the moduleOp.
     auto module = this->getOperation();
     auto *context = &getContext();
     mlir::RewritePatternSet patterns(context);
-    patterns
-        .insert<AsExprOpConversion, AssignOpConversion, AssociateOpConversion,
-                ConcatOpConversion, EndAssociateOpConversion>(context);
+    patterns.insert<AsExprOpConversion, AssignOpConversion,
+                    AssociateOpConversion, ConcatOpConversion,
+                    EndAssociateOpConversion, NoReassocOpConversion>(context);
     mlir::ConversionTarget target(*context);
     target.addIllegalOp<hlfir::AssociateOp, hlfir::EndAssociateOp>();
     target.markUnknownOpDynamicallyLegal([](mlir::Operation *op) {
       return llvm::all_of(
                  op->getResultTypes(),
                  [](mlir::Type ty) { return !ty.isa<hlfir::ExprType>(); }) &&
              llvm::all_of(op->getOperandTypes(), [](mlir::Type ty) {
                return !ty.isa<hlfir::ExprType>();

flang/lib/Optimizer/HLFIR/Transforms/ConvertToFIR.cpp

if (designateResultType.isa<fir::BoxCharType>()) {
       rewriter.replaceOp(designate, emboxChar.getResult());
     } else {
       rewriter.replaceOp(designate, arrayCoor.getResult());
     }
     return mlir::success();
   }
 };
 
+class NoReassocOpConversion
+    : public mlir::OpRewritePattern<hlfir::NoReassocOp> {
+public:
+  explicit NoReassocOpConversion(mlir::MLIRContext *ctx)
+      : OpRewritePattern{ctx} {}
+
+  mlir::LogicalResult
+  matchAndRewrite(hlfir::NoReassocOp noreassoc,
+                  mlir::PatternRewriter &rewriter) const override {
+    rewriter.replaceOpWithNewOp<fir::NoReassocOp>(noreassoc,
+                                                  noreassoc.getVal());
+    return mlir::success();
+  }
+};
+
 class ConvertHLFIRtoFIR
     : public hlfir::impl::ConvertHLFIRtoFIRBase<ConvertHLFIRtoFIR> {
 public:
   void runOnOperation() override {
     // TODO: like "bufferize-hlfir" pass, runtime signature may be added
     // by this pass. This requires the pass to run on the ModuleOp. It would
     // probably be more optimal to have it run on FuncOp and find a way to
     // generate the signatures in a thread safe way.
     auto module = this->getOperation();
     auto *context = &getContext();
     mlir::RewritePatternSet patterns(context);
-    patterns
-        .insert<AssignOpConversion, DeclareOpConversion, DesignateOpConversion>(
-            context);
+    patterns.insert<AssignOpConversion, DeclareOpConversion,
+                    DesignateOpConversion, NoReassocOpConversion>(context);
     mlir::ConversionTarget target(*context);
     target.addIllegalDialect<hlfir::hlfirDialect>();
     target.markUnknownOpDynamicallyLegal(
         [](mlir::Operation *) { return true; });
     if (mlir::failed(mlir::applyPartialConversion(module, target,
                                                   std::move(patterns)))) {
       mlir::emitError(mlir::UnknownLoc::get(context),
                       "failure in HLFIR to FIR conversion pass");
       signalPassFailure();
     }
   }
 };
-
 } // namespace
 
 std::unique_ptr<mlir::Pass> hlfir::createConvertHLFIRtoFIRPass() {
   return std::make_unique<ConvertHLFIRtoFIR>();
 }

flang/test/HLFIR/no_reassoc-codegen.fir

+// Test hlfir.noreassoc code generation to FIR.
+
+// RUN: fir-opt %s -bufferize-hlfir -convert-hlfir-to-fir | FileCheck %s
+
+func.func @no_reassoc_expr(%addr: !fir.ref<!fir.char<1,?>>, %len: index) {
+  %0:2 = hlfir.declare %addr typeparams %len {uniq_name = "c"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+  %1 = hlfir.as_expr %0#0 : (!fir.boxchar<1>) -> !hlfir.expr<!fir.char<1,?>>
+  %2 = hlfir.no_reassoc %1 : !hlfir.expr<!fir.char<1,?>>
+  return
+}
+// CHECK:  %[[VAL_4:.*]] = fir.alloca !fir.char<1,?>
+// CHECK:  %[[VAL_5:.*]] = fir.declare %[[VAL_4]] {{.*}}
+// CHECK:  %[[VAL_6:.*]] = fir.emboxchar %[[VAL_5]], %{{.*}}
+// CHECK:  fir.no_reassoc %[[VAL_6]] : !fir.boxchar<1>
+
+func.func @no_reassoc_var(%addr: !fir.ref<!fir.char<1,?>>, %len: index) {
+  %0:2 = hlfir.declare %addr typeparams %len {uniq_name = "c"} : (!fir.ref<!fir.char<1,?>>, index) -> (!fir.boxchar<1>, !fir.ref<!fir.char<1,?>>)
+  %1 = hlfir.no_reassoc %0#0 : !fir.boxchar<1>
+  return
+}
+// CHECK-LABEL:   func.func @no_reassoc_var(
+// CHECK:  %[[VAL_3:.*]] = fir.emboxchar
+// CHECK:  fir.no_reassoc %[[VAL_3]] : !fir.boxchar<1>
+
+func.func @no_reassoc_value(%arg0 : i32) {
+  %0 = hlfir.no_reassoc %arg0 : i32
+  return
+}
+// CHECK-LABEL:   func.func @no_reassoc_value(
+// CHECK-SAME:    %[[VAL_0:.*]]: i32) {
+// CHECK:  fir.no_reassoc %[[VAL_0]] : i32