[flang] Support SELECTED_LOGICAL_KIND() up to lowering

[klausler]

Summary

Process and fold the new F'2023 intrinsic function SELECTED_LOGICAL_KIND.

[PeteSteinfeld]

All builds and tests correctly and looks good.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/include/flang/Evaluate/target.h

public:
 
   std::size_t GetByteSize(
       common::TypeCategory category, std::int64_t kind) const;
   std::size_t GetAlignment(
       common::TypeCategory category, std::int64_t kind) const;
   bool IsTypeEnabled(common::TypeCategory category, std::int64_t kind) const;
 
   int SelectedIntKind(std::int64_t precision = 0) const;
+  int SelectedLogicalKind(std::int64_t bits = 1) const;
   int SelectedRealKind(std::int64_t precision = 0, std::int64_t range = 0,
       std::int64_t radix = 2) const;
 
   static Rounding defaultRounding;
 
   const std::string &compilerOptionsString() const {
     return compilerOptionsString_;
   };

flang/lib/Evaluate/fold-integer.cpp

if (const auto *chCon{UnwrapExpr<Constant<TypeOf<std::string>>>(args[0])}) {
             context.defaults().GetDefaultKind(TypeCategory::Character)};
         return Expr<T>{SelectedCharKind(*value, defaultKind)};
       }
     }
   } else if (name == "selected_int_kind") {
     if (auto p{ToInt64(args[0])}) {
       return Expr<T>{context.targetCharacteristics().SelectedIntKind(*p)};
     }
+  } else if (name == "selected_logical_kind") {
+    if (auto p{ToInt64(args[0])}) {
+      return Expr<T>{context.targetCharacteristics().SelectedLogicalKind(*p)};
+    }
   } else if (name == "selected_real_kind" ||
       name == "__builtin_ieee_selected_real_kind") {
     if (auto p{GetInt64ArgOr(args[0], 0)}) {
       if (auto r{GetInt64ArgOr(args[1], 0)}) {
         if (auto radix{GetInt64ArgOr(args[2], 2)}) {
           return Expr<T>{
               context.targetCharacteristics().SelectedRealKind(*p, *r, *radix)};
         }

flang/lib/Evaluate/intrinsics.cpp

// NULL() is a special case handled in Probe() below
         {{"string", SameCharNoLen}, {"set", SameCharNoLen},
             {"back", AnyLogical, Rank::elemental, Optionality::optional},
             DefaultingKIND},
         KINDInt},
     {"selected_char_kind", {{"name", DefaultChar, Rank::scalar}}, DefaultInt,
         Rank::scalar, IntrinsicClass::transformationalFunction},
     {"selected_int_kind", {{"r", AnyInt, Rank::scalar}}, DefaultInt,
         Rank::scalar, IntrinsicClass::transformationalFunction},
+    {"selected_logical_kind", {{"bits", AnyInt, Rank::scalar}}, DefaultInt,
+        Rank::scalar, IntrinsicClass::transformationalFunction},
     {"selected_real_kind",
         {{"p", AnyInt, Rank::scalar},
             {"r", AnyInt, Rank::scalar, Optionality::optional},
             {"radix", AnyInt, Rank::scalar, Optionality::optional}},
         DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"selected_real_kind",
         {{"p", AnyInt, Rank::scalar, Optionality::optional},
             {"r", AnyInt, Rank::scalar},

flang/lib/Evaluate/target.cpp

int TargetCharacteristics::SelectedIntKind(std::int64_t precision) const {
   if (auto kind{
           common::SearchTypes(SelectedIntKindVisitor{*this, precision})}) {
     return *kind;
   } else {
     return -1;
   }
 }
 
+// SELECTED_LOGICAL_KIND() -- F'2023 16.9.182
+class SelectedLogicalKindVisitor {
+public:
+  SelectedLogicalKindVisitor(
+      const TargetCharacteristics &targetCharacteristics, std::int64_t bits)
+      : targetCharacteristics_{targetCharacteristics}, bits_{bits} {}
+  using Result = std::optional<int>;
+  using Types = LogicalTypes;
+  template <typename T> Result Test() const {
+    if (Scalar<T>::bits >= bits_ &&
+        targetCharacteristics_.IsTypeEnabled(T::category, T::kind)) {
+      return T::kind;
+    } else {
+      return std::nullopt;
+    }
+  }
+
+private:
+  const TargetCharacteristics &targetCharacteristics_;
+  std::int64_t bits_;
+};
+
+int TargetCharacteristics::SelectedLogicalKind(std::int64_t bits) const {
+  if (auto kind{common::SearchTypes(SelectedLogicalKindVisitor{*this, bits})}) {
+    return *kind;
+  } else {
+    return -1;
+  }
+}
+
 // SELECTED_REAL_KIND() -- F'2018 16.9.170
 class SelectedRealKindVisitor {
 public:
   SelectedRealKindVisitor(const TargetCharacteristics &targetCharacteristics,
       std::int64_t p, std::int64_t r)
       : targetCharacteristics_{targetCharacteristics}, precision_{p}, range_{
                                                                           r} {}
   using Result = std::optional<int>;

flang/test/Evaluate/fold-selected_logical_kind.f90

+! RUN: %python %S/test_folding.py %s %flang_fc1
+module m
+  logical, parameter :: test_0  = selected_logical_kind( 0) == 1
+  logical, parameter :: test_1  = selected_logical_kind( 1) == 1
+  logical, parameter :: test_7  = selected_logical_kind( 7) == 1
+  logical, parameter :: test_8  = selected_logical_kind( 8) == 1
+  logical, parameter :: test_9  = selected_logical_kind( 9) == 2
+  logical, parameter :: test_15 = selected_logical_kind(15) == 2
+  logical, parameter :: test_16 = selected_logical_kind(16) == 2
+  logical, parameter :: test_17 = selected_logical_kind(17) == 4
+  logical, parameter :: test_31 = selected_logical_kind(31) == 4
+  logical, parameter :: test_32 = selected_logical_kind(32) == 4
+  logical, parameter :: test_33 = selected_logical_kind(33) == 8
+  logical, parameter :: test_63 = selected_logical_kind(63) == 8
+  logical, parameter :: test_64 = selected_logical_kind(64) == 8
+  logical, parameter :: test_65 = selected_logical_kind(65) == -1
+end