[flang] Address more MSVC build issues with reduction & numeric intrinsics

[klausler]

Summary

Move #include <complex.h> to complex-reduction.h, where
it is needed in MSVC builds.

Exclude code that requires a native 128-bit integer type from
compilation by MSVC.

[MehdiChinoune]

It would be better if you exclude int128 intrinsic functions introduced in D99764

[klausler]

Exclude more entry points.

[MehdiChinoune]

I get this error:

D:\dev\llvm-project\flang\runtime\reduction.cpp(95): error C2059: syntax error: 'template'
D:\dev\llvm-project\flang\runtime\reduction.cpp(404): note: see reference to function template instantiation 'signed char Fortran::runtime::GetTotalReduction<Fortran::common::TypeCategory::Integer,1,Fortran::runtime::IntegerSumAccumulator<int>>(const Fortran::runtime::Descriptor &,const char *,int,int,const Fortran::runtime::Descriptor *,ACCUMULATOR &&,const char *)' being compiled
        with
        [
            ACCUMULATOR=Fortran::runtime::IntegerSumAccumulator<int>
        ]

Could you fix it?

[klausler]

Add attempted MSVC work-around to dodge error on "accumulator.template GetResult(...)" in function template.

[MehdiChinoune]

It works

Remaining (after applying the patch)

D:\dev\llvm-project\flang\runtime\reduction.cpp(161): error C2059: syntax error: 'template'

D:\dev\llvm-project\flang\runtime\reduction.cpp(137): error C2059: syntax error: 'template'

[klausler]

Two more sites for the previous fix for a MSVC spurious error.

[MehdiChinoune]

Thanks

I don't see any other error for now.

[klausler]

In D99806#2666949, @MehdiChinoune wrote:

Thanks

I don't see any other error for now.

Thank you for your help. Please approve when convenient.

flang/runtime/complex-reduction.h

 #define FORTRAN_RUNTIME_COMPLEX_REDUCTION_H_
 
 #include "entry-names.h"
+#include <complex.h>
 
 struct CppDescriptor; /* dummy type name for Fortran::runtime::Descriptor */
 

flang/runtime/complex-reduction.c

 
 #include "complex-reduction.h"
 #include "flang/Common/long-double.h"
-#include <complex.h>
 
 struct CppComplexFloat {
   float r, i;

flang/runtime/numeric.h

     CppTypeFor<TypeCategory::Real, 4>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Ceiling4_8)(
     CppTypeFor<TypeCategory::Real, 4>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling4_16)(
     CppTypeFor<TypeCategory::Real, 4>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling8_1)(
     CppTypeFor<TypeCategory::Real, 8>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Ceiling8_2)(

     CppTypeFor<TypeCategory::Real, 8>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Ceiling8_8)(
     CppTypeFor<TypeCategory::Real, 8>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling8_16)(
     CppTypeFor<TypeCategory::Real, 8>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling10_1)(
     CppTypeFor<TypeCategory::Real, 10>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Ceiling10_2)(

     CppTypeFor<TypeCategory::Real, 10>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Ceiling10_8)(
     CppTypeFor<TypeCategory::Real, 10>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling10_16)(
     CppTypeFor<TypeCategory::Real, 10>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling16_1)(
     CppTypeFor<TypeCategory::Real, 16>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Ceiling16_2)(

     CppTypeFor<TypeCategory::Real, 16>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Ceiling16_8)(
     CppTypeFor<TypeCategory::Real, 16>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling16_16)(
     CppTypeFor<TypeCategory::Real, 16>);
+#endif
 
 // EXPONENT is defined to return default INTEGER; support INTEGER(4 & 8)
 CppTypeFor<TypeCategory::Integer, 4> RTNAME(Exponent4_4)(

     CppTypeFor<TypeCategory::Real, 4>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Floor4_8)(
     CppTypeFor<TypeCategory::Real, 4>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor4_16)(
     CppTypeFor<TypeCategory::Real, 4>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Floor8_1)(
     CppTypeFor<TypeCategory::Real, 8>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Floor8_2)(

     CppTypeFor<TypeCategory::Real, 8>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Floor8_8)(
     CppTypeFor<TypeCategory::Real, 8>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor8_16)(
     CppTypeFor<TypeCategory::Real, 8>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Floor10_1)(
     CppTypeFor<TypeCategory::Real, 10>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Floor10_2)(

     CppTypeFor<TypeCategory::Real, 10>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Floor10_8)(
     CppTypeFor<TypeCategory::Real, 10>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor10_16)(
     CppTypeFor<TypeCategory::Real, 10>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Floor16_1)(
     CppTypeFor<TypeCategory::Real, 16>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Floor16_2)(

     CppTypeFor<TypeCategory::Real, 16>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Floor16_8)(
     CppTypeFor<TypeCategory::Real, 16>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor16_16)(
     CppTypeFor<TypeCategory::Real, 16>);
