[flang] Enable scalar real type in lowering

[clementval]

Summary

This patch enables scalar real type in lowering.
It is tested on function return types.

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

Depends on D119698

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

[clementval]

Rebase

[kiranchandramohan]

LGTM.

flang/lib/Lower/ConvertType.cpp

 #include "mlir/IR/BuiltinTypes.h"
 
 #define DEBUG_TYPE "flang-lower-type"
 
 //===--------------------------------------------------------------------===//
 // Intrinsic type translation helpers
 //===--------------------------------------------------------------------===//
 
+static mlir::Type genRealType(mlir::MLIRContext *context, int kind) {
+  if (Fortran::evaluate::IsValidKindOfIntrinsicType(
+          Fortran::common::TypeCategory::Real, kind)) {
+    switch (kind) {
+    case 2:
+      return mlir::FloatType::getF16(context);
+    case 3:
+      return mlir::FloatType::getBF16(context);
+    case 4:
+      return mlir::FloatType::getF32(context);
+    case 8:
+      return mlir::FloatType::getF64(context);
+    case 10:
+      return mlir::FloatType::getF80(context);
+    case 16:
+      return mlir::FloatType::getF128(context);
+    }
+  }
+  llvm_unreachable("REAL type translation not implemented");
+}
+
 template <int KIND>
 int getIntegerBits() {
   return Fortran::evaluate::Type<Fortran::common::TypeCategory::Integer,
                                  KIND>::Scalar::bits;
 }
 static mlir::Type genIntegerType(mlir::MLIRContext *context, int kind) {
   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
           Fortran::common::TypeCategory::Integer, kind)) {
static mlir::Type genLogicalType(mlir::MLIRContext *context, int KIND) {
   return {};
 }
 
 static mlir::Type
 genFIRType(mlir::MLIRContext *context, Fortran::common::TypeCategory tc,
            int kind) {
   switch (tc) {
   case Fortran::common::TypeCategory::Real:
-    TODO_NOLOC("genFIRType Real");
+    return genRealType(context, kind);
   case Fortran::common::TypeCategory::Integer:
     return genIntegerType(context, kind);
   case Fortran::common::TypeCategory::Complex:
     TODO_NOLOC("genFIRType Complex");
   case Fortran::common::TypeCategory::Logical:
     return genLogicalType(context, kind);
   case Fortran::common::TypeCategory::Character:
     TODO_NOLOC("genFIRType Character");
if constexpr (TC == Fortran::common::TypeCategory::Integer) {
     return genFIRType<TC>(context, KIND);
   } else {
     return {};
   }
 }
 
 template <>
 mlir::Type
-genFIRType<Fortran::common::TypeCategory::Real, 2>(mlir::MLIRContext *context) {
-  return mlir::FloatType::getF16(context);
-}
-
-template <>
-mlir::Type
-genFIRType<Fortran::common::TypeCategory::Real, 3>(mlir::MLIRContext *context) {
-  return mlir::FloatType::getBF16(context);
-}
-
-template <>
-mlir::Type
-genFIRType<Fortran::common::TypeCategory::Real, 4>(mlir::MLIRContext *context) {
-  return mlir::FloatType::getF32(context);
-}
-
-template <>
-mlir::Type
-genFIRType<Fortran::common::TypeCategory::Real, 8>(mlir::MLIRContext *context) {
-  return mlir::FloatType::getF64(context);
-}
-
-template <>
-mlir::Type genFIRType<Fortran::common::TypeCategory::Real, 10>(
-    mlir::MLIRContext *context) {
-  return fir::RealType::get(context, 10);
-}
-
-template <>
-mlir::Type genFIRType<Fortran::common::TypeCategory::Real, 16>(
-    mlir::MLIRContext *context) {
-  return fir::RealType::get(context, 16);
-}
-
-template <>
-mlir::Type
-genFIRType<Fortran::common::TypeCategory::Real>(mlir::MLIRContext *context,
-                                                int kind) {
-  if (Fortran::evaluate::IsValidKindOfIntrinsicType(
-          Fortran::common::TypeCategory::Real, kind)) {
-    switch (kind) {
-    case 2:
-      return genFIRType<Fortran::common::TypeCategory::Real, 2>(context);
-    case 3:
-      return genFIRType<Fortran::common::TypeCategory::Real, 3>(context);
-    case 4:
-      return genFIRType<Fortran::common::TypeCategory::Real, 4>(context);
-    case 8:
-      return genFIRType<Fortran::common::TypeCategory::Real, 8>(context);
-    case 10:
-      return genFIRType<Fortran::common::TypeCategory::Real, 10>(context);
-    case 16:
-      return genFIRType<Fortran::common::TypeCategory::Real, 16>(context);
-    }
-  }
-  llvm_unreachable("REAL type translation not implemented");
-}
-
-template <>
-mlir::Type
 genFIRType<Fortran::common::TypeCategory::Logical>(mlir::MLIRContext *context,
                                                    int KIND) {
   if (Fortran::evaluate::IsValidKindOfIntrinsicType(
           Fortran::common::TypeCategory::Logical, KIND))
     return fir::LogicalType::get(context, KIND);
   return {};
 }
 

flang/test/Lower/basic-function.f90

 ! CHECK-LABEL: func @_QPfct5() -> i128
 ! CHECK:         return %{{.*}} : i128
 
 function fct()
   integer :: fct
 end
 ! CHECK-LABEL: func @_QPfct() -> i32
 ! CHECK:         return %{{.*}} : i32
+
+real(2) function rfct1()
+end
+! CHECK-LABEL: func @_QPrfct1() -> f16
+! CHECK:         return %{{.*}} : f16
+
+real(3) function rfct2()
+end
+! CHECK-LABEL: func @_QPrfct2() -> bf16
+! CHECK:         return %{{.*}} : bf16
+
+real function rfct3()
+end
+! CHECK-LABEL: func @_QPrfct3() -> f32
+! CHECK:         return %{{.*}} : f32
+
+real(8) function rfct4()
+end
+! CHECK-LABEL: func @_QPrfct4() -> f64
+! CHECK:         return %{{.*}} : f64
+
+real(10) function rfct5()
+end
+! CHECK-LABEL: func @_QPrfct5() -> f80
+! CHECK:         return %{{.*}} : f80
+
+real(16) function rfct6()
+end
+! CHECK-LABEL: func @_QPrfct6() -> f128
+! CHECK:         return %{{.*}} : f128
+