fpectlmodule.c 9.88 KB
Newer Older
1
/*
2 3
     ---------------------------------------------------------------------
    /                       Copyright (c) 1996.                           \
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
   |          The Regents of the University of California.                 |
   |                        All rights reserved.                           |
   |                                                                       |
   |   Permission to use, copy, modify, and distribute this software for   |
   |   any purpose without fee is hereby granted, provided that this en-   |
   |   tire notice is included in all copies of any software which is or   |
   |   includes  a  copy  or  modification  of  this software and in all   |
   |   copies of the supporting documentation for such software.           |
   |                                                                       |
   |   This  work was produced at the University of California, Lawrence   |
   |   Livermore National Laboratory under  contract  no.  W-7405-ENG-48   |
   |   between  the  U.S.  Department  of  Energy and The Regents of the   |
   |   University of California for the operation of UC LLNL.              |
   |                                                                       |
   |                              DISCLAIMER                               |
   |                                                                       |
   |   This  software was prepared as an account of work sponsored by an   |
   |   agency of the United States Government. Neither the United States   |
   |   Government  nor the University of California nor any of their em-   |
   |   ployees, makes any warranty, express or implied, or  assumes  any   |
   |   liability  or  responsibility  for the accuracy, completeness, or   |
   |   usefulness of any information,  apparatus,  product,  or  process   |
   |   disclosed,   or  represents  that  its  use  would  not  infringe   |
   |   privately-owned rights. Reference herein to any specific  commer-   |
   |   cial  products,  process,  or  service  by trade name, trademark,   |
   |   manufacturer, or otherwise, does not  necessarily  constitute  or   |
   |   imply  its endorsement, recommendation, or favoring by the United   |
   |   States Government or the University of California. The views  and   |
   |   opinions  of authors expressed herein do not necessarily state or   |
   |   reflect those of the United States Government or  the  University   |
   |   of  California,  and shall not be used for advertising or product   |
35 36
    \  endorsement purposes.                                              /
     ---------------------------------------------------------------------
37 38 39
*/

/*
40
                  Floating point exception control module.
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

   This Python module provides bare-bones control over floating point
   units from several hardware manufacturers.  Specifically, it allows
   the user to turn on the generation of SIGFPE whenever any of the
   three serious IEEE 754 exceptions (Division by Zero, Overflow,
   Invalid Operation) occurs.  We currently ignore Underflow and
   Inexact Result exceptions, although those could certainly be added
   if desired.

   The module also establishes a signal handler for SIGFPE during
   initialization.  This builds on code found in the Python
   distribution at Include/pyfpe.h and Python/pyfpe.c.  If those files
   are not in your Python distribution, find them in a patch at
   ftp://icf.llnl.gov/pub/python/busby/patches.961108.tgz.

   This module is only useful to you if it happens to include code
   specific for your hardware and software environment.  If you can
   contribute OS-specific code for new platforms, or corrections for
   the code provided, it will be greatly appreciated.

   ** Version 1.0: September 20, 1996.  Lee Busby, LLNL.
 */

