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 693 - (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 : monnier 251 #elif (defined(HOST_RS6000) || defined(HOST_PPC))
225 : monnier 2 # if defined (OPSYS_AIX)
226 : monnier 251 /** RS6000 or PPC, AIX **/
227 : monnier 2 # 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 : george 693 # elif (defined(TARGET_PPC) && defined(OPSYS_LINUX))
267 :     /* PPC, Linux */
268 : monnier 2
269 : george 693 # include <signal.h>
270 :     typedef struct sigcontext_struct SigContext_t;
271 :    
272 :     # define SIG_FAULT1 SIGTRAP
273 :    
274 :     # define INT_DIVZERO(s, c) (((s) == SIGTRAP) && (((c) == 0) || ((c) == 0x2000) || ((c) == 0x4000)))
275 :     # define INT_OVFLW(s, c) (((s) == SIGTRAP) && (((c) == 0) || ((c) == 0x2000) || ((c) == 0x4000)))
276 :     # define SIG_GetPC(scp) ((scp)->regs->nip)
277 :     # define SIG_SetPC(scp, addr) { (scp)->regs->nip = (long)(addr); }
278 :     # define SIG_ZeroLimitPtr(scp) { ((scp)->regs->gpr[15] = 0); } /* limitptr = 15 (see src/runtime/mach-dep/PPC.prim.asm) */
279 :     # define SIG_GetCode(info,scp) ((scp)->regs->gpr[PT_FPSCR])
280 :     # define SIG_ResetFPE(scp) { (scp)->regs->gpr[PT_FPSCR] = 0x0; }
281 :     typedef void SigReturn_t;
282 :    
283 :     # define SIG_Flags 0
284 :    
285 :    
286 : monnier 251 # endif /* HOST_RS6000/HOST_PPC */
287 : monnier 2
288 :     #elif defined(HOST_HPPA)
289 :    
290 :     # if defined(OPSYS_HPUX9)
291 :     /** HPPA, HPUX 9.x **/
292 :     typedef void SigReturn_t;
293 :     # define SIG_FAULT1 SIGFPE
294 : monnier 13 /* Since exceptions can be raised both in data space and code space,
295 :     * implementing this on HPPA/HPUX is going to be complicated.
296 :     */
297 :     # define SIG_GetPC(scp) 0
298 : monnier 2 /* pcoq and pcsq are equivalent to the instruction address
299 :     * offset queue (iaoq) and the IA space queue (iasq)
300 :     */
301 :     # define SIG_SetPC(scp, addr) { \
302 :     SigContext_t *_scp = (scp); \
303 :     _scp->sc_pcoq_head = addr; \
304 :     _scp->sc_pcoq_tail = _scp->sc_pcoq_head + 4; \
305 :     _scp->sc_pcsq_tail = _scp->sc_pcsq_head = pointer2space(addr); \
306 :     }
307 :     # define SIG_ZeroLimitPtr(scp) { (scp)->sc_gr4 = 0; }
308 :    
309 :     # define SIG_GetCode(info, scp) info
310 :    
311 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == 13))
312 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == 12 || (c) == 14))
313 :     # define SIG_InitFPE() set_fsr()
314 :    
315 :     # endif
316 :    
317 :     # if defined(OPSYS_HPUX)
318 :     /** HPPA, HPUX 10.x **/
319 :    
320 :     # define SIG_FAULT1 SIGFPE
321 :    
322 :     /* There are bugs in the HPUX *.10.* machine/save_state.h
323 :     * header file macros!!
324 :     */
325 :     # define sc_pcoq_head sc_sl.sl_ss.ss_narrow.ss_pcoq_head
326 :     # define sc_pcoq_tail sc_sl.sl_ss.ss_narrow.ss_pcoq_tail
327 :     # define sc_pcsq_head sc_sl.sl_ss.ss_narrow.ss_pcsq_head
328 :     # define sc_pcsq_tail sc_sl.sl_ss.ss_narrow.ss_pcsq_tail
329 :     # define sc_gr3 sc_sl.sl_ss.ss_narrow.ss_gr3
330 :     # define sc_gr4 sc_sl.sl_ss.ss_narrow.ss_gr4
331 :    
332 : monnier 13 /* Since exceptions can be raised both in data space and code space,
333 :     * implementing this on HPPA/HPUX is going to be complicated.
334 :     */
335 :     # define SIG_GetPC(scp) 0
336 : monnier 2 /* pcoq and pcsq are equivalent to the instruction address
337 :     * offset queue (iaoq) and the IA space queue (iasq)
338 :     */
339 :     # define SIG_SetPC(scp, addr) { \
340 :     SigContext_t *_scp = (scp); \
341 :     _scp->sc_pcoq_head = addr; \
342 :     _scp->sc_pcoq_tail = _scp->sc_pcoq_head + 4; \
343 :     _scp->sc_pcsq_tail = _scp->sc_pcsq_head = pointer2space(addr); \
344 :     }
345 :    
346 :     # define SIG_ZeroLimitPtr(scp) { (scp)->sc_gr4 = 0; }
347 :     # define SIG_GetCode(info, scp) (info)
348 :    
349 :     /* The SVR4 API for SIGFPE isn't implemented correctly */
350 :     # undef INT_DIVZERO
351 :     # undef INT_OVFLW
352 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == 0xd))
353 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == 0xc || (c) == 0xe))
354 :    
355 :     # define SIG_InitFPE() set_fsr()
356 :    
357 :     typedef void SigReturn_t;
358 :    
359 :     # endif
360 :    
361 :     #elif defined(HOST_X86)
362 :    
363 :     # define LIMITPTR_X86OFFSET 3 /* offset (words) of limitptr in ML stack */
364 :     /* frame (see X86.prim.asm) */
365 :     extern Addr_t *ML_X86Frame; /* used to get at limitptr */
366 :     # define SIG_InitFPE() FPEEnable()
367 :    
368 : george 693 # if (defined(TARGET_X86) && defined(OPSYS_LINUX))
369 : monnier 2 /** X86, LINUX **/
370 : monnier 292 # if (!defined(_SIGCONTEXT_H) && !defined(sigcontext_struct))
371 : monnier 13 /* older versions of Linux don't define this in <signal.h> */
372 :     struct sigcontext {
373 :     unsigned short gs, __gsh;
374 :     unsigned short fs, __fsh;
375 :     unsigned short es, __esh;
376 :     unsigned short ds, __dsh;
377 :     unsigned long edi;
378 :     unsigned long esi;
379 :     unsigned long ebp;
380 :     unsigned long esp;
381 :     unsigned long ebx;
382 :     unsigned long edx;
383 :     unsigned long ecx;
384 :     unsigned long eax;
385 :     unsigned long trapno;
386 :     unsigned long err;
387 :     unsigned long eip;
388 :     unsigned short cs, __csh;
389 :     unsigned long eflags;
390 :     unsigned long esp_at_signal;
391 :     unsigned short ss, __ssh;
392 :     unsigned long i387;
393 :     unsigned long oldmask;
394 :     unsigned long cr2;
395 :     };
396 : monnier 292 # endif
397 : monnier 2
398 :     #define INTO_OPCODE 0xce /* the 'into' instruction is a single */
399 :     /* instruction that signals Overflow */
400 :    
401 :    
402 :     # define SIG_FAULT1 SIGFPE
403 :     # define SIG_FAULT2 SIGSEGV
404 :     # define INT_DIVZERO(s, c) ((s) == SIGFPE)
405 :     # define INT_OVFLW(s, c) \
406 :     (((s) == SIGSEGV) && (((Byte_t *)c)[-1] == INTO_OPCODE))
407 :    
408 : monnier 13 # define SIG_GetCode(info,scp) ((scp)->eip)
409 : monnier 2 /* for linux, SIG_GetCode simply returns the address of the fault */
410 : monnier 13 # define SIG_GetPC(scp) ((scp)->eip)
411 :     # define SIG_SetPC(scp,addr) { (scp)->eip = (long)(addr); }
412 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
413 : monnier 2 typedef void SigReturn_t;
414 :    
415 :     # elif defined(OPSYS_FREEBSD)
416 :     /** x86, FreeBSD **/
417 :     # define SIG_FAULT1 SIGFPE
418 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == FPE_INTDIV_TRAP))
419 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == FPE_INTOVF_TRAP))
420 :    
421 :     # define SIG_GetCode(info, scp) (info)
422 : monnier 13 # define SIG_GetPC(scp) ((scp)->sc_pc)
423 : monnier 2 # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
424 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
425 :    
426 :     typedef void SigReturn_t;
427 :    
428 :     # elif defined(OPSYS_NETBSD)
429 :     /** x86, NetBSD **/
430 :     /* NetBSD (including versions 1.0 and 1.1) generates SIGBUS rather
431 :     than SIGFPE for overflows. The real fix is a trivial change to
432 :     kernel sources, which has already been reported (NetBSD internal
433 :     problem identification "port-i386/1833").
434 :    
435 :     If you want to fix this on your NetBSD system. Edit machdep.c in
436 :     directory /sys/arch/i386/i386, and find the line
437 :    
438 :     setgate(&idt[ 4], &IDTVEC(ofl), 0, SDT_SYS386TGT, SEL_KPL);
439 :    
440 :     Change SEL_KPL to SEL_UPL. With SEL_KPL, the int overflow trap is
441 :     not accessible at user level, and a protection fault occurs instead
442 :     (thus the seg fault). SEL_UPL will allow user processes to generate
443 :     this trap.
444 :    
445 :     For the change to take effect, recompile your kernel, install it
446 :     and reboot. */
447 :     # define SIG_FAULT1 SIGFPE
448 :     # define SIG_FAULT2 SIGBUS
449 :     # define INT_DIVZERO(s, c) 0
450 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) || ((s) == SIGBUS))
451 :    
452 :     # define SIG_GetCode(info, scp) (info)
453 : monnier 13 # define SIG_GetPC(scp) ((scp)->sc_pc)
454 : monnier 2 # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
455 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
456 :    
457 :     typedef void SigReturn_t;
458 :    
459 :     # elif defined(OPSYS_SOLARIS)
460 :     /** x86, Solaris */
461 :    
462 : monnier 13 # define SIG_GetPC(scp) ((scp)->uc_mcontext.gregs[EIP])
463 : monnier 2 # define SIG_SetPC(scp, addr) { (scp)->uc_mcontext.gregs[EIP] = (int)(addr); }
464 :     # define SIG_ZeroLimitPtr(scp) { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
465 :    
466 :     # elif defined(OPSYS_WIN32)
467 :     # define SIG_ZeroLimitPtr() { ML_X86Frame[LIMITPTR_X86OFFSET] = 0; }
468 :    
469 :     # else
470 :     # error "unknown OPSYS for x86"
471 :     # endif
472 :    
473 :     #elif defined(HOST_ALPHA32)
474 :    
475 :     # if (defined(OPSYS_OSF1) || defined(OPSYS_DUNIX))
476 :     /** Alpha AXP, OSF1 **/
477 :     # include <machine/fpu.h>
478 :     # define SIG_FAULT1 SIGFPE
479 :     # define INT_DIVZERO(s, c) (((s) == SIGFPE) && ((c) == -2))
480 :     # define INT_OVFLW(s, c) (((s) == SIGFPE) && ((c) == FPE_INTOVF_FAULT))
481 : monnier 13 # define SIG_GetPC(scp) ((scp)->sc_pc)
482 : monnier 2 # define SIG_SetPC(scp, addr) { (scp)->sc_pc = (long)(addr); }
483 :     # define SIG_GetCode(info, scp) info
484 :     # define SIG_ZeroLimitPtr(scp) { (scp)->sc_regs[9] = 0; }
485 :     typedef void SigReturn_t;
486 :     # define SIG_InitFPE() SetFSR()
487 :     # endif
488 :     #endif
489 :    
490 :     #ifndef SIG_InitFPE
491 :     #define SIG_InitFPE() /* nop */
492 :     #endif
493 :    
494 :     #ifndef SIG_ResetFPE
495 :     #define SIG_ResetFPE(SCP) /* nop */
496 :     #endif
497 :    
498 :     #endif /* !_SIGNAL_SYSDEP_ */
499 :    

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