[flang] Make real type of kind 10 target dependent

[peixin]

Summary

The real(10) is supported on x86_64. On aarch64, the value of
selected_real_kind(16) should be 16 rather than 10 since real(10)
is not supported on x86_64. Previously, the real type support check
is not target dependent. Support it now through the target triple
information.

[peixin]

Add "-triple aarch64-unknown-linux-gnu" to fix the CI fail. Do not know why the test case is still checked on Debian X86 even with ! REQUIRES: aarch64-registered-target.

[awarzynski]

In D134021#3797366, @peixin wrote:

Add "-triple aarch64-unknown-linux-gnu" to fix the CI fail. Do not know why the test case is still checked on Debian X86 even with ! REQUIRES: aarch64-registered-target.

! REQUIRES: <target> refers to the targets enabled when building LLVM rather than to the host machine on which the compiler is built. In the case of pre-commit CI, all available targets are enabled (i.e. the default value for LLVM_TARGETS_TO_BUILD is used):

-- Targeting AArch64
-- Targeting AMDGPU
-- Targeting ARM
-- Targeting AVR
-- Targeting BPF
-- Targeting Hexagon
-- Targeting Lanai
-- Targeting Mips
-- Targeting MSP430
-- Targeting NVPTX
-- Targeting PowerPC
-- Targeting RISCV
-- Targeting Sparc
-- Targeting SystemZ
-- Targeting VE
-- Targeting WebAssembly
-- Targeting X86
-- Targeting XCore

[clementval]

I think you should just call targetCharacteristics.DisableType(Fortran::common::TypeCategory::Real, 10); from the driver when the target is set and the rest is already in place.

[peixin]

In D134021#3797633, @awarzynski wrote:

In D134021#3797366, @peixin wrote:

Add "-triple aarch64-unknown-linux-gnu" to fix the CI fail. Do not know why the test case is still checked on Debian X86 even with ! REQUIRES: aarch64-registered-target.

! REQUIRES: <target> refers to the targets enabled when building LLVM rather than to the host machine on which the compiler is built. In the case of pre-commit CI, all available targets are enabled (i.e. the default value for LLVM_TARGETS_TO_BUILD is used):

-- Targeting AArch64
-- Targeting AMDGPU
-- Targeting ARM
-- Targeting AVR
-- Targeting BPF
-- Targeting Hexagon
-- Targeting Lanai
-- Targeting Mips
-- Targeting MSP430
-- Targeting NVPTX
-- Targeting PowerPC
-- Targeting RISCV
-- Targeting Sparc
-- Targeting SystemZ
-- Targeting VE
-- Targeting WebAssembly
-- Targeting X86
-- Targeting XCore

Got it. Thanks.

In D134021#3797756, @clementval wrote:

I think you should just call targetCharacteristics.DisableType(Fortran::common::TypeCategory::Real, 10); from the driver when the target is set and the rest is already in place.

Good point. This will avoid adding new element to SemanticContext. Will fix the patch.

[peixin]

Reimplement this as @clementval suggested.

[peixin]

ping

[clementval]

flang/module/__fortran_ieee_exceptions.f90

46

I'm not sure this is the right approach. It will not work when we do cross compilation (target is different than the host machine) since the target might have or not have support for real(10).

[peixin]

flang/module/__fortran_ieee_exceptions.f90

46

You are right. I also have this question when I follow the previous implementation in flang/module/iso_c_binding.f90. I think this is only the temporary and fast solution to support quad on aarch64. The final solution for the cross-compilation might need fix the build scripts (CMakeLists.txt) for flang.

[klausler]

flang/module/__fortran_ieee_exceptions.f90

46

Such a cross-compilation would properly define x86_64 or not, and that's the only architecture with x87 80-bit extended precision numbers.

[clementval]

LGTM

flang/include/flang/Evaluate/target.h

 //===-- include/flang/Evaluate/target.h -------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Represents the minimal amount of target architecture information required by
 // semantics.
 
 #ifndef FORTRAN_EVALUATE_TARGET_H_
 #define FORTRAN_EVALUATE_TARGET_H_
 
 #include "flang/Common/Fortran.h"
 #include "flang/Evaluate/common.h"
