The functions do not work with `gfortran-13 -Ofast -flto`

[zaikunzhang]

gtest fails if gfortran-13 is invoked with -Ofast -flto, which runs the standard link-time optimizer.

[zaikunzhang]

gfortran-10, gfortran-11, and gfortran-12 do not have the same problem.

[zaikunzhang]

Note that the problem remains even if we define posinf and neginf as follows (in a separated file) and use them instead of huge_value to define is_nan. See d9504b0.

module inf_values_mod                                                                                                                   
                                                                                                                                        
use, intrinsic :: ieee_arithmetic, only : ieee_value, ieee_negative_inf, ieee_positive_inf                                              
implicit none                                                                                                                           
private                                                                                                                                 
public :: posinf, neginf                                                                                                                                                                                   
interface posinf                                                                                                                        
    module procedure posinf_sp, posinf_dp                                                                                               
end interface posinf                                                                                                                    
                                                                                                                                        
interface neginf                                                                                                                        
    module procedure neginf_sp, neginf_dp                                                                                               
end interface neginf                                                                                                                    
                                                                                                                                        
contains                                                                                                                                
                                                                                                                                        
pure function posinf_sp(x) result(y)                                                                                                    
use, non_intrinsic :: consts_mod, only : SP                                                                                             
implicit none                                                                                                                           
real(SP), intent(in) :: x                                                                                                               
real(SP) :: y                                                                                                                           
y = ieee_value(x, ieee_positive_inf)                                                                                                    
end function posinf_sp                                                                                                                  
                                                                                                                                        
pure function posinf_dp(x) result(y)                                                                                                    
use, non_intrinsic :: consts_mod, only : DP                                                                                             
implicit none                                                                                                                           
real(DP), intent(in) :: x                                                                                                               
real(DP) :: y                                                                                                                           
y = ieee_value(x, ieee_positive_inf)                                                                                                    
end function posinf_dp                                                                                                                  
                                                                                                                                        
                                                                                                                                        
pure function neginf_sp(x) result(y)                                                                                                    
use, non_intrinsic :: consts_mod, only : SP                                                                                             
implicit none                                                                                                                           
real(SP), intent(in) :: x                                                                                                               
real(SP) :: y                                                                                                                           
y = ieee_value(x, ieee_negative_inf)                                                                                                    
end function neginf_sp                                                                                                                  
                                                                                                                                        
pure function neginf_dp(x) result(y)                                                                                                    
use, non_intrinsic :: consts_mod, only : DP                                                                                             
implicit none                                                                                                                           
real(DP), intent(in) :: x                                                                                                               
real(DP) :: y                                                                                                                           
y = ieee_value(x, ieee_negative_inf)                                                                                                    
end function neginf_dp                                                                                                                  
                                                                                                                                        
                                                                                                                                        
end module inf_values_mod