#include "sysbits.h" #if HAVE_SIGNAL #ifdef MSH #define SIGFPE SIGDIV #endif static void HandleMatherr(int sig, void *sipv, void *uapv); #define PLSIG_PREPARED 0x01 /* signal is prepared */ #define PLSIG_THROW 0x02 /* throw signal(num, name) */ #define PLSIG_SYNC 0x04 /* call synchronously */ #define PLSIG_NOFRAME 0x08 /* Do not create a Prolog frame */ #define SIG_PROLOG_OFFSET 32 /* Start of Prolog signals */ #define SIG_EXCEPTION (SIG_PROLOG_OFFSET+0) #ifdef ATOMGC #define SIG_ATOM_GC (SIG_PROLOG_OFFSET+1) #endif #define SIG_GC (SIG_PROLOG_OFFSET+2) #ifdef THREADS #define SIG_THREAD_SIGNAL (SIG_PROLOG_OFFSET+3) #endif #define SIG_FREECLAUSES (SIG_PROLOG_OFFSET+4) #define SIG_PLABORT (SIG_PROLOG_OFFSET+5) static struct signame { int sig; const char *name; int flags; } signames[] = { #ifdef SIGHUP { SIGHUP, "hup", 0}, #endif { SIGINT, "int", 0}, #ifdef SIGQUIT { SIGQUIT, "quit", 0}, #endif { SIGILL, "ill", 0}, { SIGABRT, "abrt", 0}, #if HAVE_SIGFPE { SIGFPE, "fpe", PLSIG_THROW}, #endif #ifdef SIGKILL { SIGKILL, "kill", 0}, #endif { SIGSEGV, "segv", 0}, #ifdef SIGPIPE { SIGPIPE, "pipe", 0}, #endif #ifdef SIGALRM { SIGALRM, "alrm", PLSIG_THROW}, #endif { SIGTERM, "term", 0}, #ifdef SIGUSR1 { SIGUSR1, "usr1", 0}, #endif #ifdef SIGUSR2 { SIGUSR2, "usr2", 0}, #endif #ifdef SIGCHLD { SIGCHLD, "chld", 0}, #endif #ifdef SIGCONT { SIGCONT, "cont", 0}, #endif #ifdef SIGSTOP { SIGSTOP, "stop", 0}, #endif #ifdef SIGTSTP { SIGTSTP, "tstp", 0}, #endif #ifdef SIGTTIN { SIGTTIN, "ttin", 0}, #endif #ifdef SIGTTOU { SIGTTOU, "ttou", 0}, #endif #ifdef SIGTRAP { SIGTRAP, "trap", 0}, #endif #ifdef SIGBUS { SIGBUS, "bus", 0}, #endif #ifdef SIGSTKFLT { SIGSTKFLT, "stkflt", 0}, #endif #ifdef SIGURG { SIGURG, "urg", 0}, #endif #ifdef SIGIO { SIGIO, "io", 0}, #endif #ifdef SIGPOLL { SIGPOLL, "poll", 0}, #endif #ifdef SIGXCPU { SIGXCPU, "xcpu", PLSIG_THROW}, #endif #ifdef SIGXFSZ { SIGXFSZ, "xfsz", PLSIG_THROW}, #endif #ifdef SIGVTALRM { SIGVTALRM, "vtalrm", PLSIG_THROW}, #endif #ifdef SIGPROF { SIGPROF, "prof", 0}, #endif #ifdef SIGPWR { SIGPWR, "pwr", 0}, #endif { SIG_EXCEPTION, "prolog:exception", 0 }, #ifdef SIG_ATOM_GC { SIG_ATOM_GC, "prolog:atom_gc", 0 }, #endif { SIG_GC, "prolog:gc", 0 }, #ifdef SIG_THREAD_SIGNAL { SIG_THREAD_SIGNAL, "prolog:thread_signal", 0 }, #endif { -1, NULL, 0} }; typedef void (*signal_handler_t)(int, void *, void *); #if HAVE_SIGACTION static void my_signal_info(int sig, void * handler) { struct sigaction sigact; sigact.sa_handler = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction(sig,&sigact,NULL); } static void my_signal(int sig, void * handler) { struct sigaction sigact; sigact.sa_handler= (void *)handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = 0; sigaction(sig,&sigact,NULL); } #else static void my_signal(int sig, void *handler) { signal(sig, handler); } static void my_signal_info(int sig, void *handler) { if(signal(sig, (void *)handler) == SIG_ERR) exit(1); } #endif /* SWI emulation */ int Yap_signal_index(const char *name) { struct signame *sn = signames; char tmp[12]; if ( strncmp(name, "SIG", 3) == 0 && strlen(name) < 12 ) { char *p = (char *)name+3, *q = tmp; while ((*q++ = tolower(*p++))) {}; name = tmp; } for( ; sn->name; sn++ ) { if ( !strcmp(sn->name, name) ) return sn->sig; } return -1; } #if HAVE_SIGINFO_H #include #endif #if HAVE_SYS_UCONTEXT_H #include #endif #if HAVE_SIGSEGV static void SearchForTrailFault(void *ptr, int sure) { /* If the TRAIL is very close to the top of mmaped allocked space, then we can try increasing the TR space and restarting the instruction. In the worst case, the system will crash again */ #if OS_HANDLES_TR_OVERFLOW && !USE_SYSTEM_MALLOC if ((ptr > (void *)LOCAL_TrailTop-1024 && TR < (tr_fr_ptr) LOCAL_TrailTop+(64*1024))) { if (!Yap_growtrail(64*1024, TRUE)) { Yap_Error(RESOURCE_ERROR_TRAIL, TermNil, "YAP failed to reserve %ld bytes in growtrail", K64); } /* just in case, make sure the OS keeps the signal handler. */ /* my_signal_info(SIGSEGV, HandleSIGSEGV); */ } else #endif /* OS_HANDLES_TR_OVERFLOW */ if (sure) Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "tried to access illegal address %p!!!!", ptr); else Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "likely bug in YAP, segmentation violation"); } /* This routine believes there is a continuous space starting from the HeapBase and ending on TrailTop */ static void HandleSIGSEGV(int sig, void *sipv, void *uap) { CACHE_REGS void *ptr = TR; int sure = FALSE; if (LOCAL_PrologMode & ExtendStackMode) { Yap_Error(SYSTEM_ERROR_FATAL, TermNil, "OS memory allocation crashed at address %p, bailing out\n",LOCAL_TrailTop); } #if (defined(__svr4__) || defined(__SVR4)) siginfo_t *sip = sipv; if ( sip->si_code != SI_NOINFO && sip->si_code == SEGV_MAPERR) { ptr = sip->si_addr; sure = TRUE; } #elif __linux__ siginfo_t *sip = sipv; ptr = sip->si_addr; sure = TRUE; #endif SearchForTrailFault( ptr, sure ); } #endif /* SIGSEGV */ #if HAVE_SIGFPE #if HAVE_FPU_CONTROL_H #include #endif /* by default Linux with glibc is IEEE compliant anyway..., but we will pretend it is not. */ static bool set_fpu_exceptions(Term flag) { if (flag == TermTrue) { #if HAVE_FESETEXCEPTFLAG fexcept_t excepts; return fesetexceptflag(&excepts, FE_DIVBYZERO| FE_UNDERFLOW|FE_OVERFLOW) == 0; #elif HAVE_FEENABLEEXCEPT /* I shall ignore de-normalization and precision errors */ feenableexcept(FE_DIVBYZERO| FE_INVALID|FE_OVERFLOW); #elif _WIN32 // Enable zero-divide, overflow and underflow exception _controlfp_s(0, ~(_EM_ZERODIVIDE|_EM_UNDERFLOW|_EM_OVERFLOW), _MCW_EM); // Line B #elif defined(__hpux) # if HAVE_FESETTRAPENABLE /* From HP-UX 11.0 onwards: */ fesettrapenable(FE_INVALID|FE_DIVBYZERO|FE_OVERFLOW|FE_UNDERFLOW); # else /* Up until HP-UX 10.20: FP_X_INV invalid operation exceptions FP_X_DZ divide-by-zero exception FP_X_OFL overflow exception FP_X_UFL underflow exception FP_X_IMP imprecise (inexact result) FP_X_CLEAR simply zero to clear all flags */ fpsetmask(FP_X_INV|FP_X_DZ|FP_X_OFL|FP_X_UFL); # endif #endif /* __hpux */ #if HAVE_FPU_CONTROL_H && i386 && defined(__GNUC__) /* I shall ignore denormalization and precision errors */ int v = _FPU_IEEE & ~(_FPU_MASK_IM|_FPU_MASK_ZM|_FPU_MASK_OM|_FPU_MASK_UM); _FPU_SETCW(v); #endif #if HAVE_FETESTEXCEPT feclearexcept(FE_ALL_EXCEPT); #endif #ifdef HAVE_SIGFPE my_signal (SIGFPE, HandleMatherr); #endif } else { /* do IEEE arithmetic in the way the big boys do */ #if HAVE_FESETEXCEPTFLAG fexcept_t excepts; return fesetexceptflag(&excepts, 0) == 0; #elif HAVE_FEENABLEEXCEPT /* I shall ignore de-normalization and precision errors */ feenableexcept(0); #elif _WIN32 // Enable zero-divide, overflow and underflow exception _controlfp_s(0, (_EM_ZERODIVIDE|_EM_UNDERFLOW|_EM_OVERFLOW), _MCW_EM); // Line B #elif defined(__hpux) # if HAVE_FESETTRAPENABLE fesettrapenable(FE_ALL_EXCEPT); # else fpsetmask(FP_X_CLEAR); # endif #endif /* __hpux */ #if HAVE_FPU_CONTROL_H && i386 && defined(__GNUC__) /* this will probably not work in older releases of Linux */ int v = _FPU_IEEE; _FPU_SETCW(v); #endif #ifdef HAVE_SIGFPE my_signal (SIGFPE, SIG_IGN); #endif } return true; } bool Yap_set_fpu_exceptions(Term flag) { return set_fpu_exceptions(flag); } yap_error_number Yap_MathException__( USES_REGS1 ) { #if HAVE_FETESTEXCEPT int raised; // #pragma STDC FENV_ACCESS ON if ((raised = fetestexcept( FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW)) ) { feclearexcept(FE_ALL_EXCEPT); if (raised & FE_OVERFLOW) { return EVALUATION_ERROR_FLOAT_OVERFLOW; } else if (raised & FE_DIVBYZERO) { return EVALUATION_ERROR_ZERO_DIVISOR; } else if (raised & FE_UNDERFLOW) { return EVALUATION_ERROR_FLOAT_UNDERFLOW; //} else if (raised & (FE_INVALID|FE_INEXACT)) { // return EVALUATION_ERROR_UNDEFINED; } else { return EVALUATION_ERROR_UNDEFINED; } } #elif _WIN32 unsigned int raised; int err; // Show original FP control word and do calculation. err = _controlfp_s(&raised, 0, 0); if (err) { return EVALUATION_ERROR_UNDEFINED; } if (raised ) { feclearexcept(FE_ALL_EXCEPT); if (raised & FE_OVERFLOW) { return EVALUATION_ERROR_FLOAT_OVERFLOW; } else if (raised & FE_DIVBYZERO) { return EVALUATION_ERROR_ZERO_DIVISOR; } else if (raised & FE_UNDERFLOW) { return EVALUATION_ERROR_FLOAT_UNDERFLOW; //} else if (raised & (FE_INVALID|FE_INEXACT)) { // return EVALUATION_ERROR_UNDEFINED; } else { return EVALUATION_ERROR_UNDEFINED; } } #elif (defined(__svr4__) || defined(__SVR4)) switch(sip->si_code) { case FPE_INTDIV: return EVALUATION_ERROR_ZERO_DIVISOR; break; case FPE_INTOVF: return EVALUATION_ERROR_INT_OVERFLOW; break; case FPE_FLTDIV: return EVALUATION_ERROR_ZERO_DIVISOR; break; case FPE_FLTOVF: return EVALUATION_ERROR_FLOAT_OVERFLOW; break; case FPE_FLTUND: return EVALUATION_ERROR_FLOAT_UNDERFLOW; break; case FPE_FLTRES: case FPE_FLTINV: case FPE_FLTSUB: default: return EVALUATION_ERROR_UNDEFINED; } set_fpu_exceptions(0); #endif return LOCAL_matherror; } static Int p_fpe_error( USES_REGS1 ) { Yap_Error(LOCAL_matherror, LOCAL_mathtt, LOCAL_mathstring); LOCAL_matherror = YAP_NO_ERROR; LOCAL_mathtt = TermNil; LOCAL_mathstring = NULL; return FALSE; } static void HandleMatherr(int sig, void *sipv, void *uapv) { CACHE_REGS LOCAL_matherror = Yap_MathException( ); /* reset the registers so that we don't have trash in abstract machine */ Yap_external_signal( worker_id, YAP_FPE_SIGNAL ); } #endif /* SIGFPE */ #if !defined(LIGHT) && !_MSC_VER && !defined(__MINGW32__) && !defined(LIGHT) static RETSIGTYPE ReceiveSignal (int s, void *x, void *y) { CACHE_REGS LOCAL_PrologMode |= InterruptMode; my_signal (s, ReceiveSignal); switch (s) { case SIGINT: // always direct SIGINT to console Yap_external_signal( 0, YAP_INT_SIGNAL ); break; case SIGALRM: Yap_external_signal( worker_id, YAP_ALARM_SIGNAL ); break; case SIGVTALRM: Yap_external_signal( worker_id, YAP_VTALARM_SIGNAL ); break; #ifndef MPW #ifdef HAVE_SIGFPE case SIGFPE: Yap_external_signal( worker_id, YAP_FPE_SIGNAL ); break; #endif #endif #if !defined(LIGHT) && !defined(_WIN32) /* These signals are not handled by WIN32 and not the Macintosh */ case SIGQUIT: case SIGKILL: LOCAL_PrologMode &= ~InterruptMode; Yap_Error(INTERRUPT_EVENT,MkIntTerm(s),NULL); break; #endif #ifdef SIGUSR1 case SIGUSR1: /* force the system to creep */ Yap_external_signal ( worker_id, YAP_USR1_SIGNAL); break; #endif /* defined(SIGUSR1) */ #ifdef SIGUSR2 case SIGUSR2: /* force the system to creep */ Yap_external_signal ( worker_id, YAP_USR2_SIGNAL); break; #endif /* defined(SIGUSR2) */ #ifdef SIGPIPE case SIGPIPE: /* force the system to creep */ Yap_external_signal ( worker_id, YAP_PIPE_SIGNAL); break; #endif /* defined(SIGPIPE) */ #ifdef SIGHUP case SIGHUP: /* force the system to creep */ /* Just ignore SUGHUP Yap_signal (YAP_HUP_SIGNAL); */ break; #endif /* defined(SIGHUP) */ default: fprintf(stderr, "\n[ Unexpected signal ]\n"); exit (s); } LOCAL_PrologMode &= ~InterruptMode; } #endif #if (_MSC_VER || defined(__MINGW32__)) static BOOL WINAPI MSCHandleSignal(DWORD dwCtrlType) { if ( #if THREADS REMOTE_InterruptsDisabled(0) #else LOCAL_InterruptsDisabled #endif ) { return FALSE; } switch(dwCtrlType) { case CTRL_C_EVENT: case CTRL_BREAK_EVENT: #if THREADS Yap_external_signal(0, YAP_WINTIMER_SIGNAL); REMOTE_PrologMode(0) |= InterruptMode; #else Yap_signal(YAP_WINTIMER_SIGNAL); LOCAL_PrologMode |= InterruptMode; #endif return(TRUE); default: return(FALSE); } } #endif /* SIGINT can cause problems, if caught before full initialization */ void Yap_InitOSSignals (int wid) { if (GLOBAL_PrologShouldHandleInterrupts) { #if !defined(LIGHT) && !_MSC_VER && !defined(__MINGW32__) && !defined(LIGHT) my_signal (SIGQUIT, ReceiveSignal); my_signal (SIGKILL, ReceiveSignal); my_signal (SIGUSR1, ReceiveSignal); my_signal (SIGUSR2, ReceiveSignal); my_signal (SIGHUP, ReceiveSignal); my_signal (SIGALRM, ReceiveSignal); my_signal (SIGVTALRM, ReceiveSignal); #endif #ifdef SIGPIPE my_signal (SIGPIPE, ReceiveSignal); #endif #if _MSC_VER || defined(__MINGW32__) signal (SIGINT, SIG_IGN); SetConsoleCtrlHandler(MSCHandleSignal,TRUE); #else my_signal (SIGINT, ReceiveSignal); #endif #ifdef HAVE_SIGFPE my_signal (SIGFPE, HandleMatherr); #endif #if HAVE_SIGSEGV my_signal_info (SIGSEGV, HandleSIGSEGV); #endif #ifdef YAPOR_COW signal(SIGCHLD, SIG_IGN); /* avoid ghosts */ #endif } } #endif /* HAVE_SIGNAL */ /* wrapper for alarm system call */ #if _MSC_VER || defined(__MINGW32__) static DWORD WINAPI DoTimerThread(LPVOID targ) { Int *time = (Int *)targ; HANDLE htimer; LARGE_INTEGER liDueTime; htimer = CreateWaitableTimer(NULL, FALSE, NULL); liDueTime.QuadPart = -10000000; liDueTime.QuadPart *= time[0]; /* add time in usecs */ liDueTime.QuadPart -= time[1]*10; /* Copy the relative time into a LARGE_INTEGER. */ if (SetWaitableTimer(htimer, &liDueTime,0,NULL,NULL,0) == 0) { return(FALSE); } if (WaitForSingleObject(htimer, INFINITE) != WAIT_OBJECT_0) fprintf(stderr,"WaitForSingleObject failed (%ld)\n", GetLastError()); Yap_signal (YAP_WINTIMER_SIGNAL); /* now, say what is going on */ Yap_PutValue(AtomAlarm, MkAtomTerm(AtomTrue)); ExitThread(1); #if _MSC_VER return(0L); #endif } #endif static Int enable_interrupts( USES_REGS1 ) { LOCAL_InterruptsDisabled--; if (LOCAL_Signals && !LOCAL_InterruptsDisabled) { CreepFlag = Unsigned(LCL0); if ( !Yap_only_has_signal( YAP_CREEP_SIGNAL ) ) EventFlag = Unsigned( LCL0 ); } return TRUE; } static Int disable_interrupts( USES_REGS1 ) { LOCAL_InterruptsDisabled++; CalculateStackGap( PASS_REGS1 ); return TRUE; } static Int alarm4( USES_REGS1 ) { Term t = Deref(ARG1); Term t2 = Deref(ARG2); Int i1, i2; if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, "alarm/2"); return(FALSE); } if (!IsIntegerTerm(t)) { Yap_Error(TYPE_ERROR_INTEGER, t, "alarm/2"); return(FALSE); } if (IsVarTerm(t2)) { Yap_Error(INSTANTIATION_ERROR, t2, "alarm/2"); return(FALSE); } if (!IsIntegerTerm(t2)) { Yap_Error(TYPE_ERROR_INTEGER, t2, "alarm/2"); return(FALSE); } i1 = IntegerOfTerm(t); i2 = IntegerOfTerm(t2); if (i1 == 0 && i2 == 0) { #if _WIN32 Yap_get_signal( YAP_WINTIMER_SIGNAL ); #else Yap_get_signal( YAP_ALARM_SIGNAL ); #endif } #if _MSC_VER || defined(__MINGW32__) { Term tout; Int time[2]; time[0] = i1; time[1] = i2; if (time[0] != 0 && time[1] != 0) { DWORD dwThreadId; HANDLE hThread; hThread = CreateThread( NULL, /* no security attributes */ 0, /* use default stack size */ DoTimerThread, /* thread function */ (LPVOID)time, /* argument to thread function */ 0, /* use default creation flags */ &dwThreadId); /* returns the thread identifier */ /* Check the return value for success. */ if (hThread == NULL) { Yap_WinError("trying to use alarm"); } } tout = MkIntegerTerm(0); return Yap_unify(ARG3,tout) && Yap_unify(ARG4,MkIntTerm(0)); } #elif HAVE_SETITIMER && !SUPPORT_CONDOR { struct itimerval new, old; new.it_interval.tv_sec = 0; new.it_interval.tv_usec = 0; new.it_value.tv_sec = i1; new.it_value.tv_usec = i2; if (setitimer(ITIMER_REAL, &new, &old) < 0) { #if HAVE_STRERROR Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1, "setitimer: %s", strerror(errno)); #else Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1, "setitimer %d", errno); #endif return FALSE; } return Yap_unify(ARG3,MkIntegerTerm(old.it_value.tv_sec)) && Yap_unify(ARG4,MkIntegerTerm(old.it_value.tv_usec)); } #elif HAVE_ALARM && !SUPPORT_CONDOR { Int left; Term tout; left = alarm(i1); tout = MkIntegerTerm(left); return Yap_unify(ARG3,tout) && Yap_unify(ARG4,MkIntTerm(0)) ; } #else /* not actually trying to set the alarm */ if (IntegerOfTerm(t) == 0) return TRUE; Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "alarm not available in this configuration"); return FALSE; #endif } static Int virtual_alarm( USES_REGS1 ) { Term t = Deref(ARG1); Term t2 = Deref(ARG2); if (IsVarTerm(t)) { Yap_Error(INSTANTIATION_ERROR, t, "alarm/2"); return(FALSE); } if (!IsIntegerTerm(t)) { Yap_Error(TYPE_ERROR_INTEGER, t, "alarm/2"); return(FALSE); } if (IsVarTerm(t2)) { Yap_Error(INSTANTIATION_ERROR, t2, "alarm/2"); return(FALSE); } if (!IsIntegerTerm(t2)) { Yap_Error(TYPE_ERROR_INTEGER, t2, "alarm/2"); return(FALSE); } #if _MSC_VER || defined(__MINGW32__) { Term tout; Int time[2]; time[0] = IntegerOfTerm(t); time[1] = IntegerOfTerm(t2); if (time[0] != 0 && time[1] != 0) { DWORD dwThreadId; HANDLE hThread; hThread = CreateThread( NULL, /* no security attributes */ 0, /* use default stack size */ DoTimerThread, /* thread function */ (LPVOID)time, /* argument to thread function */ 0, /* use default creation flags */ &dwThreadId); /* returns the thread identifier */ /* Check the return value for success. */ if (hThread == NULL) { Yap_WinError("trying to use alarm"); } } tout = MkIntegerTerm(0); return Yap_unify(ARG3,tout) && Yap_unify(ARG4,MkIntTerm(0)); } #elif HAVE_SETITIMER && !SUPPORT_CONDOR { struct itimerval new, old; new.it_interval.tv_sec = 0; new.it_interval.tv_usec = 0; new.it_value.tv_sec = IntegerOfTerm(t); new.it_value.tv_usec = IntegerOfTerm(t2); if (setitimer(ITIMER_VIRTUAL, &new, &old) < 0) { #if HAVE_STRERROR Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1, "setitimer: %s", strerror(errno)); #else Yap_Error(SYSTEM_ERROR_OPERATING_SYSTEM, ARG1, "setitimer %d", errno); #endif return FALSE; } return Yap_unify(ARG3,MkIntegerTerm(old.it_value.tv_sec)) && Yap_unify(ARG4,MkIntegerTerm(old.it_value.tv_usec)); } #else /* not actually trying to set the alarm */ if (IntegerOfTerm(t) == 0) return TRUE; Yap_Error(SYSTEM_ERROR_INTERNAL, TermNil, "virtual_alarm not available in this configuration"); return FALSE; #endif } #ifdef VAX /* avoid longjmp botch */ int vax_absmi_fp; typedef struct { int eh; int flgs; int ap; int fp; int pc; int dummy1; int dummy2; int dummy3; int oldfp; int dummy4; int dummy5; int dummy6; int oldpc; } *VaxFramePtr; VaxFixFrame (dummy) { int maxframes = 100; VaxFramePtr fp = (VaxFramePtr) (((int *) &dummy) - 6); while (--maxframes) { fp = (VaxFramePtr) fp->fp; if (fp->flgs == 0) { if (fp->oldfp >= ®S[6] && fp->oldfp < ®S[REG_SIZE]) fp->oldfp = vax_absmi_fp; return; } } } #endif #if defined(_WIN32) #include int WINAPI win_yap(HANDLE, DWORD, LPVOID); int WINAPI win_yap(HANDLE hinst, DWORD reason, LPVOID reserved) { switch (reason) { case DLL_PROCESS_ATTACH: break; case DLL_PROCESS_DETACH: break; case DLL_THREAD_ATTACH: break; case DLL_THREAD_DETACH: break; } return 1; } #endif #if (defined(YAPOR) || defined(THREADS)) && !defined(USE_PTHREAD_LOCKING) #ifdef sparc void rw_lock_voodoo(void); void rw_lock_voodoo(void) { /* code taken from the Linux kernel, it handles shifting between locks */ /* Read/writer locks, as usual this is overly clever to make it as fast as possible. */ /* caches... */ __asm__ __volatile__( "___rw_read_enter_spin_on_wlock:\n" " orcc %g2, 0x0, %g0\n" " be,a ___rw_read_enter\n" " ldstub [%g1 + 3], %g2\n" " b ___rw_read_enter_spin_on_wlock\n" " ldub [%g1 + 3], %g2\n" "___rw_read_exit_spin_on_wlock:\n" " orcc %g2, 0x0, %g0\n" " be,a ___rw_read_exit\n" " ldstub [%g1 + 3], %g2\n" " b ___rw_read_exit_spin_on_wlock\n" " ldub [%g1 + 3], %g2\n" "___rw_write_enter_spin_on_wlock:\n" " orcc %g2, 0x0, %g0\n" " be,a ___rw_write_enter\n" " ldstub [%g1 + 3], %g2\n" " b ___rw_write_enter_spin_on_wlock\n" " ld [%g1], %g2\n" "\n" " .globl ___rw_read_enter\n" "___rw_read_enter:\n" " orcc %g2, 0x0, %g0\n" " bne,a ___rw_read_enter_spin_on_wlock\n" " ldub [%g1 + 3], %g2\n" " ld [%g1], %g2\n" " add %g2, 1, %g2\n" " st %g2, [%g1]\n" " retl\n" " mov %g4, %o7\n" " .globl ___rw_read_exit\n" "___rw_read_exit:\n" " orcc %g2, 0x0, %g0\n" " bne,a ___rw_read_exit_spin_on_wlock\n" " ldub [%g1 + 3], %g2\n" " ld [%g1], %g2\n" " sub %g2, 0x1ff, %g2\n" " st %g2, [%g1]\n" " retl\n" " mov %g4, %o7\n" " .globl ___rw_write_enter\n" "___rw_write_enter:\n" " orcc %g2, 0x0, %g0\n" " bne ___rw_write_enter_spin_on_wlock\n" " ld [%g1], %g2\n" " andncc %g2, 0xff, %g0\n" " bne,a ___rw_write_enter_spin_on_wlock\n" " stb %g0, [%g1 + 3]\n" " retl\n" " mov %g4, %o7\n" ); } #endif /* sparc */ #endif /* YAPOR || THREADS */ void Yap_InitSignalPreds(void) { CACHE_REGS Term cm = CurrentModule; Yap_InitCPred ("$fpe_error", 0, p_fpe_error, 0); Yap_InitCPred ("$alarm", 4, alarm4, SafePredFlag|SyncPredFlag); CurrentModule = HACKS_MODULE; Yap_InitCPred ("virtual_alarm", 4, virtual_alarm, SafePredFlag|SyncPredFlag); Yap_InitCPred ("enable_interrupts", 0, enable_interrupts, SafePredFlag); Yap_InitCPred ("disable_interrupts", 0, disable_interrupts, SafePredFlag); CurrentModule = cm; }