[Fortran] Conditionally add real16 test

I replicated the floating point conversion test for real(kind=16).
Instead of trying to keep both tests in the same source file, I broke
it into two tests and only enabled one when the fortran compiler
can compile a test program using real16.

Author: ashermancinelli

Fortran/UnitTests/fp_conversions/CMakeLists.txt

@@ -1,5 +1,21 @@
+include(CheckFortranSourceCompiles)
+
+CHECK_FORTRAN_SOURCE_COMPILES("
+real(kind=16)::r
+integer(kind=16)::i
+end
+" FORTRAN_HAS_R16)
+
 list(APPEND FFLAGS -funsigned)
 
-llvm_singlesource()
+if(FORTRAN_HAS_R16)
+  message(STATUS "Fortran compiler supports real(kind=16)")
+  set(Source fp_convert_r16.f90)
+  llvm_singlesource()
+else()
+  message(STATUS "Fortran compiler does not support real(kind=16)")
+endif()
 
+set(Source fp_convert.f90)
+llvm_singlesource()
 file(COPY lit.local.cfg DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")

Fortran/UnitTests/fp_conversions/fp_convert.f90

@@ -1,7 +1,5 @@
 module fp_convert_m
-  use iso_fortran_env
   implicit none
-  integer            :: test_case = 1
   type answer
     integer(kind=1)  :: i8
     integer(kind=2)  :: i16
@@ -12,72 +10,23 @@ module fp_convert_m
     unsigned(kind=4) :: u32
     unsigned(kind=8) :: u64
   end type answer
-  type(answer)       :: answers(6)
-
-  interface operator(==)
-    module procedure answer_eq
-  end interface operator(==)
 
 contains
-
-  subroutine init_answers()
-    ! huge
-    answers(1) = answer( &
-                  127, 32767, 2147483647, 9223372036854775807_8, &
-                  unsigned(255, kind=1), &
-                  unsigned(65535, kind=2), &
-                  unsigned(4294967295, kind=4), &
-                  unsigned(18446744073709551615, kind=8))
-
-    ! -huge
-    answers(2) = answer( &
-                  -128, -32768, -2147483648, -9223372036854775808_8, &
-                  unsigned(0, kind=1), &
-                  unsigned(0, kind=2), &
-                  unsigned(0, kind=4), &
-                  unsigned(0, kind=8))
-
-    ! tiny
-    answers(3) = answer( &
-                  0, 0, 0, 0, &
-                  unsigned(0, kind=1), &
-                  unsigned(0, kind=2), &
-                  unsigned(0, kind=4), &
-                  unsigned(0, kind=8))
-
-    ! -tiny
-    answers(4) = answers(3)
-
-    ! inf
-    answers(5) = answer( &
-                  127, 32767, 2147483647, 9223372036854775807_8, &
-                  unsigned(255, kind=1), &
-                  unsigned(65535, kind=2), &
-                  unsigned(4294967295, kind=4), &
-                  unsigned(18446744073709551615, kind=8))
-
-    ! -inf
-    answers(6) = answer( &
-                  -128, -32768, -2147483648, -9223372036854775808_8, &
-                  unsigned(0, kind=1), &
-                  unsigned(0, kind=2), &
-                  unsigned(0, kind=4), &
-                  unsigned(0, kind=8))
-  end subroutine init_answers
   subroutine print_answer(a)
     type(answer), intent(in) :: a
-    print *, a%i8, a%i16, a%i32, a%i64, a%u8, a%u16, a%u32, a%u64
+    print *, a%i8
+    print *, a%i16
+    print *, a%i32
+    print *, a%i64
+    print *, a%u8
+    print *, a%u16
+    print *, a%u32
+    print *, a%u64
   end subroutine print_answer
 
-  logical function answer_eq(a, b)
-    type(answer), intent(in) :: a, b
-    answer_eq = a%i8 == b%i8 .and. a%i16 == b%i16 .and. a%i32 == b%i32 .and. a%i64 == b%i64 &
-                        .and. a%u8 == b%u8 .and. a%u16 == b%u16 .and. a%u32 == b%u32 .and. a%u64 == b%u64
-  end function answer_eq
-
-  subroutine do_conversion(value, result)
+  function do_conversion(value) result(result)
     real(kind=8), intent(in) :: value
-    type(answer), intent(out) :: result
+    type(answer) :: result
     result%i8 = int(value, kind=1)
     result%i16 = int(value, kind=2)
     result%i32 = int(value, kind=4)
@@ -87,24 +36,14 @@ subroutine do_conversion(value, result)
     result%u16 = uint(value, kind=2)
     result%u32 = uint(value, kind=4)
     result%u64 = uint(value, kind=8)
-  end subroutine
+  end function do_conversion
 
-  subroutine testcase(value, answers)
+  subroutine testcase(value)
     real(kind=8), intent(in) :: value
-    type(answer), intent(in) :: answers
     type(answer) :: result
-    call do_conversion(value, result)
-    if (result == answers) then
-      print *, "PASS", test_case
-    else
-      print *, "FAIL", test_case
-      print *, "Expected:"
-      call print_answer(answers)
-      print *, "Got:"
-      call print_answer(result)
-    end if
-    test_case = test_case + 1
-  end subroutine
+    result = do_conversion(value)
+    call print_answer(result)
+  end subroutine testcase
 end module fp_convert_m
 
 program fp_convert
@@ -114,28 +53,29 @@ program fp_convert
 
   real(kind=8) :: r64, nan, inf, ninf
 
-  call init_answers()
-
   nan = ieee_value(nan, ieee_quiet_nan)
   inf = ieee_value(inf, ieee_positive_inf)
   ninf = ieee_value(ninf, ieee_negative_inf)
 
   print *, "huge"
-  call testcase(huge(r64), answers(1))
+  call testcase(huge(r64))
 
   print *, "-huge"
-  call testcase(-huge(r64), answers(2))
+  call testcase(-huge(r64))
 
   print *, "tiny"
-  call testcase(tiny(r64), answers(3))
+  call testcase(tiny(r64))
 
   print *, "-tiny"
-  call testcase(-tiny(r64), answers(4))
+  call testcase(-tiny(r64))
 
   print *, "inf"
-  call testcase(inf, answers(5))
+  call testcase(inf)
 
   print *, "-inf"
-  call testcase(ninf, answers(6))
+  call testcase(ninf)
+
+  print *, "nan"
+  call testcase(nan)
 
 end program fp_convert

Fortran/UnitTests/fp_conversions/fp_convert.reference_output

@@ -1,13 +1,64 @@
  huge
- PASS 1
+ 127
+ 32767
+ 2147483647
+ 9223372036854775807
+ 255
+ 65535
+ 4294967295
+ 18446744073709551615
  -huge
- PASS 2
+ -128
+ -32768
+ -2147483648
+ -9223372036854775808
+ 0
+ 0
+ 0
+ 0
  tiny
- PASS 3
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
  -tiny
- PASS 4
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
  inf
- PASS 5
+ 127
+ 32767
+ 2147483647
+ 9223372036854775807
+ 255
+ 65535
+ 4294967295
+ 18446744073709551615
  -inf
- PASS 6
+ -128
+ -32768
+ -2147483648
+ -9223372036854775808
+ 0
+ 0
+ 0
+ 0
+ nan
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
+ 0
 exit 0

Fortran/UnitTests/fp_conversions/fp_convert_r16.f90

@@ -0,0 +1,86 @@
+module fp_convert_m
+  implicit none
+  type answer
+    integer(kind=1)   :: i8
+    integer(kind=2)   :: i16
+    integer(kind=4)   :: i32
+    integer(kind=8)   :: i64
+    integer(kind=16)  :: i128
+    unsigned(kind=1)  :: u8
+    unsigned(kind=2)  :: u16
+    unsigned(kind=4)  :: u32
+    unsigned(kind=8)  :: u64
+    unsigned(kind=16) :: u128
+  end type answer
+contains
+
+  subroutine print_answer(a)
+    type(answer), intent(in) :: a
+    print *, a%i8
+    print *, a%i16
+    print *, a%i32
+    print *, a%i64
+    print *, a%i128
+    print *, a%u8
+    print *, a%u16
+    print *, a%u32
+    print *, a%u64
+    print *, a%u128
+  end subroutine print_answer
+
+  function do_conversion(value) result(result)
+    real(kind=16), intent(in) :: value
+    type(answer) :: result
+    result%i8 = int(value, kind=1)
+    result%i16 = int(value, kind=2)
+    result%i32 = int(value, kind=4)
+    result%i64 = int(value, kind=8)
+    result%i128 = int(value, kind=16)
+    result%u8 = uint(value, kind=1)
+    result%u16 = uint(value, kind=2)
+    result%u32 = uint(value, kind=4)
+    result%u64 = uint(value, kind=8)
+    result%u128 = uint(value, kind=16)
+  end function do_conversion
+
+  subroutine testcase(value)
+    real(kind=16), intent(in) :: value
+    type(answer) :: result
+    result = do_conversion(value)
+    call print_answer(result)
+  end subroutine
+end module fp_convert_m
+
+program fp_convert
+  use ieee_arithmetic, only: ieee_value, ieee_quiet_nan, ieee_positive_inf, ieee_negative_inf
+  use fp_convert_m
+  implicit none
+
+  real(kind=16) :: r128, nan, inf, ninf
+
+  nan = ieee_value(nan, ieee_quiet_nan)
+  inf = ieee_value(inf, ieee_positive_inf)
+  ninf = ieee_value(ninf, ieee_negative_inf)
+
+  print *, "huge"
+  call testcase(huge(r128))
+
+  print *, "-huge"
+  call testcase(-huge(r128))
+
+  print *, "tiny"
+  call testcase(tiny(r128))
+
+  print *, "-tiny"
+  call testcase(-tiny(r128))
+
+  print *, "inf"
+  call testcase(inf)
+
+  print *, "-inf"
+  call testcase(ninf)
+
+  print *, "nan"
+  call testcase(nan)
+
+end program fp_convert