[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/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

           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);
   }