[Bug fortran/57628] spurious error: division by zero in if statement

["furue at hawaii dot edu" <gcc-bugzilla@gcc.gnu.org>]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57628

--- Comment #9 from Ryo Furue <furue at hawaii dot edu> ---
(In reply to Steve Kargl from comment #8)

> So, the compiler should just arbitrarily chose to evaluate
> some expression and ignore others?

No, I don't mean that.  I'm not saying which expression the compiler should
evaluate.  What I'm saying is, what is the best way to deal with the result of
the evaluation?

The compiler "can" (or "should"?) evaluate 1/a at compile time if a is a
parameter.  But, it's "useful" to provide an option that allows the compiler to
let the code pass even if a == 0 (with a warning message, perhaps).  That's
what I argue.

I don't think the compiler "must" evaluate "1/a" or "a>0" at compile time. 
It's at the compiler's discretion.  But, whatever it does "should" be maximally
"useful" (as long as the chosen behavior does not violate the Fortran
standard).

> Just remove the PARAMETER attribute in your code, it it will
> do what you.
> 
> real :: a = 0
> if (a > 0) then
>    print *, 1/a
[. . .]

Yes, I was about to come to that!  I write my code that way because I plan to
provide the value of "a" from an external module in the future.  Currently I
set the value with PARAMETER just as a convenience during the development of
the code.  So, you are right, that your solution is one workaround for my
situation.

But, I feel strongly uneasy looking at the code because "real::a = 0" is a
strong indication that the value of "a" will be altered after the definition. 
The codes we are showing in this message exchange are shortened versions and in
my real codes, there are some lines between "real, parameter:: a = 0" and the
IF statement.  When I see "real:: a = 0.0", I expect the value of "a" will be
altered because I don't see PARAMETER.

Also, I still don't like this (sort of) "inconsistency".  It's more natural to
expect the outcome of the code be the same whether it's "real, parameter:: a =
0" or "real:: a = 0".  Another example is,

  real, parameter:: a = -1.0
  if (a > 0) write(*,*) sqrt(a)

This does not compile.  If we replace sqrt with yoursqrt, it compiles. (I know
the reason why gfortran does this.  That's not my question.)

Overall, I think this kind of thing is better be a "warning" and that at least
the compiler should allow the user to run such a code as this.  The result of
the run may be a disaster but it's the user's responsibility.  To refuse to
compile these codes is too much patronizing on the part of the compiler.

Cheers,
Ryo

P.S. How does this interact with the IEEE support of F2003?  I may be wrong,
but I thought that replacing 1.0/0.0 with "Inf" at compile time would be a
useful extension (without violating the Fortran standard, of course).  Again,
I'm not saying the compiler must do this.  All I'm saying is that it may be
useful.