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

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