Conference turris::fortran

/su is needed so that overflows can produce infinities, and other bad
operations (such as division by zero) can produce NaN's.

No trapb is needed after the first muls/su because (roughly) none of its
inputs are overwritten by later instructions.  The first trapb is inserted
right before an addq r4,r9,r4 instruction that overwrites its own input
-- it would be incorrect to reexecute this instruction when resuming after
a trap.  All the other trapb's in this example are for a similar case.
See the Alpha Architecture Handbook or the Alpha Architecture Reference Manual,
section 4.7.6.1 for the rules the compiler follows when deciding where a
trapb is needed.

How common is it for performance-sensitive Alpha code to be compiled with
a -fpe mode other than zero?  The example posted has many more trapb's than
are strictly needed -- is it important for the compiler to generate better
code for these cases?

    	It would be useful to see exactly the error message that got
    generated.  If you are trying to use the debugger, please do a
    "ignore fpe" so that any exception will get handled properly by
    the RTL.  Generally speaking, normal floating point code which
    is compiled -fpe1 may encounter underflows, but they should not
    cause any "failures" - might slow things down a bit, but that's
    about all.  If there really is a "failure", we need to have a
    reproducible case (for example, that zero you saw in the register
    may be something else, like a denormalized number).  There is
    nothing that I noticed that was remotely suspicious about the
    generated code.  We are going to need more information in order
    to help you - best is an executable example, using more current
    software.  
    
    Cheers!
    Dave Eklund
    

>  io_status = for_set_fpe_(&0x00010001);

This asks the FORTRAN RTL to trap underflows and replace the result with zero.
In order to do this, the FORTRAN RTL's signal handler needs to be established.
Does the for_set_fpe() call do that?  Or does it depend on the main program
being a FORTRAN program compiled with -fpe1?

Or does this routine "pattern match" for this set of requests, and translate
it into a call to ieee_set_fp_control() to set IEEE_MAP_UMZ, so that the
operating system maps underflows to zero without signaling an exception?

>  io_status = for_set_fpe_(&0x00010001);

This asks the FORTRAN RTL to trap underflows and replace the result with zero.
In order to do this, the FORTRAN RTL's signal handler needs to be established.
Does the for_set_fpe() call do that?  Or does it depend on the main program
being a FORTRAN program compiled with -fpe1?

>> The forrtl signal handler gets established by for_rtl_init_().
   Doesn't depend on the -fpe option.

Or does this routine "pattern match" for this set of requests, and translate
it into a call to ieee_set_fp_control() to set IEEE_MAP_UMZ, so that the
operating system maps underflows to zero without signaling an exception?

>> for_set_fpe() maps the bits of the input arg to a similar mask to
   ieee_set_fp_control().  In this case, the rtl will set both IEEE_MAP_UMZ
   and IEEE_TRAP_ENABLE_UNF in the call to ieee_set_fp_control().

>> The forrtl signal handler gets established by for_rtl_init_().
   Doesn't depend on the -fpe option.

Who is responsible for calling for_rtl_init when the main program isn't
Fortran, as in .0's case?

	This is from the release notes (note 22.4):

	-   The documentation for the for_rtl_init_ routine does not describe
	    the arguments to for_rtl_init_.

	      When the main program is a C program that calls Fortran
	      subprograms, the main C program should call the for_rtl_init_
	      routine, which allows Fortran subprograms to properly use the DEC
	      Fortran RTL.

	    The following should be added to the above:

	      The C function prototype for for_rtl_init_ is as follows:

	      void for_rtl_init_ (
	         int *argc,   /* Access: Read.  # of args to the main program */
	         char *argv[] /* Access: Read.  Pointer to the list of args */
	         );

	      Note:  Unlike a main C function, the first argument, argc, is
	             passed by address.

	      The following is an example of how to use the for_rtl_init_
	      routine from a main C function.

	      int main ( int argc, char *argv[] )
	        {
	        extern void for_rtl_init_( int *rtl_argc, char *rtl_argv[] );
	        extern void my_fortran_subroutine( void );

	        for_rtl_init_( &argc, argv );
	        my_fortran_subroutine();
	        return( 1 );
	        }

    

    	But the claim is that the user is already doing this (calling
    for_rtl_init_) correctly.
    
    Cheers!
    Dave Eklund