Re: gfortran 4.2 exponentiation failure on cygwin

[Tim Prince <tprince at myrealbox dot com>]

Steve Kargl wrote:
> On Wed, Dec 14, 2005 at 02:29:28PM -0800, Tim Prince wrote:
>
> > All programs using real ** power (double precision) have been failing 
> > (segv), using gcc-4.2 on my cygwin installation.  gfortran-4.0.3 works 
> > fine, and both 4.0.3 and 4.2 work on 32-bit SuSE 9.2.  For example:
> >        program powtest
> >        common/test/a,b
> >        double precision a,b
> >        a=sqrt(huge(1d0))
> >        b=a**2.
>
>
> Do you have decimal point after the 2 on purpose?
>
>
> >        write(*,*)a,' squared =',b
> >        end
> > In the examples, when I try to debug under insight, I can step up to the 
> > first statement which includes **, but insight hangs when I attempt to 
> > step into it.  If I set 'b __gfortran_pow_r8_i4' (in a case where the 
>
>
> because __gfortran_pow_r8_i4 does not correspond to that case
>
>
> > compilation calls that function), insight also hangs when I click 
> > Continue, and never reaches the break point.  I have been at a loss to 
> > figure this out any further.  The example above simply generates in-line 
> > code, yet it also crashes on cygwin.
>
>
> Try -fdump-tree-original on cygwin.  You'll get a *.t0.original file.
>
> troutmask:kargl[216] gfc -o z -fdump-tree-original tim.f90
> troutmask:kargl[217] more tim.f90.t02.original
> MAIN__ ()
> {
>   a = 1.34078079299425956110083176408029342824642072659591070215e+154;
>   {
>     real8 D.927;
>
>     D.927 = a;
>     b = __builtin_pow (D.927, 2.0e+0);
>   }
>
> You can also look at the parse tree.  This shows
>
>       ASSIGN MAIN__:a 1.3407807929942596e154_8
>       ASSIGN MAIN__:b (** MAIN__:a 2.0000000000000000_8)
>       WRITE UNIT=6 FMT=-1
>         TRANSFER MAIN__:a
>         TRANSFER ' squared ='
>         TRANSFER MAIN__:b
>       DT_END
>  
> These options may give a clue as to the problem.
The C version has no problem.  I put the decimal point on 2. 
intentionally, thinking it might make a difference, but it doesn't. 
Also, the behavior is the same with smaller operands, although I thought 
originally there might be a possibility of the problem being associated 
with corner cases.
I have attached the .c and .f and corresponding .original files.

Thanks,

Tim
#include "float.h"
#include "math.h"
#include "stdio.h"
int main(){
	double a=sqrt(DBL_MAX);
	double b=a*a;
	printf("%g squared = %g\n",a,b);
	}

;; Function __sgn (__sgn)
;; enabled by -tree-original


{
  return __x == 0.0 ? 0.0 : __x > 0.0 ? 1.0e+0 : -1.0e+0;
}



;; Function __sgnf (__sgnf)
;; enabled by -tree-original

{
  return __x == 0.0 ? 0.0 : __x > 0.0 ? 1.0e+0 : -1.0e+0;
}



;; Function __sgnl (__sgnl)
;; enabled by -tree-original

{
  return __x == 0.0 ? 0.0 : __x > 0.0 ? 1.0e+0 : -1.0e+0;
}



;; Function __pow2 (__pow2)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long long int __p = (long long int) __x;

  <STATEMENT_LIST>
}



;; Function __pow2f (__pow2f)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long long int __p = (long long int) __x;

  <STATEMENT_LIST>
}



;; Function __pow2l (__pow2l)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long long int __p = (long long int) __x;

  <STATEMENT_LIST>
}



;; Function __sincos (__sincos)
;; enabled by -tree-original

{
  long double __cosr;
  long double __sinr;

  <STATEMENT_LIST>
}



;; Function __sincosf (__sincosf)
;; enabled by -tree-original

{
  long double __cosr;
  long double __sinr;

  <STATEMENT_LIST>
}



;; Function __sincosl (__sincosl)
;; enabled by -tree-original

{
  long double __cosr;
  long double __sinr;

  <STATEMENT_LIST>
}



;; Function rint (rint)
;; enabled by -tree-original

{
  double __result;

  <STATEMENT_LIST>
}



