[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/lib/Evaluate/target.cpp

 #include "flang/Evaluate/common.h"
 #include "flang/Evaluate/type.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) {
     for (int kind{0}; kind < maxKind; ++kind) {
       if (CanSupportType(category, kind)) {
         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)

flang/lib/Frontend/CompilerInvocation.cpp

semanticsContext = std::make_unique<semantics::SemanticsContext>(
       getDefaultKinds(), fortranOptions.features, allCookedSources);
 
   semanticsContext->set_moduleDirectory(getModuleDir())
       .set_searchDirectories(fortranOptions.searchDirectories)
       .set_intrinsicModuleDirectories(fortranOptions.intrinsicModuleDirectories)
       .set_warnOnNonstandardUsage(getEnableConformanceChecks())
       .set_warningsAreErrors(getWarnAsErr())
       .set_moduleFileSuffix(getModuleFileSuffix());
+
+  llvm::Triple targetTriple{llvm::Triple(this->targetOpts.triple)};
+  // FIXME: Handle real(3) ?
+  if (targetTriple.getArch() != llvm::Triple::ArchType::x86 &&
+      targetTriple.getArch() != llvm::Triple::ArchType::x86_64) {
+    semanticsContext->targetCharacteristics().DisableType(
+        Fortran::common::TypeCategory::Real, /*kind=*/10);
+  }
 }
 
 /// Set \p loweringOptions controlling lowering behavior based
 /// on the \p optimizationLevel.
 void CompilerInvocation::setLoweringOptions() {
   const auto &codegenOpts = getCodeGenOpts();
 
   // Lower TRANSPOSE as a runtime call under -O0.
   loweringOpts.setOptimizeTranspose(codegenOpts.OptimizationLevel > 0);
 }

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

 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Parser/Parser.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Pass/PassRegistry.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/Passes/OptimizationLevel.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
Fortran::semantics::SemanticsContext semanticsContext{
       defaultKinds, options.features, allCookedSources};
   semanticsContext.set_moduleDirectory(moduleDir)
       .set_moduleFileSuffix(moduleSuffix)
       .set_searchDirectories(includeDirs)
       .set_intrinsicModuleDirectories(intrinsicIncludeDirs)
       .set_warnOnNonstandardUsage(warnStdViolation)
       .set_warningsAreErrors(warnIsError);
 
+  llvm::Triple targetTriple{llvm::Triple(
+      llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()))};
+  // FIXME: Handle real(3) ?
+  if (targetTriple.getArch() != llvm::Triple::ArchType::x86 &&
+      targetTriple.getArch() != llvm::Triple::ArchType::x86_64) {
+    semanticsContext.targetCharacteristics().DisableType(
+        Fortran::common::TypeCategory::Real, /*kind=*/10);
+  }
+
   return mlir::failed(convertFortranSourceToMLIR(
       inputFilename, options, programPrefix, semanticsContext, passPipe));
 }