+#endif
 
 // FRACTION
 CppTypeFor<TypeCategory::Real, 4> RTNAME(Fraction4)(

     CppTypeFor<TypeCategory::Integer, 4>, CppTypeFor<TypeCategory::Integer, 4>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(ModInteger8)(
     CppTypeFor<TypeCategory::Integer, 8>, CppTypeFor<TypeCategory::Integer, 8>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(ModInteger16)(
     CppTypeFor<TypeCategory::Integer, 16>,
     CppTypeFor<TypeCategory::Integer, 16>);
+#endif
 CppTypeFor<TypeCategory::Real, 4> RTNAME(ModReal4)(
     CppTypeFor<TypeCategory::Real, 4>, CppTypeFor<TypeCategory::Real, 4>);
 CppTypeFor<TypeCategory::Real, 8> RTNAME(ModReal8)(

     CppTypeFor<TypeCategory::Integer, 4>, CppTypeFor<TypeCategory::Integer, 4>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(ModuloInteger8)(
     CppTypeFor<TypeCategory::Integer, 8>, CppTypeFor<TypeCategory::Integer, 8>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(ModuloInteger16)(
     CppTypeFor<TypeCategory::Integer, 16>,
     CppTypeFor<TypeCategory::Integer, 16>);
+#endif
 CppTypeFor<TypeCategory::Real, 4> RTNAME(ModuloReal4)(
     CppTypeFor<TypeCategory::Real, 4>, CppTypeFor<TypeCategory::Real, 4>);
 CppTypeFor<TypeCategory::Real, 8> RTNAME(ModuloReal8)(

     CppTypeFor<TypeCategory::Real, 4>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Nint4_8)(
     CppTypeFor<TypeCategory::Real, 4>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint4_16)(
     CppTypeFor<TypeCategory::Real, 4>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Nint8_1)(
     CppTypeFor<TypeCategory::Real, 8>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Nint8_2)(

     CppTypeFor<TypeCategory::Real, 8>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Nint8_8)(
     CppTypeFor<TypeCategory::Real, 8>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint8_16)(
     CppTypeFor<TypeCategory::Real, 8>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Nint10_1)(
     CppTypeFor<TypeCategory::Real, 10>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Nint10_2)(

     CppTypeFor<TypeCategory::Real, 10>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Nint10_8)(
     CppTypeFor<TypeCategory::Real, 10>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint10_16)(
     CppTypeFor<TypeCategory::Real, 10>);
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Nint16_1)(
     CppTypeFor<TypeCategory::Real, 16>);
 CppTypeFor<TypeCategory::Integer, 2> RTNAME(Nint16_2)(

     CppTypeFor<TypeCategory::Real, 16>);
 CppTypeFor<TypeCategory::Integer, 8> RTNAME(Nint16_8)(
     CppTypeFor<TypeCategory::Real, 16>);
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint16_16)(
     CppTypeFor<TypeCategory::Real, 16>);
+#endif
 
 // NEAREST
 // The second argument to NEAREST is the result of a comparison

flang/runtime/numeric.cpp

     CppTypeFor<TypeCategory::Real, 4> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling4_16)(
     CppTypeFor<TypeCategory::Real, 4> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling8_1)(
     CppTypeFor<TypeCategory::Real, 8> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 1>>(x);

     CppTypeFor<TypeCategory::Real, 8> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling8_16)(
     CppTypeFor<TypeCategory::Real, 8> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 #if LONG_DOUBLE == 80
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling10_1)(
     CppTypeFor<TypeCategory::Real, 10> x) {

     CppTypeFor<TypeCategory::Real, 10> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling10_16)(
     CppTypeFor<TypeCategory::Real, 10> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 #else
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling16_1)(
     CppTypeFor<TypeCategory::Real, 16> x) {

     CppTypeFor<TypeCategory::Real, 16> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Ceiling16_16)(
     CppTypeFor<TypeCategory::Real, 16> x) {
   return Ceiling<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
 #endif
+#endif
 
 CppTypeFor<TypeCategory::Integer, 4> RTNAME(Exponent4_4)(
     CppTypeFor<TypeCategory::Real, 4> x) {

     CppTypeFor<TypeCategory::Real, 4> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor4_16)(
     CppTypeFor<TypeCategory::Real, 4> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Floor8_1)(
     CppTypeFor<TypeCategory::Real, 8> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 1>>(x);

     CppTypeFor<TypeCategory::Real, 8> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor8_16)(
     CppTypeFor<TypeCategory::Real, 8> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 #if LONG_DOUBLE == 80
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Floor10_1)(
     CppTypeFor<TypeCategory::Real, 10> x) {

     CppTypeFor<TypeCategory::Real, 10> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor10_16)(
     CppTypeFor<TypeCategory::Real, 10> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 #else
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Floor16_1)(
     CppTypeFor<TypeCategory::Real, 16> x) {

     CppTypeFor<TypeCategory::Real, 16> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Floor16_16)(
     CppTypeFor<TypeCategory::Real, 16> x) {
   return Floor<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
 #endif
+#endif
 
 CppTypeFor<TypeCategory::Real, 4> RTNAME(Fraction4)(
     CppTypeFor<TypeCategory::Real, 4> x) {

     CppTypeFor<TypeCategory::Integer, 8> p) {
   return IntMod<false>(x, p);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(ModInteger16)(
     CppTypeFor<TypeCategory::Integer, 16> x,
     CppTypeFor<TypeCategory::Integer, 16> p) {
   return IntMod<false>(x, p);
 }
+#endif
 CppTypeFor<TypeCategory::Real, 4> RTNAME(ModReal4)(
     CppTypeFor<TypeCategory::Real, 4> x, CppTypeFor<TypeCategory::Real, 4> p) {
   return RealMod<false>(x, p);

     CppTypeFor<TypeCategory::Integer, 8> p) {
   return IntMod<true>(x, p);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(ModuloInteger16)(
     CppTypeFor<TypeCategory::Integer, 16> x,
     CppTypeFor<TypeCategory::Integer, 16> p) {
   return IntMod<true>(x, p);
 }
+#endif
 CppTypeFor<TypeCategory::Real, 4> RTNAME(ModuloReal4)(
     CppTypeFor<TypeCategory::Real, 4> x, CppTypeFor<TypeCategory::Real, 4> p) {
   return RealMod<true>(x, p);

     CppTypeFor<TypeCategory::Real, 4> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint4_16)(
     CppTypeFor<TypeCategory::Real, 4> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Nint8_1)(
     CppTypeFor<TypeCategory::Real, 8> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 1>>(x);

     CppTypeFor<TypeCategory::Real, 8> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint8_16)(
     CppTypeFor<TypeCategory::Real, 8> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 #if LONG_DOUBLE == 80
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Nint10_1)(
     CppTypeFor<TypeCategory::Real, 10> x) {

     CppTypeFor<TypeCategory::Real, 10> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint10_16)(
     CppTypeFor<TypeCategory::Real, 10> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
+#endif
 #else
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Nint16_1)(
     CppTypeFor<TypeCategory::Real, 16> x) {

     CppTypeFor<TypeCategory::Real, 16> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 8>>(x);
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(Nint16_16)(
     CppTypeFor<TypeCategory::Real, 16> x) {
   return Anint<CppTypeFor<TypeCategory::Integer, 16>>(x);
 }
 #endif
+#endif
 
 CppTypeFor<TypeCategory::Real, 4> RTNAME(RRSpacing4)(
     CppTypeFor<TypeCategory::Real, 4> x) {

flang/runtime/reduction.h

     int line, int dim = 0, const Descriptor *mask = nullptr);
 std::int64_t RTNAME(SumInteger8)(const Descriptor &, const char *source,
     int line, int dim = 0, const Descriptor *mask = nullptr);
+#ifdef __SIZEOF_INT128__
 common::int128_t RTNAME(SumInteger16)(const Descriptor &, const char *source,
     int line, int dim = 0, const Descriptor *mask = nullptr);
+#endif
 
 // REAL/COMPLEX(2 & 3) return 32-bit float results for the caller to downconvert
 float RTNAME(SumReal2)(const Descriptor &, const char *source, int line,

     int line, int dim = 0, const Descriptor *mask = nullptr);
 std::int64_t RTNAME(ProductInteger8)(const Descriptor &, const char *source,
     int line, int dim = 0, const Descriptor *mask = nullptr);
+#ifdef __SIZEOF_INT128__
 common::int128_t RTNAME(ProductInteger16)(const Descriptor &,
     const char *source, int line, int dim = 0,
     const Descriptor *mask = nullptr);
+#endif
 
 // REAL/COMPLEX(2 & 3) return 32-bit float results for the caller to downconvert
 float RTNAME(ProductReal2)(const Descriptor &, const char *source, int line,

     int line, int dim = 0, const Descriptor *mask = nullptr);
 std::int64_t RTNAME(MaxvalInteger8)(const Descriptor &, const char *source,
     int line, int dim = 0, const Descriptor *mask = nullptr);
+#ifdef __SIZEOF_INT128__
 common::int128_t RTNAME(MaxvalInteger16)(const Descriptor &, const char *source,
     int line, int dim = 0, const Descriptor *mask = nullptr);
+#endif
 float RTNAME(MaxvalReal2)(const Descriptor &, const char *source, int line,
     int dim = 0, const Descriptor *mask = nullptr);
 float RTNAME(MaxvalReal3)(const Descriptor &, const char *source, int line,

     int line, int dim = 0, const Descriptor *mask = nullptr);
 std::int64_t RTNAME(MivalInteger8)(const Descriptor &, const char *source,
     int line, int dim = 0, const Descriptor *mask = nullptr);
+#ifdef __SIZEOF_INT128__
 common::int128_t RTNAME(MivalInteger16)(const Descriptor &, const char *source,
     int line, int dim = 0, const Descriptor *mask = nullptr);
+#endif
 float RTNAME(MinvalReal2)(const Descriptor &, const char *source, int line,
     int dim = 0, const Descriptor *mask = nullptr);
 float RTNAME(MinvalReal3)(const Descriptor &, const char *source, int line,

flang/runtime/reduction.cpp

   using CppType = CppTypeFor<CAT, KIND>;
   DoTotalReduction<CppType>(x, dim, mask, accumulator, intrinsic, terminator);
   CppType result;
+#ifdef _MSC_VER // attempt to work around MSVC spurious error
+  accumulator.GetResult(&result);
+#else
   accumulator.template GetResult(&result);
+#endif
   return result;
 }
 

           TypeCategory::Integer, 8>(
           result, x, dim, mask, terminator, intrinsic);
       return;
+#ifdef __SIZEOF_INT128__
     case 16:
       PartialReduction<INTEGER_ACCUM<CppTypeFor<TypeCategory::Integer, 16>>,
           TypeCategory::Integer, 16>(
           result, x, dim, mask, terminator, intrinsic);
       return;
+#endif
     }
     break;
   case TypeCategory::Real:

   return GetTotalReduction<TypeCategory::Integer, 8>(x, source, line, dim, mask,
       IntegerSumAccumulator<CppTypeFor<TypeCategory::Integer, 8>>{x}, "SUM");
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(SumInteger16)(const Descriptor &x,
     const char *source, int line, int dim, const Descriptor *mask) {
   return GetTotalReduction<TypeCategory::Integer, 16>(x, source, line, dim,
       mask, IntegerSumAccumulator<CppTypeFor<TypeCategory::Integer, 16>>{x},
       "SUM");
 }
+#endif
 
 // TODO: real/complex(2 & 3)
 CppTypeFor<TypeCategory::Real, 4> RTNAME(SumReal4)(const Descriptor &x,

       NonComplexProductAccumulator<CppTypeFor<TypeCategory::Integer, 8>>{x},
       "PRODUCT");
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(ProductInteger16)(
     const Descriptor &x, const char *source, int line, int dim,
     const Descriptor *mask) {

       NonComplexProductAccumulator<CppTypeFor<TypeCategory::Integer, 16>>{x},
       "PRODUCT");
 }
+#endif
 
 // TODO: real/complex(2 & 3)
 CppTypeFor<TypeCategory::Real, 4> RTNAME(ProductReal4)(const Descriptor &x,

     accumulator.GetResult(
         result.OffsetElement<CppTypeFor<TypeCategory::Integer, 8>>());
     break;
+#ifdef __SIZEOF_INT128__
   case 16:
     accumulator.GetResult(
         result.OffsetElement<CppTypeFor<TypeCategory::Integer, 16>>());
     break;
+#endif
   default:
     terminator.Crash("%s: bad KIND=%d", intrinsic, kind);
   }

       DoMaxOrMinLoc<TypeCategory::Integer, 8, IS_MAX, NumericCompare>(
           intrinsic, result, x, kind, source, line, mask, back);
       return;
+#ifdef __SIZEOF_INT128__
     case 16:
       DoMaxOrMinLoc<TypeCategory::Integer, 16, IS_MAX, NumericCompare>(
           intrinsic, result, x, kind, source, line, mask, back);
       return;
+#endif
     }
     break;
   case TypeCategory::Real:

     PartialReduction<ExtremumLocAccumulator<COMPARE<CppType, IS_MAX, BACK>>,
         TypeCategory::Integer, 8>(result, x, dim, mask, terminator, intrinsic);
     break;
+#ifdef __SIZEOF_INT128__
   case 16:
     PartialReduction<ExtremumLocAccumulator<COMPARE<CppType, IS_MAX, BACK>>,
         TypeCategory::Integer, 16>(result, x, dim, mask, terminator, intrinsic);
     break;
+#endif
   default:
     terminator.Crash("%s: bad KIND=%d", intrinsic, kind);
   }

       DoPartialMaxOrMinLoc<TypeCategory::Integer, 8, IS_MAX, NumericCompare>(
           intrinsic, result, x, kind, dim, mask, back, terminator);
       return;
+#ifdef __SIZEOF_INT128__
     case 16:
       DoPartialMaxOrMinLoc<TypeCategory::Integer, 16, IS_MAX, NumericCompare>(
           intrinsic, result, x, kind, dim, mask, back, terminator);
       return;
+#endif
     }
     break;
   case TypeCategory::Real:

           NumericExtremumAccumulator>(
           result, x, dim, mask, intrinsic, terminator);
       return;
+#ifdef __SIZEOF_INT128__
     case 16:
       DoMaxOrMin<TypeCategory::Integer, 16, IS_MAXVAL,
           NumericExtremumAccumulator>(
           result, x, dim, mask, intrinsic, terminator);
       return;
+#endif
     }
     break;
   case TypeCategory::Real:

   return TotalNumericMaxOrMin<TypeCategory::Integer, 8, true>(
       x, source, line, dim, mask, "MAXVAL");
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(MaxvalInteger16)(
     const Descriptor &x, const char *source, int line, int dim,
     const Descriptor *mask) {
   return TotalNumericMaxOrMin<TypeCategory::Integer, 16, true>(
       x, source, line, dim, mask, "MAXVAL");
 }
+#endif
 
 // TODO: REAL(2 & 3)
 CppTypeFor<TypeCategory::Real, 4> RTNAME(MaxvalReal4)(const Descriptor &x,

   return TotalNumericMaxOrMin<TypeCategory::Integer, 8, false>(
       x, source, line, dim, mask, "MINVAL");
 }
+#ifdef __SIZEOF_INT128__
 CppTypeFor<TypeCategory::Integer, 16> RTNAME(MinvalInteger16)(
     const Descriptor &x, const char *source, int line, int dim,
     const Descriptor *mask) {
   return TotalNumericMaxOrMin<TypeCategory::Integer, 16, false>(
       x, source, line, dim, mask, "MINVAL");
 }
+#endif
 
 // TODO: REAL(2 & 3)
 CppTypeFor<TypeCategory::Real, 4> RTNAME(MinvalReal4)(const Descriptor &x,

   case 8:
     CountDimension<8>(result, x, dim, terminator);
     break;
+#ifdef __SIZEOF_INT128__
   case 16:
     CountDimension<16>(result, x, dim, terminator);
     break;
+#endif
   default:
     terminator.Crash("COUNT: bad KIND=%d", kind);
   }