;; Function rintf (rintf)
;; enabled by -tree-original

{
  float __result;

  <STATEMENT_LIST>
}



;; Function rintl (rintl)
;; enabled by -tree-original

{
  long double __result;

  <STATEMENT_LIST>
}



;; Function __expm1l (__expm1l)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long double __temp;

  <STATEMENT_LIST>
}



;; Function __expm1h (__expm1h)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long double __temp;

  <STATEMENT_LIST>
}



;; Function __expl (__expl)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long double __temp;

  <STATEMENT_LIST>
}



;; Function exp (exp)
;; enabled by -tree-original

{
  <STATEMENT_LIST>
}



;; Function expf (expf)
;; enabled by -tree-original

{
  <STATEMENT_LIST>
}



;; Function expl (expl)
;; enabled by -tree-original

{
  <STATEMENT_LIST>
}



;; Function __exph (__exph)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long double __temp;

  <STATEMENT_LIST>
}



;; Function tan (tan)
;; enabled by -tree-original

{
  long double __value;
  long double __value2;

  <STATEMENT_LIST>
}



;; Function tanf (tanf)
;; enabled by -tree-original

{
  long double __value;
  long double __value2;

  <STATEMENT_LIST>
}



;; Function tanl (tanl)
;; enabled by -tree-original

{
  long double __value;
  long double __value2;

  <STATEMENT_LIST>
}



;; Function atan2 (atan2)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function atan2f (atan2f)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function atan2l (atan2l)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function __atan2l (__atan2l)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function atan (atan)
;; enabled by -tree-original

{
  return (double) __atan2l ((long double) __y, 1.0e+0);
}



;; Function atanf (atanf)
;; enabled by -tree-original

{
  return (float) __atan2l ((long double) __y, 1.0e+0);
}



;; Function atanl (atanl)
;; enabled by -tree-original

{
  return __atan2l (__y, 1.0e+0);
}



;; Function fmod (fmod)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function fmodf (fmodf)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function fmodl (fmodl)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function fabs (fabs)
;; enabled by -tree-original

{
  return ABS_EXPR <__x>;
}



;; Function fabsf (fabsf)
;; enabled by -tree-original

{
  return ABS_EXPR <__x>;
}



;; Function fabsl (fabsl)
;; enabled by -tree-original

{
  return ABS_EXPR <__x>;
}



;; Function __fabsl (__fabsl)
;; enabled by -tree-original

{
  return ABS_EXPR <__x>;
}



;; Function __sqrtl (__sqrtl)
;; enabled by -tree-original

{
  return __builtin_sqrtl (__x);
}



;; Function sin (sin)
;; enabled by -tree-original

{
  double __result;

  <STATEMENT_LIST>
}



;; Function sinf (sinf)
;; enabled by -tree-original

{
  float __result;

  <STATEMENT_LIST>
}



;; Function sinl (sinl)
;; enabled by -tree-original

{
  long double __result;

  <STATEMENT_LIST>
}



;; Function cos (cos)
;; enabled by -tree-original

{
  double __result;

  <STATEMENT_LIST>
}



;; Function cosf (cosf)
;; enabled by -tree-original

{
  float __result;

  <STATEMENT_LIST>
}



;; Function cosl (cosl)
;; enabled by -tree-original

{
  long double __result;

  <STATEMENT_LIST>
}



;; Function log (log)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function logf (logf)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function logl (logl)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function log10 (log10)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function log10f (log10f)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function log10l (log10l)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function __sgn1l (__sgn1l)
;; enabled by -tree-original

{
  return __x >= 0.0 ? 1.0e+0 : -1.0e+0;
}



;; Function sinh (sinh)
;; enabled by -tree-original

{
  long double __exm1 = __expm1h ((long double) __x);

  <STATEMENT_LIST>
}



;; Function sinhf (sinhf)
;; enabled by -tree-original

{
  long double __exm1 = __expm1h ((long double) __x);

  <STATEMENT_LIST>
}



;; Function sinhl (sinhl)
;; enabled by -tree-original

{
  long double __exm1 = __expm1h (__x);

  <STATEMENT_LIST>
}



;; Function cosh (cosh)
;; enabled by -tree-original

{
  long double __ex = __exph (__fabsl ((long double) __x));

  <STATEMENT_LIST>
}