#ifdef __cplusplus
extern "C" {
#endif

#include "Python.h"
#include <signal.h>

71 72 73 74
#if defined(__FreeBSD__)
#  include <ieeefp.h>
#endif

75 76 77 78
#ifndef WANT_SIGFPE_HANDLER
/* Define locally if they are not defined in Python.  This gives only
 * the limited control to induce a core dump in case of an exception.
 */
79
#include <setjmp.h>
80 81 82 83
static jmp_buf PyFPE_jbuf;
static int PyFPE_counter = 0;
#endif

84
typedef void Sigfunc(int);
85 86 87 88
static Sigfunc sigfpe_handler;
static void fpe_reset(Sigfunc *);

static PyObject *fpe_error;
89 90

PyMODINIT_FUNC PyInit_fpectl(void);
91 92 93 94
static PyObject *turnon_sigfpe            (PyObject *self,PyObject *args);
static PyObject *turnoff_sigfpe           (PyObject *self,PyObject *args);

static PyMethodDef fpectl_methods[] = {
95 96
    {"turnon_sigfpe",            (PyCFunction) turnon_sigfpe,            METH_VARARGS},
    {"turnoff_sigfpe",           (PyCFunction) turnoff_sigfpe,           METH_VARARGS},
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
    {0,0}
};

static PyObject *turnon_sigfpe(PyObject *self,PyObject *args)
{
    /* Do any architecture-specific one-time only initialization here. */

    fpe_reset(sigfpe_handler);
    Py_INCREF (Py_None);
    return Py_None;
}

static void fpe_reset(Sigfunc *handler)
{
    /* Reset the exception handling machinery, and reset the signal
     * handler for SIGFPE to the given handler.
     */

/*-- IRIX -----------------------------------------------------------------*/
#if defined(sgi)
    /* See man page on handle_sigfpes -- must link with -lfpe
     * My usage doesn't follow the man page exactly.  Maybe somebody
     * else can explain handle_sigfpes to me....
     * cc -c -I/usr/local/python/include fpectlmodule.c
121
     * ld -shared -o fpectlmodule.so fpectlmodule.o -lfpe
122 123 124 125 126
     */
#include <sigfpe.h>
    typedef void user_routine (unsigned[5], int[2]);
    typedef void abort_routine (unsigned long);
    handle_sigfpes(_OFF, 0,
127 128 129
                 (user_routine *)0,
                 _TURN_OFF_HANDLER_ON_ERROR,
                 NULL);
130
    handle_sigfpes(_ON, _EN_OVERFL | _EN_DIVZERO | _EN_INVALID,
131 132 133
                 (user_routine *)0,
                 _ABORT_ON_ERROR,
                 NULL);
134
    PyOS_setsig(SIGFPE, handler);
135 136 137 138 139 140 141 142 143

/*-- SunOS and Solaris ----------------------------------------------------*/
#elif defined(sun)
    /* References: ieee_handler, ieee_sun, ieee_functions, and ieee_flags
       man pages (SunOS or Solaris)
       cc -c -I/usr/local/python/include fpectlmodule.c
       ld -G -o fpectlmodule.so -L/opt/SUNWspro/lib fpectlmodule.o -lsunmath -lm
     */
#include <math.h>
144 145 146 147 148 149
#ifndef _SUNMATH_H
    extern void nonstandard_arithmetic(void);
    extern int ieee_flags(const char*, const char*, const char*, char **);
    extern long ieee_handler(const char*, const char*, sigfpe_handler_type);
#endif

150 151 152 153
    char *mode="exception", *in="all", *out;
    (void) nonstandard_arithmetic();
    (void) ieee_flags("clearall",mode,in,&out);
    (void) ieee_handler("set","common",(sigfpe_handler_type)handler);
154
    PyOS_setsig(SIGFPE, handler);
155 156 157 158 159 160 161 162

/*-- HPUX -----------------------------------------------------------------*/
#elif defined(__hppa) || defined(hppa)
    /* References:   fpsetmask man page */
    /* cc -Aa +z -c -I/usr/local/python/include fpectlmodule.c */
    /* ld -b -o fpectlmodule.sl fpectlmodule.o -lm */
#include <math.h>
    fpsetdefaults();
163
    PyOS_setsig(SIGFPE, handler);
164 165 166 167 168 169 170

/*-- IBM AIX --------------------------------------------------------------*/
#elif defined(__AIX) || defined(_AIX)
    /* References:   fp_trap, fp_enable man pages */
#include <fptrap.h>
    fp_trap(FP_TRAP_SYNC);
    fp_enable(TRP_INVALID | TRP_DIV_BY_ZERO | TRP_OVERFLOW);
171
    PyOS_setsig(SIGFPE, handler);
172

173 174 175 176 177 178 179 180
/*-- DEC ALPHA LINUX ------------------------------------------------------*/
#elif defined(__alpha) && defined(linux)
#include <asm/fpu.h>
    unsigned long fp_control =
    IEEE_TRAP_ENABLE_INV | IEEE_TRAP_ENABLE_DZE | IEEE_TRAP_ENABLE_OVF;
    ieee_set_fp_control(fp_control);
    PyOS_setsig(SIGFPE, handler);

181 182 183 184 185 186
/*-- Cray Unicos ----------------------------------------------------------*/
#elif defined(cray)
    /* UNICOS delivers SIGFPE by default, but no matherr */
#ifdef HAS_LIBMSET
    libmset(-1);
#endif
187
    PyOS_setsig(SIGFPE, handler);
188

189 190
/*-- FreeBSD ----------------------------------------------------------------*/
#elif defined(__FreeBSD__)
191 192 193
    fpresetsticky(fpgetsticky());
    fpsetmask(FP_X_INV | FP_X_DZ | FP_X_OFL);
    PyOS_setsig(SIGFPE, handler);
194

195 196
/*-- Linux ----------------------------------------------------------------*/
#elif defined(linux)
197 198 199
#ifdef __GLIBC__
#include <fpu_control.h>
#else
200
#include <i386/fpu_control.h>
201
#endif
202 203 204 205 206 207
#ifdef _FPU_SETCW
    {
        fpu_control_t cw = 0x1372;
        _FPU_SETCW(cw);
    }
#else
208
    __setfpucw(0x1372);
209
#endif
210
    PyOS_setsig(SIGFPE, handler);
211 212 213 214 215 216 217 218

/*-- Microsoft Windows, NT ------------------------------------------------*/
#elif defined(_MSC_VER)
    /* Reference: Visual C++ Books Online 4.2,
       Run-Time Library Reference, _control87, _controlfp */
#include <float.h>
    unsigned int cw = _EM_INVALID | _EM_ZERODIVIDE | _EM_OVERFLOW;
    (void)_controlfp(0, cw);
219
    PyOS_setsig(SIGFPE, handler);
220 221 222 223 224 225 226 227 228 229

/*-- Give Up --------------------------------------------------------------*/
#else
    fputs("Operation not implemented\n", stderr);
#endif

}

static PyObject *turnoff_sigfpe(PyObject *self,PyObject *args)
{
230
#ifdef __FreeBSD__
231 232
    fpresetsticky(fpgetsticky());
    fpsetmask(0);
233
#else
234
    fputs("Operation not implemented\n", stderr);
235
#endif
236
    Py_INCREF(Py_None);
237 238 239 240 241 242 243 244 245 246 247 248 249
    return Py_None;
}

static void sigfpe_handler(int signo)
{
    fpe_reset(sigfpe_handler);
    if(PyFPE_counter) {
        longjmp(PyFPE_jbuf, 1);
    } else {
        Py_FatalError("Unprotected floating point exception");
    }
}

250
static struct PyModuleDef fpectlmodule = {
251 252 253 254 255 256 257 258 259
        PyModuleDef_HEAD_INIT,
        "fpectl",
        NULL,
        -1,
        fpectl_methods,
        NULL,
        NULL,
        NULL,
        NULL
260 261 262
};

PyMODINIT_FUNC PyInit_fpectl(void)
263 264
{
    PyObject *m, *d;
265
    m = PyModule_Create(&fpectlmodule);
266
    if (m == NULL)
267
        return NULL;
268
    d = PyModule_GetDict(m);
269 270
    fpe_error = PyErr_NewException("fpectl.error", NULL, NULL);
    if (fpe_error != NULL)
271
        PyDict_SetItemString(d, "error", fpe_error);
272
    return m;
273 274 275 276 277
}

#ifdef __cplusplus
}
#endif