NAME

sigfpe - signal handling for specific SIGFPE codes

SYNOPSIS

cc [ flag... ] file ... -lucb
#include <signal.h>
#include <floatingpoint.h>
sigfpe_handler_type sigfpe(code, hdl)
sigfpe_code_type code;
sigfpe_handler_type hdl;

DESCRIPTION

 This function allows signal handling  to  be  specified  for
 particular  SIGFPE  codes.   A  call to sigfpe defines a new
 handler hdl for a particular SIGFPE code and returns the old
 handler  as  the  value  of  the  function sigfpe.  Normally
 handlers are specified as pointers to functions; the special
 cases  SIGFPE_IGNORE, SIGFPE_ABORT, and SIGFPE_DEFAULT allow
 ignoring, specifying core dump using  abort(3),  or  default
 handling respectively.  For these IEEE-related codes:
FPE_FLTINEX_TRAP    fp_inexact     floating inexact result
FPE_FLTDIV_TRAP     fp_division    floating division by zero
FPE_FLTUND_TRAP     fp_underflow   floating underflow
FPE_FLTOVF_TRAP     fp_overflow    floating overflow
FPE_FLTBSUN_TRAP    fp_invalid     branch or set on unordered
FPE_FLTOPERR_TRAP   fp_invalid     floating operand error
FPE_FLTNAN_TRAP     fp_invalid     floating Not-A-Number
 default handling is defined to be to call the handler speci-
 fied  to  ieee_handler(3M).   For  all  other  SIGFPE codes,
 default handling is to core dump using abort(3).  The compi-
 lation  option -ffpa causes fpa recomputation to replace the
 default  abort  action  for   code   FPE_FPA_ERROR.    Note:
 SIGFPE_DEFAULT will restore abort rather than FPA recomputa-
 tion for this code.  Three steps are required  to  intercept
 an IEEE-related SIGFPE code with sigfpe:

1) Set up a handler with sigfpe.

2) Enable the relevant IEEE trapping capability in the hardware, perhaps by using assembly-language instructions.

     3)   Perform a floating-point operation that  generates
          the intended IEEE exception.
Unlike ieee_handler(3M), sigfpe never changes floating-point
hardware mode bits affecting IEEE trapping.  No IEEE-related
SIGFPE signals will be generated unless those hardware  mode
bits  are  enabled.   SIGFPE  signals  can  be handled using
sigvec(2), signal(3), sigfpe(3), or ieee_handler(3M).  In  a
particular  program,  to  avoid  confusion,  use only one of
these interfaces to handle SIGFPE signals.

EXAMPLE

A user-specified signal handler might look like this:
void sample_handler( sig, code, scp, addr )
        int sig ;               /* sig == SIGFPE always */
        int code ;
        struct sigcontext *scp ;
        char *addr ;
        {
                /*
                   Sample user-written sigfpe code handler.
                   Prints a message and continues.
                   struct sigcontext is defined in <signal.h>.
                 */
                printf(" ieee exception code %x occurred at pc %X \n",
                        code,scp->sc_pc);
        }
and it might be set up like this:
        extern void sample_handler;
        main
        {
                sigfpe_handler_type hdl, old_handler1, old_handler2;
        /*
         * save current overflow and invalid handlers; set the new
         * overflow handler to sample_handler and set the new
         * invalid handler to SIGFPE_ABORT (abort on invalid)
         */
                hdl = (sigfpe_handler_type) sample_handler;
                old_handler1 = sigfpe(FPE_FLTOVF_TRAP, hdl);
                old_handler2 = sigfpe(FPE_FLTOPERR_TRAP, SIGFPE_ABORT);
                ...
        /*
         * restore old overflow and invalid handlers
         */
                sigfpe(FPE_FLTOVF_TRAP,   old_handler1);
                sigfpe(FPE_FLTOPERR_TRAP, old_handler2);
        }

FILES

/usr/include/floatingpoint.h
/usr/include/signal.h

SEE ALSO

sigvec(2),  floatingpoint(3),  ieee_handler(3M),  signal(3),
abort(3C) in the Programmer's Reference Manual.

RETURN VALUE

sigfpe returns BADSIG if code is not zero or a defined SIGFPE code.