;; Function coshf (coshf)
;; enabled by -tree-original

{
  long double __ex = __exph (__fabsl ((long double) __x));

  <STATEMENT_LIST>
}



;; Function coshl (coshl)
;; enabled by -tree-original

{
  long double __ex = __exph (__fabsl (__x));

  <STATEMENT_LIST>
}



;; Function tanh (tanh)
;; enabled by -tree-original

{
  <STATEMENT_LIST>
}



;; Function tanhf (tanhf)
;; enabled by -tree-original

{
  <STATEMENT_LIST>
}



;; Function tanhl (tanhl)
;; enabled by -tree-original

{
  <STATEMENT_LIST>
}



;; Function floor (floor)
;; enabled by -tree-original

{
  long double __value;
  short unsigned int __cw;
  short unsigned int __cwtmp;

  <STATEMENT_LIST>
}



;; Function floorf (floorf)
;; enabled by -tree-original

{
  long double __value;
  short unsigned int __cw;
  short unsigned int __cwtmp;

  <STATEMENT_LIST>
}



;; Function floorl (floorl)
;; enabled by -tree-original

{
  long double __value;
  short unsigned int __cw;
  short unsigned int __cwtmp;

  <STATEMENT_LIST>
}



;; Function ceil (ceil)
;; enabled by -tree-original

{
  long double __value;
  short unsigned int __cw;
  short unsigned int __cwtmp;

  <STATEMENT_LIST>
}



;; Function ceilf (ceilf)
;; enabled by -tree-original

{
  long double __value;
  short unsigned int __cw;
  short unsigned int __cwtmp;

  <STATEMENT_LIST>
}



;; Function ceill (ceill)
;; enabled by -tree-original

{
  long double __value;
  short unsigned int __cw;
  short unsigned int __cwtmp;

  <STATEMENT_LIST>
}



;; Function ldexp (ldexp)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function expm1 (expm1)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long double __temp;

  <STATEMENT_LIST>
}



;; Function expm1f (expm1f)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long double __temp;

  <STATEMENT_LIST>
}



;; Function expm1l (expm1l)
;; enabled by -tree-original

{
  long double __value;
  long double __exponent;
  long double __temp;

  <STATEMENT_LIST>
}



;; Function log1p (log1p)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function log1pf (log1pf)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function log1pl (log1pl)
;; enabled by -tree-original

{
  long double __value;

  <STATEMENT_LIST>
}



;; Function asinh (asinh)
;; enabled by -tree-original

{
  long double __y = __fabsl ((long double) __x);

  <STATEMENT_LIST>
}



;; Function asinhf (asinhf)
;; enabled by -tree-original

{
  long double __y = __fabsl ((long double) __x);

  <STATEMENT_LIST>
}



;; Function asinhl (asinhl)
;; enabled by -tree-original

{
  long double __y = __fabsl (__x);

  <STATEMENT_LIST>
}



;; Function acosh (acosh)
;; enabled by -tree-original

{
  return (double) logl ((long double) __x + __sqrtl ((long double) (__x - 1.0e+0)) * __sqrtl ((long double) (__x + 1.0e+0)));
}



;; Function acoshf (acoshf)
;; enabled by -tree-original

{
  return (float) logl ((long double) __x + __sqrtl ((long double) ((double) __x - 1.0e+0)) * __sqrtl ((long double) ((double) __x + 1.0e+0)));
}



;; Function acoshl (acoshl)
;; enabled by -tree-original

{
  return logl (__sqrtl (__x - 1.0e+0) * __sqrtl (__x + 1.0e+0) + __x);
}



;; Function atanh (atanh)
;; enabled by -tree-original

{
  return (double) (log1pl ((long double) __x / (__fabsl ((long double) __x) + 1.0e+0) * 2.0e+0) * 5.0e-1);
}



;; Function atanhf (atanhf)
;; enabled by -tree-original

{
  return (float) (log1pl ((long double) __x / (__fabsl ((long double) __x) + 1.0e+0) * 2.0e+0) * 5.0e-1);
}



;; Function atanhl (atanhl)
;; enabled by -tree-original

{
  return log1pl (__x / (__fabsl (__x) + 1.0e+0) * 2.0e+0) * 5.0e-1;
}



;; Function hypot (hypot)
;; enabled by -tree-original

