Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/runtime/mach-dep/signal-sysdep.h
ViewVC logotype

Annotation of /sml/trunk/src/runtime/mach-dep/signal-sysdep.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2 - (view) (download) (as text)

1 : monnier 2 /* signal-sysdep.h
2 :     *
3 :     * COPYRIGHT (c) 1993 by AT&T Bell Laboratories.
4 :     *
5 :     * O.S. and machine dependent signal definitions for UNIX systems:
6 :     *
7 :     * typedef SigReturn_t the return type of a signal handler.
8 :     * typedef SigInfo_t the signal generation information passed to a
9 :     * a signal handler.
10 :     * typedef SigContext_t the context info passed to a signal handler.
11 :     * typedef SigMask_t the representation of a set of signals
12 :     *
13 :     * SIG_GetCode(info, scp) extract the signal generation information
14 :     * SIG_SetPC(scp, addr) set the PC in the context to the address
15 :     * SIG_SetHandler(sig, h) set the signal handler
16 :     * SIG_GetHandler(sig, h) get the current handler into h
17 :     * SIG_Flags flags used when setting a handler
18 :     * SIG_ClearMask(mask) clear the given signal mask.
19 :     * SIG_AddToMask(mask, sig) Add the given signal to the mask.
20 :     * SIG_isSet(mask, sig) Return true, if the signal is in the mask.
21 :     * SIG_SetMask(mask) Set the signal mask.
22 :     * SIG_GetMask(mask) Get the signal mask into the variable mask.
23 :     *
24 :     * SIG_FAULT[12] The signals used to detect faults.
25 :     *
26 :     * SIG_InitFPE() This macro is defined to be a routine for
27 :     * initializing the FPE hardware exception mechanism.
28 :     *
29 :     * SIG_ResetFPE(scp) This macro is defined to be a routine for resetting
30 :     * the signal handling state (or hardware status
31 :     * registers) on machines that require it; otherwise
32 :     * it is defined to the empty statement.
33 :     *
34 :     * Predicates on signals, the arguments are (signal, code).
35 :     * INT_DIVZERO(s, c)
36 :     * INT_OVFLW(s, c)
37 :     *
38 :     * There are two ways to force a GC when a signal occurs. For some machines,
39 :     * this is done in an assembly routine called ZeroLimitPtr; for others, this
40 :     * can be done directly by manipulating the signal context. The following
41 :     * macros are used for this purpose:
42 :     *
43 :     * USE_ZERO_LIMIT_PTR_FN If set, then we use the ZeroLimitPtr function.
44 :     * SIG_SavePC(msp, scp) Save the PC, so that ZeroLimitPtr can restore it.
45 :     *
46 :     * SIG_ZeroLimitPtr(scp) Set the limit pointer in the context to zero.
47 :     *
48 :     * NOTE: Currently SavedPC is a global (so that the asm code in adjust_limit
49 :     * can access it). Once we have a runtimeLink register that allows dynamic
50 :     * access to the MLState, we can move SavedPC to the ML State vector.
51 :     */
52 :    
53 :     #ifndef _SIGNAL_SYSDEP_
54 :     #define _SIGNAL_SYSDEP_
55 :    
56 :     #ifndef _ML_OSDEP_
57 :     #include "ml-osdep.h"
58 :     #endif
59 :    
60 :     #ifndef _ML_BASE_
61 :     #include "ml-base.h" /* for Addr_t */
62 :     #endif
63 :    
64 :     #if defined(OPSYS_UNIX)
65 :     # include <signal.h>
66 :     #endif
67 :    
68 :     #if defined(HAS_UCONTEXT)
69 :     #include <ucontext.h>
70 :     #include <siginfo.h>
71 :    
72 :     typedef void SigReturn_t;
73 :     typedef siginfo_t *SigInfo_t;
74 :     typedef ucontext_t SigContext_t;
75 :    
76 :     #define SIG_FAULT1 SIGFPE
77 :    
78 :     #define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == FPE_INTDIV))
79 :     #define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == FPE_INTOVF))
80 :    
81 :     #define SIG_GetCode(info,scp) ((info)->si_code)
82 :     #define SIG_Flags SA_SIGINFO
83 :    
84 :     #elif defined(HAS_SIGCONTEXT)
85 :    
86 :     typedef int SigInfo_t;
87 :     typedef struct sigcontext SigContext_t;
88 :     # define SIG_Flags 0
89 :     #endif
90 :    
91 :    
92 :     #if defined(HAS_POSIX_SIGS)
93 :     /** POSIX signals **/
94 :     #define SIG_SetHandler(sig, h) { \
95 :     struct sigaction __svec; \
96 :     sigfillset(&(__svec.sa_mask)); \
97 :     __svec.sa_flags = SIG_Flags; \
98 :     __svec.sa_handler = (h); \
99 :     sigaction ((sig), &__svec, 0); \
100 :     }
101 :     #define SIG_GetHandler(sig, h) { \
102 :     struct sigaction __svec; \
103 :     sigaction ((sig), NIL(struct sigaction *), &__svec); \
104 :     (h) = __svec.sa_handler; \
105 :     }
106 :     typedef sigset_t SigMask_t;
107 :     #define SIG_ClearMask(mask) sigemptyset(&(mask))
108 :     #define SIG_AddToMask(mask, s) sigaddset(&(mask), (s))
109 :     #define SIG_isSet(mask, s) sigismember(&(mask), (s))
110 :     #define SIG_SetMask(mask) sigprocmask(SIG_SETMASK, &(mask), NIL(sigset_t *))
111 :     #define SIG_GetMask(mask) sigprocmask(SIG_SETMASK, NIL(sigset_t *), &(mask))
112 :    
113 :     #elif defined(HAS_BSD_SIGS)
114 :     /** BSD signals **/
115 :     #define SIG_SetHandler(sig, h) { \
116 :     struct sigvec __svec; \
117 :     __svec.sv_mask = 0xFFFFFFFF; \
118 :     __svec.sv_flags = SV_INTERRUPT; \
119 :     __svec.sv_handler = (h); \
120 :     sigvec ((sig), &__svec, 0); \
121 :     }
122 :     #define SIG_GetHandler(sig, h) { \
123 :     struct sigvec __svec; \
124 :     sigvec ((sig), NIL(struct sigvec *), &__svec); \
125 :     (h) = __svec.sv_handler; \
126 :     }
127 :     typedef int SigMask_t;
128 :     #define SIG_ClearMask(mask) ((mask) = 0)
129 :     #define SIG_AddToMask(mask, s) ((mask) |= sigmask(s))
130 :     #define SIG_isSet(mask, s) (((mask) & sigmask(s)) != 0)
131 :     #define SIG_SetMask(mask) sigsetmask(mask)
132 :     #define SIG_GetMask(mask) { \
133 :     int __tmpMask; \
134 :     __tmpMask = 0xFFFFFFFF; \
135 :     (mask) = sigsetmask(__tmpMask); \
136 :     sigsetmask(mask); \
137 :     }
138 :     #elif defined(OPSYS_WIN32)
139 :     /* no win32 signals yet */
140 :     #else
141 :     # error no way to set signal handler
142 :     #endif
143 :    
144 :    
145 :     /** Machine/OS dependent stuff **/
146 :    
147 :     #if defined(HOST_SPARC)
148 :    
149 :     extern void SetFSR(int);
150 :     /* disable all FP exceptions */
151 :     # define SIG_InitFPE() SetFSR(0)
152 :    
153 :     # if defined(OPSYS_SUNOS)
154 :     /** SPARC, SUNOS **/
155 :     # define USE_ZERO_LIMIT_PTR_FN
156 :     # define SIG_FAULT1 SIGFPE
157 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == FPE_INTDIV_TRAP))
158 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == FPE_INTOVF_TRAP))
159 :     # define SIG_GetCode(info, scp) (info)
160 :     # define SIG_SetPC(scp, addr) { \
161 :     (scp)->sc_pc = (long)(addr); \
162 :     (scp)->sc_npc = (scp)->sc_pc + 4; \
163 :     }
164 :     # define SIG_SavePC(msp, scp) { \
165 :     SigContext_t *__scp = (scp); \
166 :     long __pc = __scp->sc_pc; \
167 :     if (__pc+4 != __scp->sc_npc) \
168 :     /* the pc is pointing to a delay slot, so back-up \
169 :     * to the branch. */ \
170 :     __pc -= 4; \
171 :     SavedPC = __pc; \
172 :     }
173 :     typedef void SigReturn_t;
174 :    
175 :     # elif defined(OPSYS_SOLARIS)
176 :     /** SPARC, SOLARIS **/
177 :     # define SIG_SetPC(scp, addr) { \
178 :     (scp)->uc_mcontext.gregs[REG_PC] = (long)(addr); \
179 :     (scp)->uc_mcontext.gregs[REG_nPC] = (long)(addr) + 4; \
180 :     }
181 :     # define SIG_ZeroLimitPtr(scp) \
182 :     { (scp)->uc_mcontext.gregs[REG_G4] = 0; }
183 :    
184 :     # elif defined(OPSYS_SUNOS)
185 :     /** M68, SUNOS **/
186 :     # define SIG_FAULT1 SIGFPE
187 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == FPE_INTDIV_TRAP))
188 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == FPE_TRAPV_TRAP))
189 :     # define SIG_GetCode(info, scp) (info)
190 :     # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
191 :     # define SIG_SavePC(msp, scp) { \
192 :     SigContext_t *__scp = (scp); \
193 :     extern Addr_t SavedPC; \
194 :     SavedPC = __scp->sc_pc; \
195 :     }
196 :     typedef void SigReturn_t;
197 :    
198 :     # endif
199 :    
200 :     #elif defined(HOST_MIPS)
201 :    
202 :     extern void SetFSR();
203 :     # define SIG_InitFPE() SetFSR()
204 :    
205 :     # if defined(OPSYS_IRIX4)
206 :     /** MIPS, IRIX 4.0.x **/
207 :     # define SIG_FAULT1 SIGFPE
208 :     # define SIG_FAULT2 SIGTRAP
209 :     # include <sys/sbd.h> /* for EXC_OV */
210 :     # define INT_DIVZERO(s, c) (((s) == SIGTRAP) && ((c) == BRK_DIVZERO))
211 :     # define INT_OVFLW(s, c) (((s) == SIGTRAP) && ((c) == BRK_OVERFLOW))
212 :     # define SIG_GetCode(info, scp) ((info) ? (info) : (scp)->sc_fpc_csr)
213 :     # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
214 :     # define SIG_ZeroLimitPtr(scp) { (scp)->sc_regs[19] = 0; }
215 :     typedef void SigReturn_t;
216 :    
217 :     # elif defined(OPSYS_IRIX5)
218 :     /** MIPS, IRIX 5.x **/
219 :     # define SIG_FAULT2 SIGTRAP
220 :     /* We use a TRAP to signal zero divide on the mips, but IRIX 5.3 maps
221 :     * this back to SIGFPE.
222 :     */
223 :     # undef INT_DIVZERO /* SIGTRAP used for this on MIPS */
224 :     # define INT_DIVZERO(s, c) \
225 :     (((s) == SIGTRAP) || (((s) == SIGFPE) && ((c) == FPE_INTDIV)))
226 :    
227 :     # define SIG_SetPC(scp, addr) \
228 :     { (scp)->uc_mcontext.gregs[CTX_EPC] = (long)(addr); }
229 :     # define SIG_ZeroLimitPtr(scp) \
230 :     { (scp)->uc_mcontext.gregs[CTX_S3] = 0; }
231 :     # endif /* ARCH_MIPS */
232 :    
233 :     #elif defined(HOST_RS6000)
234 :     # if defined (OPSYS_AIX)
235 :     /** RS6000, AIX **/
236 :     # include <fpxcp.h>
237 :     # define SIG_FAULT1 SIGTRAP
238 :    
239 :     # define INT_DIVZERO(s, c) (((s) == SIGTRAP) && ((c) & FP_DIV_BY_ZERO))
240 :     # define INT_OVFLW(s, c) (((s) == SIGTRAP) && ((c) == 0))
241 :     PVT int SIG_GetCode (SigInfo_t info, SigContext_t *scp);
242 :     # define SIG_SetPC(scp, addr) \
243 :     { (scp)->sc_jmpbuf.jmp_context.iar = (long)(addr); }
244 :     # define SIG_ZeroLimitPtr(scp) \
245 :     { (scp)->sc_jmpbuf.jmp_context.gpr[15] = 0; }
246 :     # define SIG_ResetFPE(scp) { \
247 :     SigContext_t *__scp = (scp); \
248 :     struct mstsave *__scj = &(__scp->sc_jmpbuf.jmp_context); \
249 :     fp_ctx_t __flt_ctx; \
250 :     __scj->xer &= 0x3fffffff; \
251 :     fp_sh_trap_info (__scp, &__flt_ctx); \
252 :     fp_sh_set_stat (__scp, (__flt_ctx.fpscr & ~__flt_ctx.trap)); \
253 :     }
254 :     typedef void SigReturn_t;
255 :    
256 :     # elif defined(OPSYS_MKLINUX)
257 :     /* RS6000, MkLinux */
258 :    
259 :     # include "mklinux-regs.h"
260 :     typedef struct mklinux_ppc_regs SigContext_t;
261 :    
262 :     # define SIG_FAULT1 SIGILL
263 :    
264 :     # define INT_DIVZERO(s, c) (((s) == SIGILL) && ((c) == 0x84000000))
265 :     # define INT_OVFLW(s, c) (((s) == SIGILL) && ((c) == 0x0))
266 :     # define SIG_SetPC(scp, addr) { (scp)->nip = (long)(addr); }
267 :     # define SIG_ZeroLimitPtr(scp) { ((scp)->gpr[15] = 0); }
268 :     # define SIG_GetCode(info,scp) ((scp)->fpscr)
269 :     # define SIG_ResetFPE(scp) { (scp)->fpscr = 0x0; }
270 :     typedef void SigReturn_t;
271 :    
272 :     # define SIG_Flags 0
273 :    
274 :     # endif /* HOST_RS6000 */
275 :    
276 :     #elif defined(HOST_HPPA)
277 :    
278 :     # if defined(OPSYS_HPUX9)
279 :     /** HPPA, HPUX 9.x **/
280 :     typedef void SigReturn_t;
281 :     # define SIG_FAULT1 SIGFPE
282 :     /* pcoq and pcsq are equivalent to the instruction address
283 :     * offset queue (iaoq) and the IA space queue (iasq)
284 :     */
285 :     # define SIG_SetPC(scp, addr) { \
286 :     SigContext_t *_scp = (scp); \
287 :     _scp->sc_pcoq_head = addr; \
288 :     _scp->sc_pcoq_tail = _scp->sc_pcoq_head + 4; \
289 :     _scp->sc_pcsq_tail = _scp->sc_pcsq_head = pointer2space(addr); \
290 :     }
291 :     # define SIG_ZeroLimitPtr(scp) { (scp)->sc_gr4 = 0; }
292 :    
293 :     # define SIG_GetCode(info, scp) info
294 :    
295 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == 13))
296 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == 12 || (c) == 14))
297 :     # define SIG_InitFPE() set_fsr()
298 :    
299 :     # endif
300 :    
301 :     # if defined(OPSYS_HPUX)
302 :     /** HPPA, HPUX 10.x **/
303 :    
304 :     # define SIG_FAULT1 SIGFPE
305 :    
306 :     /* There are bugs in the HPUX *.10.* machine/save_state.h
307 :     * header file macros!!
308 :     */
309 :     # define sc_pcoq_head sc_sl.sl_ss.ss_narrow.ss_pcoq_head
310 :     # define sc_pcoq_tail sc_sl.sl_ss.ss_narrow.ss_pcoq_tail
311 :     # define sc_pcsq_head sc_sl.sl_ss.ss_narrow.ss_pcsq_head
312 :     # define sc_pcsq_tail sc_sl.sl_ss.ss_narrow.ss_pcsq_tail
313 :     # define sc_gr3 sc_sl.sl_ss.ss_narrow.ss_gr3
314 :     # define sc_gr4 sc_sl.sl_ss.ss_narrow.ss_gr4
315 :    
316 :     /* pcoq and pcsq are equivalent to the instruction address
317 :     * offset queue (iaoq) and the IA space queue (iasq)
318 :     */
319 :     # define SIG_SetPC(scp, addr) { \
320 :     SigContext_t *_scp = (scp); \
321 :     _scp->sc_pcoq_head = addr; \
322 :     _scp->sc_pcoq_tail = _scp->sc_pcoq_head + 4; \
323 :     _scp->sc_pcsq_tail = _scp->sc_pcsq_head = pointer2space(addr); \
324 :     }
325 :    
326 :     # define SIG_ZeroLimitPtr(scp) { (scp)->sc_gr4 = 0; }
327 :     # define SIG_GetCode(info, scp) (info)
328 :    
329 :     /* The SVR4 API for SIGFPE isn't implemented correctly */
330 :     # undef INT_DIVZERO
331 :     # undef INT_OVFLW
332 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == 0xd))
333 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == 0xc || (c) == 0xe))
334 :    
335 :     # define SIG_InitFPE() set_fsr()
336 :    
337 :     typedef void SigReturn_t;
338 :    
339 :     # endif
340 :    
341 :     #elif defined(HOST_X86)
342 :    
343 :     # define LIMITPTR_X86OFFSET 3 /* offset (words) of limitptr in ML stack */
344 :     /* frame (see X86.prim.asm) */
345 :     extern Addr_t *ML_X86Frame; /* used to get at limitptr */
346 :     # define SIG_InitFPE() FPEEnable()
347 :    
348 :     # if defined(OPSYS_LINUX)
349 :     /** X86, LINUX **/
350 :     /* sigcontext taken from /usr/src/linux/include/linux/signal.h */
351 :     struct sigcontext {
352 :     unsigned short gs, __gsh;
353 :     unsigned short fs, __fsh;
354 :     unsigned short es, __esh;
355 :     unsigned short ds, __dsh;
356 :     unsigned long edi;
357 :     unsigned long esi;
358 :     unsigned long ebp;
359 :     unsigned long esp;
360 :     unsigned long ebx;
361 :     unsigned long edx;
362 :     unsigned long ecx;
363 :     unsigned long eax;
364 :     unsigned long trapno;
365 :     unsigned long err;
366 :     unsigned long eip;
367 :     unsigned short cs, __csh;
368 :     unsigned long eflags;
369 :     unsigned long esp_at_signal;
370 :     unsigned short ss, __ssh;
371 :     unsigned long i387;
372 :     unsigned long oldmask;
373 :     unsigned long cr2;
374 :     };
375 :    
376 :     #define INTO_OPCODE 0xce /* the 'into' instruction is a single */
377 :     /* instruction that signals Overflow */
378 :    
379 :    
380 :     # define SIG_FAULT1 SIGFPE
381 :     # define SIG_FAULT2 SIGSEGV
382 :     # define INT_DIVZERO(s, c) ((s) == SIGFPE)
383 :     # define INT_OVFLW(s, c) \
384 :     (((s) == SIGSEGV) && (((Byte_t *)c)[-1] == INTO_OPCODE))
385 :    
386 :     # define SIG_GetCode(info,scp) ((scp)->eip)
387 :     /* for linux, SIG_GetCode simply returns the address of the fault */
388 :     # define SIG_SetPC(scp,addr) { (scp)->eip = (long)(addr); }
389 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
390 :     typedef void SigReturn_t;
391 :    
392 :     # elif defined(OPSYS_FREEBSD)
393 :     /** x86, FreeBSD **/
394 :     # define SIG_FAULT1 SIGFPE
395 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == FPE_INTDIV_TRAP))
396 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == FPE_INTOVF_TRAP))
397 :    
398 :     # define SIG_GetCode(info, scp) (info)
399 :     # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
400 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
401 :    
402 :     typedef void SigReturn_t;
403 :    
404 :     # elif defined(OPSYS_NETBSD)
405 :     /** x86, NetBSD **/
406 :     /* NetBSD (including versions 1.0 and 1.1) generates SIGBUS rather
407 :     than SIGFPE for overflows. The real fix is a trivial change to
408 :     kernel sources, which has already been reported (NetBSD internal
409 :     problem identification "port-i386/1833").
410 :    
411 :     If you want to fix this on your NetBSD system. Edit machdep.c in
412 :     directory /sys/arch/i386/i386, and find the line
413 :    
414 :     setgate(&idt[ 4], &IDTVEC(ofl), 0, SDT_SYS386TGT, SEL_KPL);
415 :    
416 :     Change SEL_KPL to SEL_UPL. With SEL_KPL, the int overflow trap is
417 :     not accessible at user level, and a protection fault occurs instead
418 :     (thus the seg fault). SEL_UPL will allow user processes to generate
419 :     this trap.
420 :    
421 :     For the change to take effect, recompile your kernel, install it
422 :     and reboot. */
423 :     # define SIG_FAULT1 SIGFPE
424 :     # define SIG_FAULT2 SIGBUS
425 :     # define INT_DIVZERO(s, c) 0
426 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) || ((s) == SIGBUS))
427 :    
428 :     # define SIG_GetCode(info, scp) (info)
429 :     # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
430 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
431 :    
432 :     typedef void SigReturn_t;
433 :    
434 :     # elif defined(OPSYS_SOLARIS)
435 :     /** x86, Solaris */
436 :    
437 :     # define SIG_SetPC(scp, addr) { (scp)->uc_mcontext.gregs[EIP] = (int)(addr); }
438 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
439 :    
440 :     # elif defined(OPSYS_WIN32)
441 :     # define SIG_ZeroLimitPtr() { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
442 :    
443 :     # else
444 :     # error "unknown OPSYS for x86"
445 :     # endif
446 :    
447 :     #elif defined(HOST_ALPHA32)
448 :    
449 :     # if (defined(OPSYS_OSF1) || defined(OPSYS_DUNIX))
450 :     /** Alpha AXP, OSF1 **/
451 :     # include <machine/fpu.h>
452 :     # define SIG_FAULT1 SIGFPE
453 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == -2))
454 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == FPE_INTOVF_FAULT))
455 :     # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
456 :     # define SIG_GetCode(info, scp) info
457 :     # define SIG_ZeroLimitPtr(scp) { (scp)->sc_regs[9] = 0; }
458 :     typedef void SigReturn_t;
459 :     # define SIG_InitFPE() SetFSR()
460 :     # endif
461 :     #endif
462 :    
463 :     #ifndef SIG_InitFPE
464 :     #define SIG_InitFPE() /* nop */
465 :     #endif
466 :    
467 :     #ifndef SIG_ResetFPE
468 :     #define SIG_ResetFPE(SCP) /* nop */
469 :     #endif
470 :    
471 :     #endif /* !_SIGNAL_SYSDEP_ */
472 :    

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0