[fir] Add character conversion pass

[clementval]

Summary

Upstream the character conversion pass.
Translates entities of one CHARACTER KIND to another.
By default the translation is to naively zero-extend or truncate a code
point to fit the destination size.

This patch is part of the upstreaming effort from fir-dev branch.

Co-authored-by: Jean Perier <[e-mail]>
Co-authored-by: Eric Schweitz <[e-mail]>

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

 
 namespace fir {
 
 //===----------------------------------------------------------------------===//
 // Passes defined in Passes.td
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<mlir::Pass> createAffineDemotionPass();
+std::unique_ptr<mlir::Pass> createCharacterConversionPass();
 std::unique_ptr<mlir::Pass> createExternalNameConversionPass();
 std::unique_ptr<mlir::Pass> createPromoteToAffinePass();
 
 /// Support for inlining on FIR.
 bool canLegallyInline(mlir::Operation *op, mlir::Region *reg,
                       mlir::BlockAndValueMapping &map);
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // OPTIMIZER_TRANSFORMS_PASSES_H

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

let description = [{
     `fir.load` and `fir.store` with `!fir.ref<?>` types is required.
   }];
   let constructor = "::fir::createAffineDemotionPass()";
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::StandardOpsDialect", "mlir::AffineDialect"
   ];
 }
 
+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
+    point to fit the destination size.
+  }];
+  let constructor = "::fir::createCharacterConversionPass()";
+  let dependentDialects = [ "fir::FIROpsDialect" ];
+  let options = [
+    Option<"useRuntimeCalls", "use-runtime-calls",
+           "std::string", /*default=*/"std::string{}",
+           "Generate runtime calls to a named set of conversion routines. "
+           "By default, the conversions may produce unexpected results.">
+  ];
+}
+
 def ExternalNameConversion : Pass<"external-name-interop", "mlir::ModuleOp"> {
   let summary = "Convert name for external interoperability";
   let description = [{
     Demangle FIR internal name and mangle them for external interoperability.
   }];
   let constructor = "::fir::createExternalNameConversionPass()";
 }
 
 #endif // FLANG_OPTIMIZER_TRANSFORMS_PASSES

flang/lib/Optimizer/Transforms/CMakeLists.txt

 add_flang_library(FIRTransforms
   AffinePromotion.cpp
   AffineDemotion.cpp
+  CharacterConversion.cpp
   Inliner.cpp
   ExternalNameConversion.cpp
 
   DEPENDS
   FIRDialect
   FIRSupport
   FIROptTransformsPassIncGen
 
   LINK_LIBS
   FIRDialect
   MLIRAffineToStandard
   MLIRLLVMIR
   MLIROpenACC
   MLIROpenMP
   FIRSupport
 )

flang/lib/Optimizer/Transforms/CharacterConversion.cpp

