[fir] Add !fir.logical type conversion

[clementval]

Summary

Add conversion from !fir.logical types to LLVM IR Dialect types.

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]>

[kiranchandramohan]

LGTM.

Nit: In the Summary please convert LLVM IR to LLVM IR Dialect/LLVM Dialect.

flang/test/Fir/types-to-llvm.fir

70

Assuming we do not support fir.logical<16>

[clementval]

flang/test/Fir/types-to-llvm.fir

70

It's actually supported. Will add a test before landing this.

func private @foo4(%arg0: !fir.logical<16>)
// CHECK-LABEL: foo4
// CHECK-SAME: i128

[schweitz]

flang/test/Fir/types-to-llvm.fir

70

The front end only supports LOGICALs with KIND values of 1, 2, 4, and 8. (See, for example, flang/Evaluate/type.h.

FIR has no such restrictions.

flang/lib/Optimizer/CodeGen/TypeConverter.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 #define FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H
 
 #include "DescriptorModel.h"
 #include "flang/Lower/Todo.h" // remove when TODO's are done
+#include "flang/Optimizer/Support/FIRContext.h"
+#include "flang/Optimizer/Support/KindMapping.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/Debug.h"
 
 namespace fir {
 
 /// FIR type converter
 /// This converts FIR types to LLVM types (for now)
 class LLVMTypeConverter : public mlir::LLVMTypeConverter {
 public:
   LLVMTypeConverter(mlir::ModuleOp module)
-      : mlir::LLVMTypeConverter(module.getContext()) {
+      : mlir::LLVMTypeConverter(module.getContext()),
+        kindMapping(getKindMapping(module)) {
     LLVM_DEBUG(llvm::dbgs() << "FIR type converter\n");
 
     // Each conversion should return a value of type mlir::Type.
     addConversion([&](BoxType box) { return convertBoxType(box); });
+    addConversion([&](fir::LogicalType boolTy) {
+      return mlir::IntegerType::get(
+          &getContext(), kindMapping.getLogicalBitsize(boolTy.getFKind()));
+    });
     addConversion(
         [&](fir::RecordType derived) { return convertRecordType(derived); });
     addConversion(
         [&](fir::ReferenceType ref) { return convertPointerLike(ref); });
     addConversion(
         [&](SequenceType sequence) { return convertSequenceType(sequence); });
     addConversion([&](mlir::TupleType tuple) {
       LLVM_DEBUG(llvm::dbgs() << "type convert: " << tuple << '\n');
if (constRows) {
         if (--i == 0)
           break;
       }
       if (seq.hasConstantShape())
         return baseTy;
     }
     return mlir::LLVM::LLVMPointerType::get(baseTy);
   }
+
+private:
+  KindMapping kindMapping;
 };
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_CODEGEN_TYPECONVERTER_H

flang/test/Fir/types-to-llvm.fir

 
 func private @foo2(%arg0: !fir.box<!fir.ref<i64>>)
 // CHECK-LABEL: foo2
 // CHECK-SAME: !llvm.ptr<struct<(ptr<i64>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}})>>
 
 func private @foo3(%arg0: !fir.box<!fir.type<derived{f:f32}>>)
 // CHECK-LABEL: foo3
 // CHECK-SAME: !llvm.ptr<struct<(ptr<struct<"derived", (f32)>>, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, i{{.*}}, ptr<i{{.*}}>, array<1 x i{{.*}}>)>>
+
+// -----
+
+// Test `!fir.logical<KIND>` conversion.
+
+func private @foo0(%arg0: !fir.logical<1>)
+// CHECK-LABEL: foo0
+// CHECK-SAME: i8
+
+func private @foo1(%arg0: !fir.logical<2>)
+// CHECK-LABEL: foo1
+// CHECK-SAME: i16
+
+func private @foo2(%arg0: !fir.logical<4>)
+// CHECK-LABEL: foo2
+// CHECK-SAME: i32
+
+func private @foo3(%arg0: !fir.logical<8>)
+// CHECK-LABEL: foo3
+// CHECK-SAME: i64
+
+func private @foo4(%arg0: !fir.logical<16>)
+// CHECK-LABEL: foo4
+// CHECK-SAME: i128