This chapter provides information about floating-point exceptions and how your programs can detect and handle them.
The Institute of Electrical and Electronics Engineers (IEEE) defines a standard for floating-point exceptions called the IEEE Standard for Binary Floating-Point Arithmetic (IEEE 754). This standard defines five types of floating-point exception that must be signaled when detected:
When one of these exceptions occurs in a user process, it is signaled either by setting a flag or taking a trap. By default, the system sets a status flag in the Floating-Point Status and Control registers (FPSCR), indicating the exception has occurred. Once the status flags are set by an exception, they are cleared only when the process clears them explicitly or when the process ends. The operating system provides subroutines to query, set, or clear these flags.
The system can also cause the floating-point exception signal (SIGFPE) to be raised if a floating-point exception occurs. Because this is not the default behavior, the operating system provides subroutines to change the state of the process so the signal is enabled. When a floating-point exception raises the SIGFPE signal, the process terminates and produces a core file if no signal-handler subroutine is present in the process. Otherwise, the process calls the signal-handler subroutine.
The Subroutine Impact figure illustrates the default state when floating-point exceptions occur and how this behavior can be changed by the appropriate operating system subroutine calls.
Floating-point exception subroutines can be used to:
The following subroutines are provided to accomplish these tasks:
| fp_any_xcp or fp_divbyzero | Test the exception sticky flags |
| fp_enable or fp_enable_all | Enable the signaling of exceptions |
| fp_inexact, fp_invalid_op, fp_iop_convert, fp_iop_infdinf, fp_iop_infmzr, fp_iop_infsinf, fp_iop_invcmp, fp_iop_snan, fp_iop_sqrt, fp_iop_vxsoft, fp_iop_zrdzr, or fp_overflow | Test the exception sticky flags |
| fp_sh_info | Determines which exceptions caused the signal |
| fp_sh_set_stat | Disables exceptions or clear flags |
| fp_trap | Changes the execution state of the process |
| fp_underflow | Tests the exception sticky flags |
| sigaction | Installs signal handler |
To generate a trap, a program must change the execution state of the process using the fp_trap subroutine and enable the exception to be trapped using the fp_enable or fp_enable_all subroutine.
Changing the execution state of the program may slow performance because floating-point trapping causes the process to execute in serial mode.
When a floating-point trap occurs, the SIGFPE signal is raised. By default, the SIGFPE signal causes the process to terminate and produce a core file. To change this behavior, the program must establish a signal handler for this signal. See the sigaction, sigvec, or signal subroutines for more information on signal handlers.
Refer to the following lists for an illustration of the differences between the disabled and enabled processing states and the subroutines that are used.
The following subroutines test exception flags in the disabled processing state:
The following subroutines function in the enabled processing state:
Some systems have imprecise trapping modes. This means the hardware can detect a floating-point exception and deliver an interrupt, but processing may continue while the signal is delivered. As a result, the instruction address register (IAR) is at a different instruction when the interrupt is delivered.
Imprecise trapping modes cause less performance degradation than precise trapping mode. However, some recovery operations are not possible, because the operation that caused the exception cannot be determined or because subsequent instruction may have modified the argument that caused the exception.
To use imprecise exceptions, a signal handler must be able to determine if a trap was precise or imprecise.
In a precise trap, the instruction address register (IAR) points to the instruction that caused the trap. A program can modify the arguments to the instruction and restart it, or fix the result of the operation and continue with the next instruction. To continue, the IAR must be incremented to point to the next instruction.
In an imprecise trap, the IAR points to an instruction beyond the one that caused the exception. The instruction to which the IAR points has not been started. To continue execution, the signal handler does not increment the IAR.
To eliminate ambiguity, the trap_mode field is provided in the fp_sh_info structure. This field specifies the trapping mode in effect in the user process when the signal handler was entered. This information can also be determined by examining the Machine Status register (MSR) in the mstsave structure.
The fp_sh_info subroutine allows a floating-point signal handler to determine if the floating-point exception was precise or imprecise.
Note: Even when precise trapping mode is enabled some floating-point exceptions may be imprecise (such as operations implemented in software). Similarly, in imprecise trapping mode some exceptions may be precise.
When using imprecise exceptions, some parts of your code may require that all floating-point exceptions are reported before proceeding. The fp_flush_imprecise subroutine is provided to accomplish this. It is also recommended that the atexit subroutine be used to register the fp_flush_imprecise subroutine to run at program exit. Running at exit ensures that the program does not exit with unreported imprecise exceptions.
Some systems have hardware instructions to compute the square root of a floating-point number and to convert a floating-point number to an integer. Models not having these hardware instructions use software subroutines to do this. Either method can cause a trap if the invalid operation exception is enabled. The software subroutines report, through the fp_sh_info subroutine, that an imprecise exception occurred, because the IAR does not point to a single instruction that can be restarted to retry the operation.
Tools and Utilities Overview for Programmers.
Example of Floating-Point Trap Handler.
Floating-Point Processor Overview in POWERstation and POWERserver Hardware Technical Information-General Architectures.
The fp_clr_flag, fp_set_flag, fp_read_flag, or fp_swap_flag subroutine.
The fp_raise_xcp subroutine.
The fp_sh_trap_info or fp_sh_set_stat subroutine.
The fp_trap subroutine.
The sigaction, sigvec or signal subroutine.
/* * This code demonstates a working floating-point exception * trap handler. The handler simply identifies which * floating-point exceptions caused the trap and return. * The handler can return via either the default signal return * mechanism (sigreturn() in AIX version 3) or longjmp(); * a global handshaking variable determines which. In * practice a working trap handler would probably use one * of these methods, not both. */
#include <signal.h> #include <setjmp.h> #include <fpxcp.h> #include <fptrap.h> #include <stdlib.h> #include <stdio.h>
#define EXIT_BAD -1 #define EXIT_GOOD 0
/* * Handshaking variable with the signal handler. If zero, * then the signal hander returns via the default signal * return mechanism; if non-zero, then the signal handler * returns via longjmp. */ static int fpsigexit; #define SIGRETURN_EXIT 0 #define LONGJUMP_EXIT 1
static jmp_buf jump_buffer; /* jump buffer */
#define JMP_DEFINED 0 /* setjmp rc on initial call */
#define JMP_FPE 2 /* setjmp rc on return from */
/* signal handler */
/* * The fp_list structure allows text descriptions * of each possible trap type to be tied to the mask * that identifies it. */
typedef struct
{
fpflag_t mask;
char *text;
} fp_list_t;
/* IEEE required trap types */
fp_list_t
trap_list[] =
{
{ FP_INVALID, "FP_INVALID"},
{ FP_OVERFLOW, "FP_OVERFLOW"},
{ FP_UNDERFLOW, "FP_UNDERFLOW"},
{ FP_DIV_BY_ZERO, "FP_DIV_BY_ZERO"},
{ FP_INEXACT, "FP_INEXACT"}
};
/* INEXACT detail list -- this is an system extension */
fp_list_t
detail_list[] =
{
{ FP_INV_SNAN, "FP_INV_SNAN" } ,
{ FP_INV_ISI, "FP_INV_ISI" } ,
{ FP_INV_IDI, "FP_INV_IDI" } ,
{ FP_INV_ZDZ, "FP_INV_ZDZ" } ,
{ FP_INV_IMZ, "FP_INV_IMZ" } ,
{ FP_INV_CMP, "FP_INV_CMP" } ,
{ FP_INV_SQRT, "FP_INV_SQRT" } ,
{ FP_INV_CVI, "FP_INV_CVI" } ,
{ FP_INV_VXSOFT, "FP_INV_VXSOFT" }
};
/* * the TEST_IT macro is used in main() to raise * an exception. */
#define TEST_IT(WHAT, RAISE_ARG) \
{ \
puts(strcat("testing: ", WHAT)); \
fp_clr_flag(FP_ALL_XCP); \
fp_raise_xcp(RAISE_ARG); \
}
/* * NAME: my_div * * FUNCTION: Perform floating-point division. * */
double
my_div(double x, double y)
{
return x / y;
}
/* * NAME: sigfpe_handler * * FUNCTION: A trap handler that is entered when * a floating-point exception occurs. The * function determines what exceptions caused * the trap, prints this to stdout, and returns * to the process which caused the trap. * * NOTES: This trap handler can return either via the * default return mechanism or via longjmp(). * The global variable fpsigexit determines which. * * When entered, all floating-point traps are * disabled. * * This sample uses printf(). This should be used * with caution since printf() of a floating- * point number can cause a trap, and then * another printf() of a floating-point number * in the signal handler will corrupt the static * buffer used for the conversion. * * OUTPUTS: The type of exception that caused * the trap. */
static void
sigfpe_handler(int sig,
int code,
struct sigcontext *SCP)
{
struct mstsave * state = &SCP->sc_jmpbuf.jmp_context;
fp_sh_info_t flt_context; /* structure for fp_sh_info()
/* call */
int i; /* loop counter */
extern int fpsigexit; /* global handshaking variable */
extern jmp_buf jump_buffer /* */
/*
* Determine which floating-point exceptions caused
* the trap. fp_sh_info() is used to build the floating signal
* handler info structure, then the member
* flt_context.trap can be examined. First the trap type is
* compared for the IEEE required traps, and if the trap type
* is an invalid operation, the detail bits are examined.
*/
fp_sh_info(SCP, &flt_context, FP_SH_INFO_SIZE);
static void
sigfpe_handler(int sig,
int code,
struct sigcontext *SCP)
{
struct mstsave * state = &SCP->sc_jmpbuf.jmp_context;
fp_sh_info_t flt_context; /* structure for fp_sh_info()
/* call */
int i; /* loop counter */
extern int fpsigexit; /* global handshaking variable */
extern jmp_buf jump_buffer; /* */
/*
* Determine which floating-point exceptions caused
* the trap. fp_sh_info() is used to build the floating signal
* handler info structure, then the member
* flt_context.trap can be examined. First the trap type is
* compared for the IEEE required traps, and if the trap type
* is an invalid operation, the detail bits are examined.
*/
fp_sh_info(SCP, &flt_context, FP_SH_INFO_SIZE);
for (i = 0; i < (sizeof(trap_list) / sizeof(fp_list_t)); i++)
{
if (flt_context.trap & trap_list[i].mask)
(void) printf("Trap caused by %s error\n", trap_list[i].text);
}
if (flt_context.trap & FP_INVALID)
{
for (i = 0; i < (sizeof(detail_list) / sizeof(fp_list_t)); i++)
{
if (flt_context.trap & detail_list[i].mask)
(void) printf("Type of invalid op is %s\n", detail_list[i].text);
}
}
/* report which trap mode was in effect */
switch (flt_context.trap_mode)
{
case FP_TRAP_OFF:
puts("Trapping Mode is OFF");
break;
case FP_TRAP_SYNC:
puts("Trapping Mode is SYNC");
break;
case FP_TRAP_IMP:
puts("Trapping Mode is IMP");
break;
case FP_TRAP_IMP_REC:
puts("Trapping Mode is IMP_REC");
break;
default:
puts("ERROR: Invalid trap mode");
}
if (fpsigexit == LONGJUMP_EXIT)
{
/*
* Return via longjmp. In this instance there is no need to
* clear any exceptions or disable traps to prevent
* recurrence of the exception, because on return the
* process will have the signal handler's floating-point
* state.
*/
longjmp(jump_buffer, JMP_FPE);
}
else
{
/*
* Return via default signal handler return mechanism.
* In this case you must take some action to prevent
* recurrence of the trap, either by clearing the
* exception bit in the fpscr or by disabling the trap.
* In this case, clear the exception bit.
* The fp_sh_set_stat routine is used to clear
* the exception bit.
*/
fp_sh_set_stat(SCP, (flt_context.fpscr & ((fpstat_t) ~flt_context.trap)));
/*
* Increment the iar of the process that caused the trap,
* to prevent re-execution of the instruction.
* The FP_IAR_STAT bit in flt_context.flags indicates if
* state->iar points to an instruction that has logically
* started. If this bit is true, state->iar points to
* an operation that has started and will cause another
* exception if it runs again. In this case you want to
* continue execution and ignore the results of that
* operation, so the iar is advanced to point to the
* next instruction. If the bit is false, the iar already
* points to the next instruction that must run.
*/
if ( flt_context.flags & FP_IAR_STAT )
{
puts("Increment IAR");
state->iar += 4;
}
}
return;
}
/*
* NAME: main
*
* FUNCTION: Demonstrate the sigfpe_handler trap handler.
*
*/
int
main(void)
{
struct sigaction response;
struct sigaction old_response;
extern int fpsigexit;
extern jmp_buf jump_buffer;
int jump_rc;
int trap_mode;
double arg1, arg2, r;
/*
* Set up for floating-point trapping. Do the following:
* 1. Clear any existing floating-point exception flags.
* 2. Set up a SIGFPE signal handler.
* 3. Place the process in synchronous execution mode.
* 4. Enable all floating-point traps.
*/
fp_clr_flag(FP_ALL_XCP); (void) sigaction(SIGFPE, NULL, &old_response); (void) sigemptyset(&response.sa_mask); response.sa_flags = FALSE; response.sa_handler = (void (*)(int)) sigfpe_handler; (void) sigaction(SIGFPE, &response, NULL); fp_enable_all();
/* * Demonstate trap handler return via default signal handler * return. The TEST_IT macro will raise the floating-point * exception type given in its second argument. Testing * is done in this case with precise trapping, because * it is supported on all platforms to date. */
trap_mode = fp_trap(FP_TRAP_SYNC);
if ((trap_mode == FP_TRAP_ERROR) ||
(trap_mode == FP_TRAP_UNIMPL))
{
printf("ERROR: rc from fp_trap is %d\n",
trap_mode);
exit(-1);
}
(void) printf("Default signal handler return: \n");
fpsigexit = SIGRETURN_EXIT;
TEST_IT("div by zero", FP_DIV_BY_ZERO);
TEST_IT("overflow", FP_OVERFLOW);
TEST_IT("underflow", FP_UNDERFLOW);
TEST_IT("inexact", FP_INEXACT);
TEST_IT("signaling nan", FP_INV_SNAN);
TEST_IT("INF - INF", FP_INV_ISI);
TEST_IT("INF / INF", FP_INV_IDI);
TEST_IT("ZERO / ZERO", FP_INV_ZDZ);
TEST_IT("INF * ZERO", FP_INV_IMZ);
TEST_IT("invalid compare", FP_INV_CMP);
TEST_IT("invalid sqrt", FP_INV_SQRT);
TEST_IT("invalid coversion", FP_INV_CVI);
TEST_IT("software request", FP_INV_VXSOFT);
/* * Next, use fp_trap() to determine what the * the fastest trapmode available is on * this platform. */
trap_mode = fp_trap(FP_TRAP_FASTMODE);
switch (trap_mode)
{
case FP_TRAP_SYNC:
puts("Fast mode for this platform is PRECISE");
break;
case FP_TRAP_OFF:
puts("This platform dosn't support trapping");
break;
case FP_TRAP_IMP:
puts("Fast mode for this platform is IMPRECISE");
break;
case FP_TRAP_IMP_REC:
puts("Fast mode for this platform is IMPRECISE RECOVERABLE");
break;
default:
printf("Unexpected return code from fp_trap(FP_TRAP_FASTMODE): %d\n",
trap_mode);
exit(-2);
}
/*
* if this platform supports imprecise trapping, demonstate this.
*/
trap_mode = fp_trap(FP_TRAP_IMP);
if (trap_mode != FP_TRAP_UNIMPL)
{
puts("Demonsrate imprecise FP execeptions");
arg1 = 1.2;
arg2 = 0.0;
r = my_div(arg1, arg2);
fp_flush_imprecise();
}
/* demonstate trap handler return via longjmp().
*/
(void) printf("longjmp return: \n");
fpsigexit = LONGJUMP_EXIT;
jump_rc = setjmp(jump_buffer);
switch (jump_rc)
{
case JMP_DEFINED:
(void) printf("setjmp has been set up; testing ...\n");
TEST_IT("div by zero", FP_DIV_BY_ZERO);
break;
case JMP_FPE:
(void) printf("back from signal handler\n");
/*
* Note that at this point the process has the floating-
* point status inherited from the trap handler. If the
* trap hander did not enable trapping (as the example
* did not) then this process at this point has no traps
* enabled. We create a floating-point exception to
* demonstrate that a trap does not occur, then re-enable
* traps.
*/
(void) printf("Creating overflow; should not trap\n");
TEST_IT("Overflow", FP_OVERFLOW);
fp_enable_all();
break;
default:
(void) printf("unexpected rc from setjmp: %d\n", jump_rc);
exit(EXIT_BAD);
}
exit(EXIT_GOOD);
}
Tools and Utilities Overview for Programmers.
Floating-Point Exceptions Overview.
The sigaction, sigvec or signal subroutine.
The fp_sh_trap_info or fp_sh_set_stat subroutine.
The fp_trap subroutine.
The fp_raise_xcp subroutine.
The fp_clr_flag, fp_set_flag, fp_read_flag, or fp_swap_flag subroutine.