+//===- CharacterConversion.cpp -- convert between character encodings -----===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "PassDetail.h"
+#include "flang/Optimizer/Dialect/FIRDialect.h"
+#include "flang/Optimizer/Dialect/FIROps.h"
+#include "flang/Optimizer/Dialect/FIRType.h"
+#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Support/KindMapping.h"
+#include "flang/Optimizer/Transforms/Passes.h"
+#include "mlir/Dialect/StandardOps/IR/Ops.h"
+#include "mlir/IR/Diagnostics.h"
+#include "mlir/Pass/Pass.h"
+#include "mlir/Transforms/DialectConversion.h"
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "flang-character-conversion"
+
+namespace {
+
+// TODO: Future hook to select some set of runtime calls.
+struct CharacterConversionOptions {
+  std::string runtimeName;
+};
+
+class CharacterConvertConversion
+    : public mlir::OpRewritePattern<fir::CharConvertOp> {
+public:
+  using OpRewritePattern::OpRewritePattern;
+
+  mlir::LogicalResult
+  matchAndRewrite(fir::CharConvertOp conv,
+                  mlir::PatternRewriter &rewriter) const override {
+    auto kindMap = fir::getKindMapping(conv->getParentOfType<mlir::ModuleOp>());
+    auto loc = conv.getLoc();
+
+    LLVM_DEBUG(llvm::dbgs()
+               << "running character conversion on " << conv << '\n');
+
+    // Establish a loop that executes count iterations.
+    auto zero = rewriter.create<mlir::ConstantIndexOp>(loc, 0);
+    auto one = rewriter.create<mlir::ConstantIndexOp>(loc, 1);
+    auto idxTy = rewriter.getIndexType();
+    auto castCnt = rewriter.create<fir::ConvertOp>(loc, idxTy, conv.count());
+    auto countm1 = rewriter.create<mlir::SubIOp>(loc, castCnt, one);
+    auto loop = rewriter.create<fir::DoLoopOp>(loc, zero, countm1, one);
+    auto insPt = rewriter.saveInsertionPoint();
+    rewriter.setInsertionPointToStart(loop.getBody());
+
+    // For each code point in the `from` string, convert naively to the `to`
+    // string code point. Conversion is done blindly on size only, not value.
+    auto getCharBits = [&](mlir::Type t) {
+      auto chrTy = fir::unwrapSequenceType(fir::dyn_cast_ptrEleTy(t))
+                       .cast<fir::CharacterType>();
+      return kindMap.getCharacterBitsize(chrTy.getFKind());
+    };
+    auto fromBits = getCharBits(conv.from().getType());
+    auto toBits = getCharBits(conv.to().getType());
+    auto pointerType = [&](unsigned bits) {
+      return fir::ReferenceType::get(fir::SequenceType::get(
+          fir::SequenceType::ShapeRef{fir::SequenceType::getUnknownExtent()},
+          rewriter.getIntegerType(bits)));
+    };
+    auto fromPtrTy = pointerType(fromBits);
+    auto toTy = rewriter.getIntegerType(toBits);
+    auto toPtrTy = pointerType(toBits);
+    auto fromPtr = rewriter.create<fir::ConvertOp>(loc, fromPtrTy, conv.from());
+    auto toPtr = rewriter.create<fir::ConvertOp>(loc, toPtrTy, conv.to());
+    auto getEleTy = [&](unsigned bits) {
+      return fir::ReferenceType::get(rewriter.getIntegerType(bits));
+    };
+    auto fromi = rewriter.create<fir::CoordinateOp>(
+        loc, getEleTy(fromBits), fromPtr,
+        mlir::ValueRange{loop.getInductionVar()});
+    auto toi = rewriter.create<fir::CoordinateOp>(
+        loc, getEleTy(toBits), toPtr, mlir::ValueRange{loop.getInductionVar()});
+    auto load = rewriter.create<fir::LoadOp>(loc, fromi);
+    mlir::Value icast =
+        (fromBits >= toBits)
+            ? rewriter.create<fir::ConvertOp>(loc, toTy, load).getResult()
+            : rewriter.create<mlir::ZeroExtendIOp>(loc, toTy, load).getResult();
+    rewriter.replaceOpWithNewOp<fir::StoreOp>(conv, icast, toi);
+    rewriter.restoreInsertionPoint(insPt);
+    return mlir::success();
+  }
+};
+
+/// Rewrite the `fir.char_convert` op into a loop. This pass must be run only on
+/// fir::CharConvertOp.
+class CharacterConversion
+    : public fir::CharacterConversionBase<CharacterConversion> {
+public:
+  void runOnOperation() override {
+    CharacterConversionOptions clOpts{useRuntimeCalls.getValue()};
+    if (clOpts.runtimeName.empty()) {
+      auto *context = &getContext();
+      auto *func = getOperation();
+      mlir::OwningRewritePatternList patterns(context);
+      patterns.insert<CharacterConvertConversion>(context);
+      mlir::ConversionTarget target(*context);
+      target.addLegalDialect<mlir::AffineDialect, fir::FIROpsDialect,
+                             mlir::StandardOpsDialect>();
+
+      // apply the patterns
+      target.addIllegalOp<fir::CharConvertOp>();
+      if (mlir::failed(mlir::applyPartialConversion(func, target,
+                                                    std::move(patterns)))) {
+        mlir::emitError(mlir::UnknownLoc::get(context),
+                        "error in rewriting character convert op");
+        signalPassFailure();
+      }
+      return;
+    }
+
+    // TODO: some sort of runtime supported conversion?
+    signalPassFailure();
+  }
+};
+} // end anonymous namespace
+
+std::unique_ptr<mlir::Pass> fir::createCharacterConversionPass() {
+  return std::make_unique<CharacterConversion>();
+}

flang/test/Fir/char-conversion.fir

+// RUN: fir-opt --character-conversion %s | FileCheck %s
+
+func @char_convert() {
+  %1 = fir.undefined i32
+  %2 = fir.undefined !fir.ref<!fir.char<1>>
+  %3 = fir.undefined !fir.ref<!fir.array<?x!fir.char<2,?>>>
+  fir.char_convert %2 for %1 to %3 : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?x!fir.char<2,?>>>
+  return
+}
+
+// CHECK-LABEL:   func @char_convert() {
+// CHECK:           %[[VAL_0:.*]] = fir.undefined i32
+// CHECK:           %[[VAL_1:.*]] = fir.undefined !fir.ref<!fir.char<1>>
+// CHECK:           %[[VAL_2:.*]] = fir.undefined !fir.ref<!fir.array<?x!fir.char<2,?>>>
+// CHECK:           %[[VAL_3:.*]] = constant 0 : index
+// CHECK:           %[[VAL_4:.*]] = constant 1 : index
+// CHECK:           %[[VAL_5:.*]] = fir.convert %[[VAL_0]] : (i32) -> index
+// CHECK:           %[[VAL_6:.*]] = subi %[[VAL_5]], %[[VAL_4]] : index
+// CHECK:           fir.do_loop %[[VAL_7:.*]] = %[[VAL_3]] to %[[VAL_6]] step %[[VAL_4]] {
+// CHECK:             %[[VAL_8:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1>>) -> !fir.ref<!fir.array<?xi8>>
+// CHECK:             %[[VAL_9:.*]] = fir.convert %[[VAL_2]] : (!fir.ref<!fir.array<?x!fir.char<2,?>>>) -> !fir.ref<!fir.array<?xi16>>
+// CHECK:             %[[VAL_10:.*]] = fir.coordinate_of %[[VAL_8]], %[[VAL_7]] : (!fir.ref<!fir.array<?xi8>>, index) -> !fir.ref<i8>
+// CHECK:             %[[VAL_11:.*]] = fir.coordinate_of %[[VAL_9]], %[[VAL_7]] : (!fir.ref<!fir.array<?xi16>>, index) -> !fir.ref<i16>
+// CHECK:             %[[VAL_12:.*]] = fir.load %[[VAL_10]] : !fir.ref<i8>
+// CHECK:             %[[VAL_13:.*]] = zexti %[[VAL_12]] : i8 to i16
+// CHECK:             fir.store %[[VAL_13]] to %[[VAL_11]] : !fir.ref<i16>
+// CHECK:           }
+// CHECK:           return
+// CHECK:         }