{
  return (double) __sqrtl ((long double) (__x * __x + __y * __y));
}



;; Function hypotf (hypotf)
;; enabled by -tree-original

{
  return (float) __sqrtl ((long double) (__x * __x + __y * __y));
}



;; Function hypotl (hypotl)
;; enabled by -tree-original

{
  return __sqrtl (__x * __x + __y * __y);
}



;; Function logb (logb)
;; enabled by -tree-original

{
  long double __value;
  long double __junk;

  <STATEMENT_LIST>
}



;; Function logbf (logbf)
;; enabled by -tree-original

{
  long double __value;
  long double __junk;

  <STATEMENT_LIST>
}



;; Function logbl (logbl)
;; enabled by -tree-original

{
  long double __value;
  long double __junk;

  <STATEMENT_LIST>
}



;; Function drem (drem)
;; enabled by -tree-original

{
  double __value;
  int __clobbered;

  <STATEMENT_LIST>
}



;; Function dremf (dremf)
;; enabled by -tree-original

{
  double __value;
  int __clobbered;

  <STATEMENT_LIST>
}



;; Function dreml (dreml)
;; enabled by -tree-original

{
  double __value;
  int __clobbered;

  <STATEMENT_LIST>
}



;; Function __finite (__finite)
;; enabled by -tree-original

{
  typedef union 
  {
    double __d;
    int __i[2];
  } unionunion 
  {
    double __d;
    int __i[2];
  };

  return (int) (((unsigned int) <<< Unknown tree: compound_literal_expr
    union 
  {
    double __d;
    int __i[2];
  } D.3039 = {.__d=__x}; >>>
.__i[1] | 0800fffff) + 1 >> 31);
}



;; Function __coshm1 (__coshm1)
;; enabled by -tree-original

{
  long double __exm1 = __expm1l (__fabsl ((long double) __x));

  <STATEMENT_LIST>
}



;; Function __coshm1f (__coshm1f)
;; enabled by -tree-original

{
  long double __exm1 = __expm1l (__fabsl ((long double) __x));

  <STATEMENT_LIST>
}



;; Function __coshm1l (__coshm1l)
;; enabled by -tree-original

{
  long double __exm1 = __expm1l (__fabsl (__x));

  <STATEMENT_LIST>
}



;; Function __acosh1p (__acosh1p)
;; enabled by -tree-original

{
  return (double) log1pl ((long double) __x + __sqrtl ((long double) __x) * __sqrtl ((long double) (__x + 2.0e+0)));
}



;; Function __acosh1pf (__acosh1pf)
;; enabled by -tree-original

{
  return (float) log1pl ((long double) __x + __sqrtl ((long double) __x) * __sqrtl ((long double) ((double) __x + 2.0e+0)));
}



;; Function __acosh1pl (__acosh1pl)
;; enabled by -tree-original

{
  return log1pl (__sqrtl (__x) * __sqrtl (__x + 2.0e+0) + __x);
}



;; Function __sgetc (__sgetc)
;; enabled by -tree-original

{
  int __c =  --__p->_r < 0 ? __srget (__p) : (int) *__p->_p++ ;

  <STATEMENT_LIST>
}



;; Function main (main)
;; enabled by -tree-original

{
  double a = 1.3407807929942595611008317640802934282464207266e+154;
  double b = a * a;

  <STATEMENT_LIST>
}


	program powtest
	common/test/a,b
	double precision a,b
	a=sqrt(sqrt(huge(1d0)))
	b=a**2
	write(*,*)a,' squared =',b
	end

MAIN__ ()
{
  a = 1.3407807929942595611008317640802934282464207266e+154;
  {
    real8 D.606;

    D.606 = a;
    b = __builtin_pow (D.606, 2.0e+0);
  }
  {
    struct __st_parameter_dtquire dt_parm.0;

    dt_parm.0.common.filename = "powtest.f";
    dt_parm.0.common.line = 6;
    dt_parm.0.common.unit = 6;
    dt_parm.0.common.flags = 128;
    _gfortran_st_write (&dt_parm.0);
    _gfortran_transfer_real (&dt_parm.0, &a, 8);
    _gfortran_transfer_character (&dt_parm.0, " squared =", 10);
    _gfortran_transfer_real (&dt_parm.0, &b, 8);
    _gfortran_st_write_done (&dt_parm.0);
  }