te
Copyright (c) 2006, Sun Microsystems, Inc. All Rights Reserved.
The contents of this file are subject to the terms of the Common Development and Distribution License (the "License"). You may not use this file except in compliance with the License.
You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE or http://www.opensolaris.org/os/licensing. See the License for the specific language governing permissions and limitations under the License.
When distributing Covered Code, include this CDDL HEADER in each file and include the License file at usr/src/OPENSOLARIS.LICENSE. If applicable, add the following below this CDDL HEADER, with the fields enclosed by brackets "[]" replaced with your own identifying information: Portions Copyright [yyyy] [name of copyright owner]
fex_set_handling, fex_get_handling, fex_getexcepthandler, fex_setexcepthandler - control floating point exception handling modes

c99 [ flag... ] file... -lm [ library... ]
#include <fenv.h>

int fex_set_handling(int ex, int mode, void(*handler);

int fex_get_handling(int ex);

void fex_getexcepthandler(fex_handler_t *buf, int ex);

void fex_setexcepthandler(const fex_handler_t *buf, int ex);

These functions provide control of floating point exception handling modes. For each function, the ex argument specifies one or more exceptions indicated by a bitwise-OR of any of the following values defined in <fenv.h>:

FEX_INEXACT

FEX_UNDERFLOW

FEX_OVERFLOW

FEX_DIVBYZERO

FEX_INV_ZDZ

FEX_INV_IDI

FEX_INV_ISI

FEX_INV_ZMI

FEX_INV_SQRT

FEX_INV_SNAN

FEX_INV_INT

FEX_INV_CMP

For convenience, the following combinations of values are also defined:

FEX_NONE

FEX_INVALID

FEX_COMMON

FEX_ALL

The fex_set_handling() function establishes the specified mode for handling the floating point exceptions identified by ex. The selected mode determines the action to be taken when one of the indicated exceptions occurs. It must be one of the following values:

FEX_NOHANDLER

FEX_NONSTOP

FEX_ABORT

FEX_SIGNAL

FEX_CUSTOM

In FEX_CUSTOM mode, when a floating point exception occurs, the handler function is invoked as though its prototype were:

#include <fenv.h>
void handler(int ex, fex_info_t *info);

On entry, ex is the value (of the first twelve listed above) corresponding to the exception that occurred, info->op indicates the operation that caused the exception, info->op1 and info->op2 contain the values of the operands, info->res contains the default untrapped result value, and info->flags reflects the exception flags that the operation would have set had it not been trapped. If the handler returns, the value contained in info->res on exit is substituted for the result of the operation, the flags indicated by info->flags are set, and execution resumes at the point where the exception occurred. The handler might modify info->res and info->flags to supply any desired result value and flags. Alternatively, if the exception is underflow or overflow, the handler might set

info->res.type = fex_nodata;

which causes the exponent-adjusted result specified by IEEE 754 to be substituted. If the handler does not modify info->res or info->flags, the effect is the same as if the exception had not been trapped.

Although the default untrapped result of an exceptional operation is always available to a FEX_CUSTOM handler, in some cases, one or both operands may not be. In these cases, the handler may be invoked with info->op1.type == fex_nodata or info->op2.type == fex_nodata to indicate that the respective data structures do not contain valid data. (For example, info->op2.type == fex_nodata if the exceptional operation is a unary operation.) Before accessing the operand values, a custom handler should always examine the type field of the operand data structures to ensure that they contain valid data in the appropriate format.

The fex_get_handling() function returns the current handling mode for the exception specified by ex, which must be one of the first twelve exceptions listed above.

The fex_getexcepthandler() function saves the current handling modes and associated data for the exceptions specified by ex in the data structure pointed to by buf. The type fex_handler_t is defined in <fenv.h>.

The fex_setexcepthandler() function restores the handling modes and associated data for the exceptions specified by ex from the data structure pointed to by buf. This data structure must have been set by a previous call to fex_getexcepthandler(). Otherwise the effect on the indicated modes is undefined.

The fex_set_handling() function returns a non-zero value if the requested exception handling mode is established. Otherwise, it returns 0. The following example demonstrates how to substitute a predetermined value for the result of a 0/0 invalid operation.

#include <math.h>
#include <fenv.h>

double k;

void presub(int ex, fex_info_t *info) {
 info->res.type = fex_double;
 info->res.val.d = k;
}

int main() {
 double x, w;
 int i;
 fex_handler_t buf;
/*
 * save current 0/0 handler
 */
 (void) fex_getexcepthandler(&buf, FEX_INV_ZDZ);
/*
 * set up presubstitution handler for 0/0
 */
 (void) fex_set_handling(FEX_INV_ZDZ, FEX_CUSTOM, presub);
/*
 * compute (k*x)/sin(x) for k=2.0, x=0.5, 0.4, ..., 0.1, 0.0
 */
 k = 2.0;
 (void) printf("Evaluating f(x) = (k*x)/sin(x)\en\en");
 for (i = 5; i >= 0; i--) {
 x = (double) i * 0.1;
 w = (k * x) / sin(x);
 (void) printf("\etx=%3.3f\et f(x) = % 1.20e\en", x, w);
 }
/*
 * restore old 0/0 handler
 */
 (void) fex_setexcepthandler(&buf, FEX_INV_ZDZ);
 return 0;
}

The output from the preceding program reads:

Evaluating f(x) = (k*x)/sin(x)

 x=0.500 f(x) = 2.08582964293348816000e+00
 x=0.400 f(x) = 2.05434596443822626000e+00
 x=0.300 f(x) = 2.03031801709447368000e+00
 x=0.200 f(x) = 2.01339581906893761000e+00
 x=0.100 f(x) = 2.00333722632695554000e+00
 x=0.000 f(x) = 2.00000000000000000000e+00

When x = 0, f(x) is computed as 0/0 and an invalid operation exception occurs. In this example, the value 2.0 is substituted for the result.

See attributes(5) for descriptions of the following attributes:

ATTRIBUTE TYPE ATTRIBUTE VALUE

Availability SUNWlibms, SUNWlmxs

Interface Stability Stable

MT-Level MT-Safe (see Notes)

sigfpe(3C), feclearexcept(3M), fegetenv(3M), fex_set_log(3M), attributes(5)

Numerical Computation Guide

In a multithreaded application, the preceding functions affect exception handling modes only for the calling thread.

The functions described on this page automatically install and deinstall SIGFPE handlers and set and clear the trap enable mode bits in the floating point status register as needed. If a program uses these functions and attempts to install a SIGFPE handler or control the trap enable mode bits independently, the resulting behavior is not defined.

All traps are disabled before a handler installed in FEX_CUSTOM mode is invoked. When the SIGFPE signal is blocked, as it is when such a handler is invoked, the floating point environment, exception flags, and retrospective diagnostic functions described in feclearexcept(3M), fegetenv(3M), and fex_set_log(3M) do not re-enable traps. Thus, the handler itself always runs in FEX_NONSTOP mode with logging of retrospective diagnostics disabled. Attempting to change these modes within the handler may not produce the expected results.