+#include "llvm/ADT/Triple.h"
 #include <cstdint>
 
 namespace Fortran::evaluate {
 
 // Floating-point rounding control
 struct Rounding {
   common::RoundingMode mode{common::RoundingMode::TiesToEven};
   // When set, emulate status flag behavior peculiar to x86
   // (viz., fail to set the Underflow flag when an inexact product of a
   // multiplication is rounded up to a normal number from a subnormal
   // in some rounding modes)
 #if __x86_64__
   bool x86CompatibleBehavior{true};
 #else
   bool x86CompatibleBehavior{false};
 #endif
 };
 
 class TargetCharacteristics {
 public:
-  TargetCharacteristics();
+  TargetCharacteristics(std::string triple);
   TargetCharacteristics &operator=(const TargetCharacteristics &) = default;
 
   bool isBigEndian() const { return isBigEndian_; }
   void set_isBigEndian(bool isBig = true);
 
   bool areSubnormalsFlushedToZero() const {
     return areSubnormalsFlushedToZero_;
   }
   void set_areSubnormalsFlushedToZero(bool yes = true);
 
   Rounding roundingMode() const { return roundingMode_; }
   void set_roundingMode(Rounding);
 
   std::size_t procedurePointerByteSize() const {
     return procedurePointerByteSize_;
   }
   std::size_t procedurePointerAlignment() const {
     return procedurePointerAlignment_;
   }
   std::size_t descriptorAlignment() const { return descriptorAlignment_; }
   std::size_t maxByteSize() const { return maxByteSize_; }
   std::size_t maxAlignment() const { return maxAlignment_; }
 
+  static bool IsTargetValidType(
+      common::TypeCategory, std::int64_t kind, llvm::Triple &targetTriple);
   static bool CanSupportType(common::TypeCategory, std::int64_t kind);
   bool EnableType(common::TypeCategory category, std::int64_t kind,
       std::size_t byteSize, std::size_t align);
   void DisableType(common::TypeCategory category, std::int64_t kind);
 
   std::size_t GetByteSize(
       common::TypeCategory category, std::int64_t kind) const;
   std::size_t GetAlignment(

flang/include/flang/Semantics/semantics.h

using ConstructNode = std::variant<const parser::AssociateConstruct *,
     const parser::DoConstruct *, const parser::ForallConstruct *,
     const parser::IfConstruct *, const parser::SelectRankConstruct *,
     const parser::SelectTypeConstruct *, const parser::WhereConstruct *>;
 using ConstructStack = std::vector<ConstructNode>;
 
 class SemanticsContext {
 public:
   SemanticsContext(const common::IntrinsicTypeDefaultKinds &,
-      const common::LanguageFeatureControl &, parser::AllCookedSources &);
+      const common::LanguageFeatureControl &, parser::AllCookedSources &,
+      const evaluate::TargetCharacteristics &);
   ~SemanticsContext();
 
   const common::IntrinsicTypeDefaultKinds &defaultKinds() const {
     return defaultKinds_;
   }
   const common::LanguageFeatureControl &languageFeatures() const {
     return languageFeatures_;
   };

flang/lib/Evaluate/target.cpp

 //===-- lib/Semantics/target.cpp ------------------------------------------===//
 //
 // 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 "flang/Evaluate/target.h"
 #include "flang/Common/template.h"
 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/type.h"
+#include "llvm/Support/Host.h"
 
 namespace Fortran::evaluate {
 
 Rounding TargetCharacteristics::defaultRounding;
 
-TargetCharacteristics::TargetCharacteristics() {
-  // TODO: Fill in the type information from command-line targeting information.
-  auto enableCategoryKinds{[this](TypeCategory category) {
+TargetCharacteristics::TargetCharacteristics(std::string triple) {
+  auto enableCategoryKinds{[this](TypeCategory category, llvm::Triple tpl) {
     for (int kind{0}; kind < maxKind; ++kind) {
-      if (CanSupportType(category, kind)) {
+      if (IsTargetValidType(category, kind, tpl)) {
         auto byteSize{static_cast<std::size_t>(kind)};
         if (category == TypeCategory::Real ||
             category == TypeCategory::Complex) {
           if (kind == 3) {
             // non-IEEE 16-bit format (truncated 32-bit)
             byteSize = 2;
           } else if (kind == 10) {
             // x87 floating-point
             // Follow gcc precedent for "long double"
             byteSize = 16;
           }
         }
         std::size_t align{byteSize};
         if (category == TypeCategory::Complex) {
           byteSize = 2 * byteSize;
         }
         EnableType(category, kind, byteSize, align);
       }
     }
   }};
-  enableCategoryKinds(TypeCategory::Integer);
-  enableCategoryKinds(TypeCategory::Real);
-  enableCategoryKinds(TypeCategory::Complex);
-  enableCategoryKinds(TypeCategory::Character);
-  enableCategoryKinds(TypeCategory::Logical);
+  if (triple.empty()) {
+    triple = llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
+  }
+  llvm::Triple targetTriple{llvm::Triple(triple)};
+  enableCategoryKinds(TypeCategory::Integer, targetTriple);
+  enableCategoryKinds(TypeCategory::Real, targetTriple);
+  enableCategoryKinds(TypeCategory::Complex, targetTriple);
+  enableCategoryKinds(TypeCategory::Character, targetTriple);
+  enableCategoryKinds(TypeCategory::Logical, targetTriple);
 
   isBigEndian_ = !isHostLittleEndian;
 
   areSubnormalsFlushedToZero_ = false;
 }
 
+bool TargetCharacteristics::IsTargetValidType(
+    TypeCategory category, std::int64_t kind, llvm::Triple &targetTriple) {
+  // FIXME: Handle real(3) ?
+  if (category == TypeCategory::Real && kind == 10) {
+    switch (targetTriple.getArch()) {
+    default:
+      break;
+    case llvm::Triple::ArchType::x86:
+    case llvm::Triple::ArchType::x86_64:
+      return true;
+    case llvm::Triple::ArchType::aarch64:
+    case llvm::Triple::ArchType::ppc64le:
+      return false;
+    }
+  }
+  return IsValidKindOfIntrinsicType(category, kind);
+}
+
 bool TargetCharacteristics::CanSupportType(
     TypeCategory category, std::int64_t kind) {
   return IsValidKindOfIntrinsicType(category, kind);
 }
 
 bool TargetCharacteristics::EnableType(common::TypeCategory category,
     std::int64_t kind, std::size_t byteSize, std::size_t align) {
   if (CanSupportType(category, kind)) {

flang/lib/Frontend/CompilerInvocation.cpp

 //===- CompilerInvocation.cpp ---------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Common/Fortran-features.h"
+#include "flang/Evaluate/target.h"
 #include "flang/Frontend/CodeGenOptions.h"
 #include "flang/Frontend/PreprocessorOptions.h"
 #include "flang/Frontend/TargetOptions.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Version.inc"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
void CompilerInvocation::setFortranOpts() {
   if (getEnableConformanceChecks()) {
     fortranOptions.features.WarnOnAllNonstandard();
   }
 }
 
 void CompilerInvocation::setSemanticsOpts(
     Fortran::parser::AllCookedSources &allCookedSources) {
   const auto &fortranOptions = getFortranOpts();
+  Fortran::evaluate::TargetCharacteristics target(this->targetOpts.triple);
 
   semanticsContext = std::make_unique<semantics::SemanticsContext>(
-      getDefaultKinds(), fortranOptions.features, allCookedSources);
+      getDefaultKinds(), fortranOptions.features, allCookedSources, target);
 
   semanticsContext->set_moduleDirectory(getModuleDir())
       .set_searchDirectories(fortranOptions.searchDirectories)
       .set_intrinsicModuleDirectories(fortranOptions.intrinsicModuleDirectories)
       .set_warnOnNonstandardUsage(getEnableConformanceChecks())
       .set_warningsAreErrors(getWarnAsErr())
       .set_moduleFileSuffix(getModuleFileSuffix());
 }

flang/lib/Semantics/semantics.cpp

static Symbol *CommonBlockIsInitialized(const Symbol &common) {
     return nullptr;
   }
   std::map<SourceName, CommonBlockInfo> commonBlocks_;
 };
 
 SemanticsContext::SemanticsContext(
     const common::IntrinsicTypeDefaultKinds &defaultKinds,
     const common::LanguageFeatureControl &languageFeatures,
-    parser::AllCookedSources &allCookedSources)
+    parser::AllCookedSources &allCookedSources,
+    const evaluate::TargetCharacteristics &target)
     : defaultKinds_{defaultKinds}, languageFeatures_{languageFeatures},
       allCookedSources_{allCookedSources},
       intrinsics_{evaluate::IntrinsicProcTable::Configure(defaultKinds_)},
-      globalScope_{*this}, intrinsicModulesScope_{globalScope_.MakeScope(
-                               Scope::Kind::IntrinsicModules, nullptr)},
+      targetCharacteristics_{target}, globalScope_{*this},
+      intrinsicModulesScope_{
+          globalScope_.MakeScope(Scope::Kind::IntrinsicModules, nullptr)},
       foldingContext_{parser::ContextualMessages{&messages_}, defaultKinds_,
           intrinsics_, targetCharacteristics_} {}
 
 SemanticsContext::~SemanticsContext() {}
 
 int SemanticsContext::GetDefaultKind(TypeCategory category) const {
   return defaultKinds_.GetDefaultKind(category);
 }

flang/module/__fortran_ieee_exceptions.f90

module __Fortran_ieee_exceptions
 
   type :: ieee_status_type ! Fortran 2018, 17.7
     private
   end type ieee_status_type
 
 ! Define specifics with 1 LOGICAL or REAL argument for generic G.
 #define SPECIFICS_L(G) \
   G(1) G(2) G(4) G(8)
+#if __x86_64__
 #define SPECIFICS_R(G) \
   G(2) G(3) G(4) G(8) G(10) G(16)
+#else
+#define SPECIFICS_R(G) \
+  G(2) G(3) G(4) G(8) G(16)
+#endif
 
 ! Set PRIVATE accessibility for specifics with 1 LOGICAL or REAL argument for
 ! generic G.
 #define PRIVATE_L(G) private :: \
   G##_l1, G##_l2, G##_l4, G##_l8
+#if __x86_64__
 #define PRIVATE_R(G) private :: \
   G##_a2, G##_a3, G##_a4, G##_a8, G##_a10, G##_a16
+#else
+#define PRIVATE_R(G) private :: \
+  G##_a2, G##_a3, G##_a4, G##_a8, G##_a16
+#endif
 
   interface ieee_get_flag
     elemental subroutine ieee_get_flag_0(flag, flag_value)
       import ieee_flag_type
       type(ieee_flag_type), intent(in) :: flag
       logical, intent(out) :: flag_value
     end subroutine ieee_get_flag_0
   end interface

flang/module/ieee_arithmetic.f90

module ieee_arithmetic
   private :: ieee_class_eq, ieee_round_eq, ieee_class_ne, ieee_round_ne
 
 ! Define specifics with 1 or 2 INTEGER, LOGICAL, or REAL arguments for
 ! generic G.
 #define SPECIFICS_I(G) \
   G(1) G(2) G(4) G(8) G(16)
 #define SPECIFICS_L(G) \
   G(1) G(2) G(4) G(8)
+#if __x86_64__
 #define SPECIFICS_R(G) \
   G(2) G(3) G(4) G(8) G(10) G(16)
+#else
+#define SPECIFICS_R(G) \
+  G(2) G(3) G(4) G(8) G(16)
+#endif
 #define SPECIFICS_II(G) \
   G(1,1) G(1,2) G(1,4) G(1,8) G(1,16) \
   G(2,1) G(2,2) G(2,4) G(2,8) G(2,16) \
   G(4,1) G(4,2) G(4,4) G(4,8) G(4,16) \
   G(8,1) G(8,2) G(8,4) G(8,8) G(8,16) \
   G(16,1) G(16,2) G(16,4) G(16,8) G(16,16)
+#if __x86_64__
 #define SPECIFICS_RI(G) \
   G(2,1) G(2,2) G(2,4) G(2,8) G(2,16) \
   G(3,1) G(3,2) G(3,4) G(3,8) G(3,16) \
   G(4,1) G(4,2) G(4,4) G(4,8) G(4,16) \
   G(8,1) G(8,2) G(8,4) G(8,8) G(8,16) \
   G(10,1) G(10,2) G(10,4) G(10,8) G(10,16) \
   G(16,1) G(16,2) G(16,4) G(16,8) G(16,16)
+#else
+#define SPECIFICS_RI(G) \
+  G(2,1) G(2,2) G(2,4) G(2,8) G(2,16) \
+  G(3,1) G(3,2) G(3,4) G(3,8) G(3,16) \
+  G(4,1) G(4,2) G(4,4) G(4,8) G(4,16) \
+  G(8,1) G(8,2) G(8,4) G(8,8) G(8,16) \
+  G(16,1) G(16,2) G(16,4) G(16,8) G(16,16)
+#endif
+
+#if __x86_64__
 #define SPECIFICS_RR(G) \
   G(2,2) G(2,3) G(2,4) G(2,8) G(2,10) G(2,16) \
   G(3,2) G(3,3) G(3,4) G(3,8) G(3,10) G(3,16) \
   G(4,2) G(4,3) G(4,4) G(4,8) G(4,10) G(4,16) \
   G(8,2) G(8,3) G(8,4) G(8,8) G(8,10) G(8,16) \
   G(10,2) G(10,3) G(10,4) G(10,8) G(10,10) G(10,16) \
   G(16,2) G(16,3) G(16,4) G(16,8) G(16,10) G(16,16)
+#else
+#define SPECIFICS_RR(G) \
+  G(2,2) G(2,3) G(2,4) G(2,8) G(2,16) \
+  G(3,2) G(3,3) G(3,4) G(3,8) G(3,16) \
+  G(4,2) G(4,3) G(4,4) G(4,8) G(4,16) \
+  G(8,2) G(8,3) G(8,4) G(8,8) G(8,16) \
+  G(16,2) G(16,3) G(16,4) G(16,8) G(16,16)
+#endif
 
 ! Set PRIVATE accessibility for specifics with 1 or 2 INTEGER, LOGICAL, or REAL
 ! arguments for generic G.
 #define PRIVATE_I(G) private :: \
   G##_i1, G##_i2, G##_i4, G##_i8, G##_i16
 #define PRIVATE_L(G) private :: \
   G##_l1, G##_l2, G##_l4, G##_l8
+#if __x86_64__
 #define PRIVATE_R(G) private :: \
   G##_a2, G##_a3, G##_a4, G##_a8, G##_a10, G##_a16
+#else
+#define PRIVATE_R(G) private :: \
+  G##_a2, G##_a3, G##_a4, G##_a8, G##_a16
+#endif
 #define PRIVATE_II(G) private :: \
   G##_i1_i1, G##_i1_i2, G##_i1_i4, G##_i1_i8, G##_i1_i16, \
   G##_i2_i1, G##_i2_i2, G##_i2_i4, G##_i2_i8, G##_i2_i16, \
   G##_i4_i1, G##_i4_i2, G##_i4_i4, G##_i4_i8, G##_i4_i16, \
   G##_i8_i1, G##_i8_i2, G##_i8_i4, G##_i8_i8, G##_i8_i16, \
   G##_i16_i1, G##_i16_i2, G##_i16_i4, G##_i16_i8, G##_i16_i16
+#if __x86_64__
 #define PRIVATE_RI(G) private :: \
   G##_a2_i1, G##_a2_i2, G##_a2_i4, G##_a2_i8, G##_a2_i16, \
   G##_a3_i1, G##_a3_i2, G##_a3_i4, G##_a3_i8, G##_a3_i16, \
   G##_a4_i1, G##_a4_i2, G##_a4_i4, G##_a4_i8, G##_a4_i16, \
   G##_a8_i1, G##_a8_i2, G##_a8_i4, G##_a8_i8, G##_a8_i16, \
   G##_a10_i1, G##_a10_i2, G##_a10_i4, G##_a10_i8, G##_a10_i16, \
   G##_a16_i1, G##_a16_i2, G##_a16_i4, G##_a16_i8, G##_a16_i16
+#else
+#define PRIVATE_RI(G) private :: \
+  G##_a2_i1, G##_a2_i2, G##_a2_i4, G##_a2_i8, G##_a2_i16, \
+  G##_a3_i1, G##_a3_i2, G##_a3_i4, G##_a3_i8, G##_a3_i16, \
+  G##_a4_i1, G##_a4_i2, G##_a4_i4, G##_a4_i8, G##_a4_i16, \
+  G##_a8_i1, G##_a8_i2, G##_a8_i4, G##_a8_i8, G##_a8_i16, \
+  G##_a16_i1, G##_a16_i2, G##_a16_i4, G##_a16_i8, G##_a16_i16
+#endif
+#if __x86_64__
 #define PRIVATE_RR(G) private :: \
   G##_a2_a2, G##_a2_a3, G##_a2_a4, G##_a2_a8, G##_a2_a10, G##_a2_a16, \
   G##_a3_a2, G##_a3_a3, G##_a3_a4, G##_a3_a8, G##_a3_a10, G##_a3_a16, \
   G##_a4_a2, G##_a4_a3, G##_a4_a4, G##_a4_a8, G##_a4_a10, G##_a4_a16, \
   G##_a8_a2, G##_a8_a3, G##_a8_a4, G##_a8_a8, G##_a8_a10, G##_a8_a16, \
   G##_a10_a2, G##_a10_a3, G##_a10_a4, G##_a10_a8, G##_a10_a10, G##_a10_a16, \
   G##_a16_a2, G##_a16_a3, G##_a16_a4, G##_a16_a8, G##_a16_a10, G##_a16_a16
+#else
+#define PRIVATE_RR(G) private :: \
+  G##_a2_a2, G##_a2_a3, G##_a2_a4, G##_a2_a8, G##_a2_a16, \
+  G##_a3_a2, G##_a3_a3, G##_a3_a4, G##_a3_a8, G##_a3_a16, \
+  G##_a4_a2, G##_a4_a3, G##_a4_a4, G##_a4_a8, G##_a4_a16, \
+  G##_a8_a2, G##_a8_a3, G##_a8_a4, G##_a8_a8, G##_a8_a16, \
+  G##_a16_a2, G##_a16_a3, G##_a16_a4, G##_a16_a8, G##_a16_a16
+#endif
 
 #define IEEE_CLASS_R(XKIND) \
   elemental type(ieee_class_type) function ieee_class_a##XKIND(x); \
     import ieee_class_type; \
     real(XKIND), intent(in) :: x; \
   end function ieee_class_a##XKIND;
   interface ieee_class
     SPECIFICS_R(IEEE_CLASS_R)

flang/test/Evaluate/folding07.f90

module m
   real(3), parameter :: &
     eps3 = epsilon(0._3), zeps3 = real(z'3c00', kind=3), deps3 = 7.8135e-3_3
   real(4), parameter :: &
     eps4 = epsilon(0._4), zeps4 = real(z'34000000', kind=4), &
     deps4 = 1.1920928955078125e-07_4
   real(8), parameter :: &
     eps8 = epsilon(0._8), zeps8 = real(z'3cb0000000000000', kind=8), &
     deps8 = 2.2204460492503130808472633361816406250e-16_8
+#if __x86_64__
   real(10), parameter :: &
     eps10 = epsilon(0._10), zeps10 = real(z'3fc08000000000000000', kind=10), &
     deps10 = 1.08420217248550443400745280086994171142578125e-19_10
+#endif
   real(16), parameter :: &
     eps16 = epsilon(0._16), &
     zeps16 = real(z'3f8f0000000000000000000000000000', kind=16), &
     deps16 = 1.9259299443872358530559779425849273185381016482153881952399387955665588378906250e-34_16
   logical, parameter :: test_eps2 = eps2 == zeps2 .and. eps2 == deps2
   logical, parameter :: test_eps3 = eps3 == zeps3 .and. eps3 == deps3
   logical, parameter :: test_eps4 = eps4 == zeps4 .and. eps4 == deps4
   logical, parameter :: test_eps8 = eps8 == zeps8 .and. eps8 == deps8
+#if __x86_64__
   logical, parameter :: test_eps10 = eps10 == zeps10 .and. eps10 == deps10
+#endif
   logical, parameter :: test_eps16 = eps16 == zeps16 .and. eps16 == deps16
 
   integer(1), parameter :: &
     ihuge1 = huge(0_1), zihuge1 = int(z'7f', kind=1), dihuge1 = 127_1
   integer(2), parameter :: &
     ihuge2 = huge(0_2), zihuge2 = int(z'7fff', kind=2), dihuge2 = 32767_2
   integer(4), parameter :: &
     ihuge4 = huge(0_4), zihuge4 = int(z'7fffffff', kind=4), &
real(4), parameter :: &
     ahuge4 = huge(0._4), zahuge4 = real(z'7f7fffff', kind=4), &
     dahuge4 = 3.4028234663852885981170418348451692544e38_4
   real(8), parameter :: &
     ahuge8 = huge(0._8), zahuge8 = real(z'7fefffffffffffff', kind=8), &
     dahuge8 = 1.7976931348623157081452742373170435679807056752584499659891747680315726078002853876058955863276687817&
                &1540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868&
                &5084551339423045832369032229481658085593321233482747978262041447231687381771809192998812504040261841&
                &24858368e308_8
+#if __x86_64__
   real(10), parameter :: &
     ahuge10 = huge(0._10), zahuge10 = real(z'7ffeffffffffffffffff', kind=10), &
     dahuge10 = 1.1897314953572317650212638530309702051690633222946242004403237338917370055229707226164102903365288828&
                 &5354569780749557731442744315367028843419812557385374367867359320070697326320191591828296152436552951&
                 &0646791086614311790632169778838896134786560600399148753433211454911160088679845154866512852340149773&
                 &0376000091254793939662231513836224178385427439178381387178058894875405751682263476592355769748051137&
                 &2564902088485522249479139937758502601177354918009979622602685950855888360815984690023564513234659447&
                 &6384939859276456284579661772930407806609229102715046085388087959327781622986827547830768080040150694&
dahuge10 = 1.1897314953572317650212638530309702051690633222946242004403237338917370055229707226164102903365288828&
                 &0667833244725787121966044152849248400418509328119089636341757398971665960007594878006191640948543387&
                 &5852065711654107226099628815012314437794400874930194474433078438899570184271000480830501217712356062&
                 &2895076269042856800047718893158089358515593863176652948089031267747029662545110861548958395087796755&
                 &4641379448959605279752098748138397625785921057562844017593493241621483395653501891968113890918437957&
                 &3470326940634289008780584694035245347939808067427323629788710086717580253156130235606487870925986528&
                 &8416350972529537091114317204887747405539054009425375424119317944175137064689643861517718849867010341&
                 &5325423859110896247108853858086888377772586485641459342621210866475884892600317623459607695088491496&
                 &6244415660441955208681198977024e4932_10
+#endif
   real(16), parameter :: &
     ahuge16 = huge(0._16), zahuge16 = real(z'7ffeffffffffffffffffffffffffffff', kind=16), &
     dahuge16 = 1.1897314953572317650857593266280070161964690526416940455296988842121635797553123923249740128484620735&
                 &2590203356474912685975526543357380446267269875194526149085346195872502126284586579940540449357468156&
                 &6096686172574953791792292256220777095858112702436475442537092608935138247345677279593806773692330094&
                 &6157461197257841728898925219399207576542048645656733564522472781522888677006389355954564966995114417&
                 &5290960687851325094831139688610052683309212868397475219226638679188087369434307734815556410166997113&
                 &8512786874753496996549221727686770196551512812712488289469952298031867469924683981576664562667786719&
dahuge16 = 1.1897314953572317650857593266280070161964690526416940455296988842121635797553123923249740128484620735&
                 &3503954612118213364077776992584180757905173583882311275962271406750966991364528828189455892561297242&
                 &5252452248453502562347348900936766966136332741088135837550717443838484760651019872222926016920811114&
                 &6169371432077434885046020127763642567468723152059526010722289706864609324352227544963417635351891055&
                 &48847634608972381760403137363968e4932_16
   logical, parameter :: test_ahuge2 = ahuge2 == zahuge2 .and. ahuge2 == dahuge2
   logical, parameter :: test_ahuge3 = ahuge3 == zahuge3 .and. ahuge3 == dahuge3
   logical, parameter :: test_ahuge4 = ahuge4 == zahuge4 .and. ahuge4 == dahuge4
   logical, parameter :: test_ahuge8 = ahuge8 == zahuge8 .and. ahuge8 == dahuge8
+#if __x86_64__
   logical, parameter :: test_ahuge10 = ahuge10 == zahuge10 .and. ahuge10 == dahuge10
+#endif
   logical, parameter :: test_ahuge16 = ahuge16 == zahuge16 .and. ahuge16 == dahuge16
 
   real(2), parameter :: tiny2 = tiny(0._2), ztiny2 = real(z'0400', kind=2)
   real(3), parameter :: tiny3 = tiny(0._3), ztiny3 = real(z'0080', kind=3)
   real(4), parameter :: tiny4 = tiny(0._4), ztiny4 = real(z'00800000', kind=4)
   real(8), parameter :: tiny8 = tiny(0._8), ztiny8 = real(z'0010000000000000', kind=8)
+#if __x86_64__
   real(10), parameter :: tiny10 = tiny(0._10), ztiny10 = real(z'00018000000000000000', kind=10)
+#endif
   real(16), parameter :: tiny16 = tiny(0._16), ztiny16 = real(z'00010000000000000000000000000000', kind=16)
   logical, parameter :: test_tiny2 = tiny2 == ztiny2
   logical, parameter :: test_tiny3 = tiny3 == ztiny3
   logical, parameter :: test_tiny4 = tiny4 == ztiny4
   logical, parameter :: test_tiny8 = tiny8 == ztiny8
+#if __x86_64__
   logical, parameter :: test_tiny10 = tiny10 == ztiny10
+#endif
   logical, parameter :: test_tiny16 = tiny16 == ztiny16
 
   real,    parameter :: nan = real(z'7fc12345')
   integer, parameter :: nanInt = int(z'7fc12345')
   real,    parameter :: inf = real(z'7f800000')
   logical, parameter :: test_exponent_0 = exponent(0.0) == 0
   logical, parameter :: test_fraction_0 = fraction(0.) == 0.
   logical, parameter :: test_exponent_r8 = exponent(0.125) == -2
#endif
   logical, parameter :: test_fraction_inf = fraction_inf /= fraction_inf ! must be NaN
   logical, parameter :: test_fraction_nan = transfer(fraction(nan),0) == nanInt
 
   integer, parameter :: &
     max2 = maxexponent(0._2), &
     max3 = maxexponent(0._3), &
     max4 = maxexponent(0._4), &
     max8 = maxexponent(0._8), &
-    max10 = maxexponent(0._10), &
     max16 = maxexponent(0._16)
+#if __x86_64__
+  integer, parameter :: max10 = maxexponent(0._10)
+#endif
   logical, parameter :: test_max2 = max2 == 16
   logical, parameter :: test_max3 = max3 == 128
   logical, parameter :: test_max4 = max4 == 128
   logical, parameter :: test_max8 = max8 == 1024
+#if __x86_64__
   logical, parameter :: test_max10 = max10 == 16384
+#endif
   logical, parameter :: test_max16 = max16 == 16384
 
   integer, parameter :: &
     min2 = minexponent(0._2), &
     min3 = minexponent(0._3), &
     min4 = minexponent(0._4), &
     min8 = minexponent(0._8), &
-    min10 = minexponent(0._10), &
     min16 = minexponent(0._16)
+#if __x86_64__
+  integer, parameter :: min10 = minexponent(0._10)
+#endif
   logical, parameter :: test_min2 = min2 == -13
   logical, parameter :: test_min3 = min3 == -125
   logical, parameter :: test_min4 = min4 == -125
   logical, parameter :: test_min8 = min8 == -1021
+#if __x86_64__
   logical, parameter :: test_min10 = min10 == -16381
+#endif
   logical, parameter :: test_min16 = min16 == -16381
 
   integer, parameter :: &
     irange1 = range(0_1), &
     irange2 = range(0_2), &
     irange4 = range(0_4), &
     irange8 = range(0_8), &
     irange16 = range(0_16)
   logical, parameter :: test_irange1 = irange1 == 2
   logical, parameter :: test_irange2 = irange2 == 4
   logical, parameter :: test_irange4 = irange4 == 9
   logical, parameter :: test_irange8 = irange8 == 18
   logical, parameter :: test_irange16 = irange16 == 38
 
   integer, parameter :: &
     arange2 = range(0._2), zrange2 = range((0._2,0._2)), &
     arange3 = range(0._3), zrange3 = range((0._3, 0._3)), &
     arange4 = range(0._4), zrange4 = range((0._4, 0._4)), &
     arange8 = range(0._8), zrange8 = range((0._8, 0._8)), &
-    arange10 = range(0._10), zrange10 = range((0._10, 0._10)), &
     arange16 = range(0._16), zrange16 = range((0._16, 0._16))
+#if __x86_64__
+  integer, parameter :: arange10 = &
+    range(0._10), zrange10 = range((0._10, 0._10))
+#endif
   logical, parameter :: test_arange2 = arange2 == 4 .and. zrange2 == 4
   logical, parameter :: test_arange3 = arange3 == 37 .and. zrange3 == 37
   logical, parameter :: test_zrange4 = arange4 == 37 .and. zrange4 == 37
   logical, parameter :: test_zrange8 = arange8 == 307 .and. zrange8 == 307
+#if __x86_64__
   logical, parameter :: test_zrange10 = arange10 == 4931 .and. zrange10 == 4931
+#endif
   logical, parameter :: test_zrange16 = arange16 == 4931 .and. zrange16 == 4931
 
   logical, parameter :: test_set_exponent_z = set_exponent(0., 999) == 0.
   logical, parameter :: test_set_exponent_nan = transfer(set_exponent(nan, 0), 0) == nanInt
   real,    parameter :: set_expo_inf = set_exponent(inf, 0)
   integer, parameter :: set_expo_inf_int = transfer(set_expo_inf, 0)
   logical, parameter :: test_set_exponent_inf = shiftr(set_expo_inf_int, 23) == 255 .and. &
                                                 shiftl(set_expo_inf_int, 9) /= 0 ! NaN
   logical, parameter :: test_set_exponent_0 = set_exponent(1., 0) == 0.5
   logical, parameter :: test_set_exponent_1 = set_exponent(1., 1) == 1.
   logical, parameter :: test_set_exponent_2 = set_exponent(1., 2) == 2.
   logical, parameter :: test_set_exponent_min = set_exponent(1., -149) == 1.40129846432481707092372958328991613128026194187651577175706828388979108268586060148663818836212158203125e-45_4
 
 end module

flang/test/Semantics/kinds03.f90

  type(rpdt(2)) :: a2
  !REF: /MainProgram1/rpdt
  !DEF: /MainProgram1/a4 ObjectEntity TYPE(rpdt(k=4_4))
  type(rpdt(4)) :: a4
  !REF: /MainProgram1/rpdt
  !DEF: /MainProgram1/a8 ObjectEntity TYPE(rpdt(k=8_4))
  type(rpdt(8)) :: a8
  !REF: /MainProgram1/rpdt
- !DEF: /MainProgram1/a10 ObjectEntity TYPE(rpdt(k=10_4))
- type(rpdt(10)) :: a10
- !REF: /MainProgram1/rpdt
  !DEF: /MainProgram1/a16 ObjectEntity TYPE(rpdt(k=16_4))
  type(rpdt(16)) :: a16
  !REF: /MainProgram1/zpdt
  !DEF: /MainProgram1/z2 ObjectEntity TYPE(zpdt(k=2_4))
  type(zpdt(2)) :: z2
  !REF: /MainProgram1/zpdt
  !DEF: /MainProgram1/z4 ObjectEntity TYPE(zpdt(k=4_4))
  type(zpdt(4)) :: z4
  !REF: /MainProgram1/zpdt
  !DEF: /MainProgram1/z8 ObjectEntity TYPE(zpdt(k=8_4))
  type(zpdt(8)) :: z8
  !REF: /MainProgram1/zpdt
- !DEF: /MainProgram1/z10 ObjectEntity TYPE(zpdt(k=10_4))
- type(zpdt(10)) :: z10
- !REF: /MainProgram1/zpdt
  !DEF: /MainProgram1/z16 ObjectEntity TYPE(zpdt(k=16_4))
  type(zpdt(16)) :: z16
  !REF: /MainProgram1/lpdt
  !DEF: /MainProgram1/l1 ObjectEntity TYPE(lpdt(k=1_4))
  type(lpdt(1)) :: l1
  !REF: /MainProgram1/lpdt
  !DEF: /MainProgram1/l2 ObjectEntity TYPE(lpdt(k=2_4))
  type(lpdt(2)) :: l2
  !REF: /MainProgram1/lpdt
  !DEF: /MainProgram1/l4 ObjectEntity TYPE(lpdt(k=4_4))
  type(lpdt(4)) :: l4
  !REF: /MainProgram1/lpdt
  !DEF: /MainProgram1/l8 ObjectEntity TYPE(lpdt(k=8_4))
  type(lpdt(8)) :: l8
 end program

flang/test/Semantics/modfile26.f90

 ! RUN: %python %S/test_modfile.py %s %flang_fc1
 ! Intrinsics SELECTED_INT_KIND, SELECTED_REAL_KIND, PRECISION, RANGE,
 ! RADIX, DIGITS
 
 module m1
-  ! INTEGER(KIND=1)  handles  0 <= P < 3
+  ! INTEGER(KIND=1)  handles       P < 3
   ! INTEGER(KIND=2)  handles  3 <= P < 5
   ! INTEGER(KIND=4)  handles  5 <= P < 10
   ! INTEGER(KIND=8)  handles 10 <= P < 19
   ! INTEGER(KIND=16) handles 19 <= P < 39
   integer, parameter :: iranges(*) = &
     [range(0_1), range(0_2), range(0_4), range(0_8), range(0_16)]
   logical, parameter :: ircheck = all([2, 4, 9, 18, 38] == iranges)
   integer, parameter :: intpvals(*) = [0, 2, 3, 4, 5, 9, 10, 18, 19, 38, 39]
   integer, parameter :: intpkinds(*) = &
     [(selected_int_kind(intpvals(j)),j=1,size(intpvals))]
   logical, parameter :: ipcheck = &
     all([1, 1, 2, 2, 4, 4, 8, 8, 16, 16, -1] == intpkinds)
 
-  ! REAL(KIND=2)  handles  0 <= P < 4  (if available)
-  ! REAL(KIND=3)  handles  0 <= P < 3  (if available)
+  ! REAL(KIND=2)  handles       P < 4  (if available)
+  ! REAL(KIND=3)  handles       P < 3  (if available)
   ! REAL(KIND=4)  handles  4 <= P < 7
   ! REAL(KIND=8)  handles  7 <= P < 16
-  ! REAL(KIND=10) handles 16 <= P < 19 (if available; ifort is KIND=16)
   ! REAL(KIND=16) handles 19 <= P < 34 (would be 32 with Power double/double)
   integer, parameter :: realprecs(*) = &
     [precision(0._2), precision(0._3), precision(0._4), precision(0._8), &
-     precision(0._10), precision(0._16)]
-  logical, parameter :: rpreccheck = all([3, 2, 6, 15, 18, 33] == realprecs)
-  integer, parameter :: realpvals(*) = [0, 3, 4, 6, 7, 15, 16, 18, 19, 33, 34]
+     precision(0._16)]
+  logical, parameter :: rpreccheck = all([3, 2, 6, 15, 33] == realprecs)
+  integer, parameter :: realpvals(*) = [0, 3, 4, 6, 7, 15, 19, 33, 34]
   integer, parameter :: realpkinds(*) = &
     [(selected_real_kind(realpvals(j),0),j=1,size(realpvals))]
   logical, parameter :: realpcheck = &
-    all([2, 2, 4, 4, 8, 8, 10, 10, 16, 16, -1] == realpkinds)
-  ! REAL(KIND=2)  handles  0 <= R < 5 (if available)
+    all([2, 2, 4, 4, 8, 8, 16, 16, -1] == realpkinds)
+  ! REAL(KIND=2)  handles       R < 5 (if available)
   ! REAL(KIND=3)  handles  5 <= R < 38 (if available, same range as KIND=4)
   ! REAL(KIND=4)  handles  5 <= R < 38 (if no KIND=3)
   ! REAL(KIND=8)  handles 38 <= R < 308
-  ! REAL(KIND=10) handles 308 <= R < 4932 (if available; ifort is KIND=16)
   ! REAL(KIND=16) handles 308 <= R < 4932 (except Power double/double)
   integer, parameter :: realranges(*) = &
-    [range(0._2), range(0._3), range(0._4), range(0._8), range(0._10), &
-     range(0._16)]
+    [range(0._2), range(0._3), range(0._4), range(0._8), range(0._16)]
   logical, parameter :: rrangecheck = &
-    all([4, 37, 37, 307, 4931, 4931] == realranges)
+    all([4, 37, 37, 307, 4931] == realranges)
   integer, parameter :: realrvals(*) = &
-    [0, 4, 5, 37, 38, 307, 308, 4931, 4932]
+    [0, 4, 5, 37, 38, 307, 4932]
   integer, parameter :: realrkinds(*) = &
     [(selected_real_kind(0,realrvals(j)),j=1,size(realrvals))]
   logical, parameter :: realrcheck = &
-    all([2, 2, 3, 3, 8, 8, 10, 10, -2] == realrkinds)
+    all([2, 2, 3, 3, 8, 8, -2] == realrkinds)
   logical, parameter :: radixcheck = &
     all([radix(0._2), radix(0._3), radix(0._4), radix(0._8), &
-         radix(0._10), radix(0._16)] == 2)
+         radix(0._16)] == 2)
   integer, parameter :: intdigits(*) = &
     [digits(0_1), digits(0_2), digits(0_4), digits(0_8), digits(0_16)]
   logical, parameter :: intdigitscheck = &
     all([7, 15, 31, 63, 127] == intdigits)
   integer, parameter :: realdigits(*) = &
-    [digits(0._2), digits(0._3), digits(0._4), digits(0._8), digits(0._10), &
-     digits(0._16)]
+    [digits(0._2), digits(0._3), digits(0._4), digits(0._8), digits(0._16)]
   logical, parameter :: realdigitscheck = &
-    all([11, 8, 24, 53, 64, 113] == realdigits)
+    all([11, 8, 24, 53, 113] == realdigits)
 end module m1
 !Expect: m1.mod
 !module m1
 !integer(4),parameter::iranges(1_8:*)=[INTEGER(4)::2_4,4_4,9_4,18_4,38_4]
 !intrinsic::range
 !logical(4),parameter::ircheck=.true._4
 !intrinsic::all
 !integer(4),parameter::intpvals(1_8:*)=[INTEGER(4)::0_4,2_4,3_4,4_4,5_4,9_4,10_4,18_4,19_4,38_4,39_4]
 !integer(4),parameter::intpkinds(1_8:*)=[INTEGER(4)::1_4,1_4,2_4,2_4,4_4,4_4,8_4,8_4,16_4,16_4,-1_4]
 !intrinsic::selected_int_kind
 !intrinsic::size
 !logical(4),parameter::ipcheck=.true._4
-!integer(4),parameter::realprecs(1_8:*)=[INTEGER(4)::3_4,2_4,6_4,15_4,18_4,33_4]
+!integer(4),parameter::realprecs(1_8:*)=[INTEGER(4)::3_4,2_4,6_4,15_4,33_4]
 !intrinsic::precision
 !logical(4),parameter::rpreccheck=.true._4
-!integer(4),parameter::realpvals(1_8:*)=[INTEGER(4)::0_4,3_4,4_4,6_4,7_4,15_4,16_4,18_4,19_4,33_4,34_4]
-!integer(4),parameter::realpkinds(1_8:*)=[INTEGER(4)::2_4,2_4,4_4,4_4,8_4,8_4,10_4,10_4,16_4,16_4,-1_4]
+!integer(4),parameter::realpvals(1_8:*)=[INTEGER(4)::0_4,3_4,4_4,6_4,7_4,15_4,19_4,33_4,34_4]
+!integer(4),parameter::realpkinds(1_8:*)=[INTEGER(4)::2_4,2_4,4_4,4_4,8_4,8_4,16_4,16_4,-1_4]
 !intrinsic::selected_real_kind
 !logical(4),parameter::realpcheck=.true._4
-!integer(4),parameter::realranges(1_8:*)=[INTEGER(4)::4_4,37_4,37_4,307_4,4931_4,4931_4]
+!integer(4),parameter::realranges(1_8:*)=[INTEGER(4)::4_4,37_4,37_4,307_4,4931_4]
 !logical(4),parameter::rrangecheck=.true._4
-!integer(4),parameter::realrvals(1_8:*)=[INTEGER(4)::0_4,4_4,5_4,37_4,38_4,307_4,308_4,4931_4,4932_4]
-!integer(4),parameter::realrkinds(1_8:*)=[INTEGER(4)::2_4,2_4,3_4,3_4,8_4,8_4,10_4,10_4,-2_4]
+!integer(4),parameter::realrvals(1_8:*)=[INTEGER(4)::0_4,4_4,5_4,37_4,38_4,307_4,4932_4]
+!integer(4),parameter::realrkinds(1_8:*)=[INTEGER(4)::2_4,2_4,3_4,3_4,8_4,8_4,-2_4]
 !logical(4),parameter::realrcheck=.true._4
 !logical(4),parameter::radixcheck=.true._4
 !intrinsic::radix
 !integer(4),parameter::intdigits(1_8:*)=[INTEGER(4)::7_4,15_4,31_4,63_4,127_4]
 !intrinsic::digits
 !logical(4),parameter::intdigitscheck=.true._4
-!integer(4),parameter::realdigits(1_8:*)=[INTEGER(4)::11_4,8_4,24_4,53_4,64_4,113_4]
+!integer(4),parameter::realdigits(1_8:*)=[INTEGER(4)::11_4,8_4,24_4,53_4,113_4]
 !logical(4),parameter::realdigitscheck=.true._4
 !end

flang/test/Semantics/real10-x86-01.f90

+! RUN: %python %S/test_symbols.py %s %flang_fc1
+! REQUIRES: x86-registered-target
+
+ !DEF: /MainProgram1/rpdt DerivedType
+ !DEF: /MainProgram1/rpdt/k TypeParam INTEGER(4)
+ type :: rpdt(k)
+  !REF: /MainProgram1/rpdt/k
+  integer, kind :: k
+  !REF: /MainProgram1/rpdt/k
+  !DEF: /MainProgram1/rpdt/x ObjectEntity REAL(int(int(k,kind=4),kind=8))
+  real(kind=k) :: x
+ end type rpdt
+ !DEF: /MainProgram1/zpdt DerivedType
+ !DEF: /MainProgram1/zpdt/k TypeParam INTEGER(4)
+ type :: zpdt(k)
+  !REF: /MainProgram1/zpdt/k
+  integer, kind :: k
+  !REF: /MainProgram1/zpdt/k
+  !DEF: /MainProgram1/zpdt/x ObjectEntity COMPLEX(int(int(k,kind=4),kind=8))
+  complex(kind=k) :: x
+ end type zpdt
+ !REF: /MainProgram1/rpdt
+ !DEF: /MainProgram1/a10 ObjectEntity TYPE(rpdt(k=10_4))
+ type(rpdt(10)) :: a10
+ !REF: /MainProgram1/zpdt
+ !DEF: /MainProgram1/z10 ObjectEntity TYPE(zpdt(k=10_4))
+ type(zpdt(10)) :: z10
+end program

flang/test/Semantics/real10-x86-02.f90

+! RUN: %python %S/test_modfile.py %s %flang_fc1
+! REQUIRES: x86-registered-target
+! Intrinsics SELECTED_INT_KIND, SELECTED_REAL_KIND, PRECISION, RANGE,
+! RADIX, DIGITS
+
+module m1
+  ! REAL(KIND=10) handles 16 <= P < 19 (if available; ifort is KIND=16)
+  integer, parameter :: realprec = precision(0._10)
+  logical, parameter :: rpreccheck = 18 == realprec
+  integer, parameter :: realpvals(*) = [16, 18]
+  integer, parameter :: realpkinds(*) = &
+    [(selected_real_kind(realpvals(j),0),j=1,size(realpvals))]
+  logical, parameter :: realpcheck = all([10, 10] == realpkinds)
+  ! REAL(KIND=10) handles 308 <= R < 4932 (if available; ifort is KIND=16)
+  integer, parameter :: realrange = range(0._10)
+  logical, parameter :: rrangecheck = 4931 == realrange
+  integer, parameter :: realrvals(*) = [308, 4931]
+  integer, parameter :: realrkinds(*) = &
+    [(selected_real_kind(0,realrvals(j)),j=1,size(realrvals))]
+  logical, parameter :: realrcheck = all([10, 10] == realrkinds)
+  logical, parameter :: radixcheck = radix(0._10) == 2
+
+  integer, parameter :: realdigits = digits(0._10)
+  logical, parameter :: realdigitscheck = 64 == realdigits
+end module m1
+!Expect: m1.mod
+!module m1
+!integer(4),parameter::realprec=18_4
+!intrinsic::precision
+!logical(4),parameter::rpreccheck=.true._4
+!integer(4),parameter::realpvals(1_8:*)=[INTEGER(4)::16_4,18_4]
+!integer(4),parameter::realpkinds(1_8:*)=[INTEGER(4)::10_4,10_4]
+!intrinsic::selected_real_kind
+!intrinsic::size
+!logical(4),parameter::realpcheck=.true._4
+!intrinsic::all
+!integer(4),parameter::realrange=4931_4
+!intrinsic::range
+!logical(4),parameter::rrangecheck=.true._4
+!integer(4),parameter::realrvals(1_8:*)=[INTEGER(4)::308_4,4931_4]
+!integer(4),parameter::realrkinds(1_8:*)=[INTEGER(4)::10_4,10_4]
+!logical(4),parameter::realrcheck=.true._4
+!logical(4),parameter::radixcheck=.true._4
+!intrinsic::radix
+!integer(4),parameter::realdigits=64_4
+!intrinsic::digits
+!logical(4),parameter::realdigitscheck=.true._4
+!end

flang/test/Semantics/realkinds-aarch64-01.f90

+! RUN: %python %S/test_modfile.py %s %flang_fc1 -triple aarch64-unknown-linux-gnu
+! REQUIRES: aarch64-registered-target
+
+module m1
+  logical, parameter :: realpcheck = 16 == selected_real_kind(16)
+end module m1
+!Expect: m1.mod
+!module m1
+!logical(4),parameter::realpcheck=.true._4
+!intrinsic::selected_real_kind
+!end

flang/tools/bbc/bbc.cpp

int main(int argc, char **argv) {
   if (enableOpenACC) {
     options.features.Enable(Fortran::common::LanguageFeature::OpenACC);
     options.predefinitions.emplace_back("_OPENACC", "201911");
   }
 
   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
   Fortran::parser::AllSources allSources;
   Fortran::parser::AllCookedSources allCookedSources(allSources);
+  Fortran::evaluate::TargetCharacteristics target("");
   Fortran::semantics::SemanticsContext semanticsContext{
-      defaultKinds, options.features, allCookedSources};
+      defaultKinds, options.features, allCookedSources, target};
   semanticsContext.set_moduleDirectory(moduleDir)
       .set_moduleFileSuffix(moduleSuffix)
       .set_searchDirectories(includeDirs)
       .set_intrinsicModuleDirectories(intrinsicIncludeDirs)
       .set_warnOnNonstandardUsage(warnStdViolation)
       .set_warningsAreErrors(warnIsError);
 
   return mlir::failed(convertFortranSourceToMLIR(
       inputFilename, options, programPrefix, semanticsContext, passPipe));
 }

flang/unittests/Evaluate/expression.cpp

int main() {
   TEST(DefaultIntegerExpr::Result::AsFortran() == "INTEGER(4)");
   MATCH("666_4", DefaultIntegerExpr{666}.AsFortran());
   MATCH("-1_4", (-DefaultIntegerExpr{1}).AsFortran());
   auto ex1{
       DefaultIntegerExpr{2} + DefaultIntegerExpr{3} * -DefaultIntegerExpr{4}};
   MATCH("2_4+3_4*(-4_4)", ex1.AsFortran());
   Fortran::common::IntrinsicTypeDefaultKinds defaults;
   auto intrinsics{Fortran::evaluate::IntrinsicProcTable::Configure(defaults)};
-  TargetCharacteristics targetCharacteristics;
+  TargetCharacteristics targetCharacteristics("");
   FoldingContext context{Fortran::parser::ContextualMessages{nullptr}, defaults,
       intrinsics, targetCharacteristics};
   ex1 = Fold(context, std::move(ex1));
   MATCH("-10_4", ex1.AsFortran());
   MATCH("1_4/2_4", (DefaultIntegerExpr{1} / DefaultIntegerExpr{2}).AsFortran());
   DefaultIntegerExpr a{1};
   DefaultIntegerExpr b{2};
   MATCH("1_4", a.AsFortran());
   a = b;
   MATCH("2_4", a.AsFortran());
   MATCH("2_4", b.AsFortran());
   return testing::Complete();
 }

flang/unittests/Evaluate/folding.cpp

 
 void TestHostRuntimeSubnormalFlushing() {
   using R4 = Type<TypeCategory::Real, 4>;
   if constexpr (std::is_same_v<host::HostType<R4>, float>) {
     Fortran::parser::CharBlock src;
     Fortran::parser::ContextualMessages messages{src, nullptr};
     Fortran::common::IntrinsicTypeDefaultKinds defaults;
     auto intrinsics{Fortran::evaluate::IntrinsicProcTable::Configure(defaults)};
-    TargetCharacteristics flushingTargetCharacteristics;
+    TargetCharacteristics flushingTargetCharacteristics("");
     flushingTargetCharacteristics.set_areSubnormalsFlushedToZero(true);
-    TargetCharacteristics noFlushingTargetCharacteristics;
+    TargetCharacteristics noFlushingTargetCharacteristics("");
     noFlushingTargetCharacteristics.set_areSubnormalsFlushedToZero(false);
     FoldingContext flushingContext{
         messages, defaults, intrinsics, flushingTargetCharacteristics};
     FoldingContext noFlushingContext{
         messages, defaults, intrinsics, noFlushingTargetCharacteristics};
 
     DynamicType r4{R4{}.GetType()};
     // Test subnormal argument flushing

flang/unittests/Evaluate/intrinsics.cpp

void DoCall(std::optional<DynamicType> resultType = std::nullopt,
     }
     if (sep == '(') {
       llvm::outs() << '(';
     }
     llvm::outs() << ')' << '\n';
     llvm::outs().flush();
     CallCharacteristics call{fName.ToString()};
     auto messages{strings.Messages(buffer)};
-    TargetCharacteristics targetCharacteristics;
+    TargetCharacteristics targetCharacteristics("");
     FoldingContext context{messages, defaults, table, targetCharacteristics};
     std::optional<SpecificCall> si{table.Probe(call, args, context)};
     if (resultType.has_value()) {
       TEST(si.has_value());
       TEST(messages.messages() && !messages.messages()->AnyFatalError());
       if (si) {
         const auto &proc{si->specificIntrinsic.characteristics.value()};
         const auto &fr{proc.functionResult};