[projects/cmucl/cmucl.git] / src / lisp / FreeBSD-os.c

/*
 * FreeBSD-os.c. Maybe could be just BSD-os.c
 * From osf1-os.c,v 1.1 94/03/27 15:30:51 hallgren Exp $
 *
 * OS-dependent routines.  This file (along with os.h) exports an
 * OS-independent interface to the operating system VM facilities.
 * Suprisingly, this interface looks a lot like the Mach interface
 * (but simpler in some places).  For some operating systems, a subset
 * of these functions will have to be emulated.
 *
 * This is the OSF1 version.  By Sean Hallgren.
 * Much hacked by Paul Werkowski
 * GENCGC support by Douglas Crosher, 1996, 1997.
 *
 */

#include "os.h"
#include <sys/file.h>
#include <machine/npx.h>
#include <errno.h>
#include "arch.h"
#include "globals.h"
#include "interrupt.h"
#include "lispregs.h"
#include "internals.h"

#include <signal.h>
#include <dlfcn.h>
#include "validate.h"
#include <stdio.h>
#include <unistd.h>

#if defined GENCGC
#include "gencgc.h"
#endif

vm_size_t os_vm_page_size;

void
os_init0(const char *argv[], const char *envp[])
{}

void
os_init(const char *argv[], const char *envp[])
{
    os_vm_page_size = getpagesize();
}

unsigned long *
os_sigcontext_reg(ucontext_t *scp, int index)
{
    __register_t *rv;

    switch (index) {
      case 0:
        rv = &scp->uc_mcontext.mc_eax;
        break;
      case 2:
        rv = &scp->uc_mcontext.mc_ecx;
        break;
      case 4:
        rv = &scp->uc_mcontext.mc_edx;
        break;
      case 6:
        rv = &scp->uc_mcontext.mc_ebx;
        break;
      case 8:
        rv = &scp->uc_mcontext.mc_esp;
        break;
      case 10:
        rv = &scp->uc_mcontext.mc_ebp;
        break;
      case 12:
        rv = &scp->uc_mcontext.mc_esi;
        break;
      case 14:
        rv = &scp->uc_mcontext.mc_edi;
        break;
      default:
        rv = NULL;
    }
    
    /* Pre-cast to (void *), to avoid the compiler warning:
     * dereferencing type-punned pointer will break strict-aliasing rules
     */
    return (unsigned long *) (void *) rv;
}

unsigned long *
os_sigcontext_pc(ucontext_t *scp)
{
    return (unsigned long *) (void *) &scp->uc_mcontext.mc_eip;
}

unsigned char *
os_sigcontext_fpu_reg(ucontext_t *scp, int index)
{
    union savefpu *sv = (union savefpu *) scp->uc_mcontext.mc_fpstate;
    int fpformat = scp->uc_mcontext.mc_fpformat;
    unsigned char *reg = NULL;

    switch (fpformat) {
      case _MC_FPFMT_XMM:
          if (index < 8) {
              reg = sv->sv_xmm.sv_fp[index].fp_acc.fp_bytes;
          } else {
              reg = sv->sv_xmm.sv_xmm[index - 8].xmm_bytes;
          }
	  break;
      case _MC_FPFMT_387:
	  reg = sv->sv_87.sv_ac[index].fp_bytes;
	  break;
      case _MC_FPFMT_NODEV:
	  reg = NULL;
	  break;
    }
    return reg;
}

unsigned int
os_sigcontext_fpu_modes(ucontext_t *scp)
{
    unsigned int modes;

    union savefpu *sv = (union savefpu *) scp->uc_mcontext.mc_fpstate;
    int fpformat = scp->uc_mcontext.mc_fpformat;
    struct env87 *env_87 = &sv->sv_87.sv_env;
    struct envxmm *env_xmm = &sv->sv_xmm.sv_env;
    u_int16_t cw;
    u_int16_t sw;

    if (fpformat == _MC_FPFMT_XMM) {
	cw = env_xmm->en_cw;
	sw = env_xmm->en_sw;
    } else if (fpformat == _MC_FPFMT_387) {
	cw = env_87->en_cw & 0xffff;
	sw = env_87->en_sw & 0xffff;
    } else { /* _MC_FPFMT_NODEV */
	cw = 0;
	sw = 0x3f;
    }

    modes = ((cw & 0x3f) << 7) | (sw & 0x3f);

#ifdef FEATURE_SSE2
    if (fpu_mode == SSE2) {
	u_int32_t mxcsr = env_xmm->en_mxcsr;

	DPRINTF(0, (stderr, "SSE2 modes = %08x\n", (int)mxcsr));
	modes |= mxcsr;
    }
#endif
    modes ^= (0x3f << 7);
    return modes;
}

os_vm_address_t
os_validate(os_vm_address_t addr, os_vm_size_t len)
{
    int flags = MAP_PRIVATE | MAP_ANON;

    if (addr)
	flags |= MAP_FIXED;

    addr = mmap(addr, len, OS_VM_PROT_ALL, flags, -1, 0);

    if (addr == (os_vm_address_t) - 1) {
	perror("mmap");
	return NULL;
    }

    return addr;
}

void
os_invalidate(os_vm_address_t addr, os_vm_size_t len)
{
    if (munmap(addr, len) == -1)
	perror("munmap");
}

os_vm_address_t
os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len)
{
    addr = mmap(addr, len, OS_VM_PROT_ALL,
		MAP_PRIVATE | MAP_FILE | MAP_FIXED, fd, (off_t) offset);

    if (addr == (os_vm_address_t) - 1)
	perror("mmap");

    return addr;
}

void
os_flush_icache(os_vm_address_t address, os_vm_size_t length)
{
}

void
os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot)
{
    if (mprotect(address, length, prot) == -1)
	perror("mprotect");
}
\f


static boolean
in_range_p(os_vm_address_t a, lispobj sbeg, size_t slen)
{
    char *beg = (char *) sbeg;
    char *end = (char *) sbeg + slen;
    char *adr = (char *) a;

    return adr >= beg && adr < end;
}

boolean
valid_addr(os_vm_address_t addr)
{
    os_vm_address_t newaddr;

    newaddr = os_trunc_to_page(addr);

    if (in_range_p(addr, READ_ONLY_SPACE_START, read_only_space_size)
	|| in_range_p(addr, STATIC_SPACE_START, static_space_size)
	|| in_range_p(addr, DYNAMIC_0_SPACE_START, dynamic_space_size)
#ifndef GENCGC
	|| in_range_p(addr, DYNAMIC_1_SPACE_START, dynamic_space_size)
#endif
	|| in_range_p(addr, CONTROL_STACK_START, control_stack_size)
	|| in_range_p(addr, BINDING_STACK_START, binding_stack_size))
	return TRUE;
    return FALSE;
}
\f

static void
protection_violation_handler(HANDLER_ARGS)
{
#ifdef RED_ZONE_HIT
    if (os_control_stack_overflow(code->si_addr, context))
	return;
#endif

#if defined GENCGC
    if (code->si_code == PROTECTION_VIOLATION_CODE) {
	if (gc_write_barrier(code->si_addr)) {
	    return;
	}
    }
#endif

    interrupt_handle_now(signal, code, context);
}

/*
 * Restore the exception flags cleared by the kernel.  These bits must
 * be set for Lisp to determine which exception caused the signal.  At
 * present, there is no way to distinguish underflow exceptions from
 * denormalized operand exceptions.  An underflow exception is assumed
 * if the subcode is FPE_FLTUND.
 */
static void
sigfpe_handler(HANDLER_ARGS)
{
    ucontext_t *ucontext = (ucontext_t *) context;
    union savefpu *sv = (union savefpu *) ucontext->uc_mcontext.mc_fpstate;
    int fpformat = ucontext->uc_mcontext.mc_fpformat;
    unsigned char trap = 0;

    switch (code->si_code) {
      case FPE_FLTDIV:		/* ZE */
	  trap = 0x04;
	  break;
      case FPE_FLTOVF:		/* OE */
	  trap = 0x08;
	  break;
      case FPE_FLTUND:		/* DE or UE */
	  trap = 0x10;
	  break;
      case FPE_FLTRES:		/* PE */
	  trap = 0x20;
	  break;
      case FPE_FLTINV:		/* IE */
	  trap = 0x01;
	  break;
    }

    switch (fpformat) {
      case _MC_FPFMT_XMM:
	  sv->sv_xmm.sv_env.en_sw |= trap;
	  break;
      case _MC_FPFMT_387:
	  sv->sv_87.sv_env.en_sw |= trap;
	  break;
    }
    interrupt_handle_now(signal, code, context);
}

void
os_install_interrupt_handlers(void)
{
    interrupt_install_low_level_handler(PROTECTION_VIOLATION_SIGNAL,
					protection_violation_handler);
    interrupt_install_low_level_handler(SIGFPE, sigfpe_handler);
}

void *
os_dlsym(const char *sym_name, lispobj lib_list)
{
    static void *program_handle;

    if (!program_handle)
	program_handle = dlopen((void *) 0, RTLD_LAZY | RTLD_GLOBAL);

    if (lib_list != NIL) {
	lispobj lib_list_head;

	for (lib_list_head = lib_list;
	     lib_list_head != NIL; lib_list_head = CONS(lib_list_head)->cdr) {
	    struct cons *lib_cons = CONS(CONS(lib_list_head)->car);
	    struct sap *dlhandle = (struct sap *)PTR(lib_cons->car);
	    void *sym_addr = dlsym((void *)dlhandle->pointer, sym_name);

	    if (sym_addr)
		return sym_addr;
	}
    }
    return dlsym(program_handle, sym_name);
}

void
restore_fpu(ucontext_t *scp)
{
    union savefpu *sv = (union savefpu *) scp->uc_mcontext.mc_fpstate;
    int fpformat = scp->uc_mcontext.mc_fpformat;
    struct env87 *env_87 = &sv->sv_87.sv_env;
    struct envxmm *env_xmm = &sv->sv_xmm.sv_env;
    u_int16_t cw;

    if (fpformat == _MC_FPFMT_XMM) {
	cw = env_xmm->en_cw;
    } else if (fpformat == _MC_FPFMT_387) {
	cw = env_87->en_cw & 0xffff;
    } else { /* _MC_FPFMT_NODEV */
	return;
    }
    DPRINTF(0, (stderr, "restore_fpu:  cw = %08x\n", (int)cw));
    __asm__ __volatile__ ("fldcw %0"::"m"(*&cw));

#ifdef FEATURE_SSE2
    if (fpu_mode == SSE2) {
	u_int32_t mxcsr = env_xmm->en_mxcsr;

	DPRINTF(0, (stderr, "restore_fpu:  mxcsr (raw) = %04x\n", mxcsr));
	__asm__ __volatile__ ("ldmxcsr %0"::"m"(*&mxcsr));
    }
#endif
}

#ifdef i386
boolean
os_support_sse2()
{
    return TRUE;
}
#endif
Commit	Line	Data
5ced0fdf	1	/*
	2	* FreeBSD-os.c. Maybe could be just BSD-os.c
	3	* From osf1-os.c,v 1.1 94/03/27 15:30:51 hallgren Exp $
	4	*
	5	* OS-dependent routines. This file (along with os.h) exports an
	6	* OS-independent interface to the operating system VM facilities.
	7	* Suprisingly, this interface looks a lot like the Mach interface
	8	* (but simpler in some places). For some operating systems, a subset
	9	* of these functions will have to be emulated.
	10	*
	11	* This is the OSF1 version. By Sean Hallgren.
	12	* Much hacked by Paul Werkowski
0c41e522	13	* GENCGC support by Douglas Crosher, 1996, 1997.
0c41e522	14	*
5ced0fdf	15	*/
5ced0fdf	16
0bba8011	17	#include "os.h"
5ced0fdf	18	#include <sys/file.h>
9495c516	19	#include <machine/npx.h>
5ced0fdf	20	#include <errno.h>
5ced0fdf	21	#include "arch.h"
	22	#include "globals.h"
	23	#include "interrupt.h"
	24	#include "lispregs.h"
	25	#include "internals.h"
	26
0c41e522	27	#include <signal.h>
bf84be07	28	#include <dlfcn.h>
182365bc	29	#include "validate.h"
86957330	30	#include <stdio.h>
86957330	31	#include <unistd.h>
0c41e522	32
	33	#if defined GENCGC
	34	#include "gencgc.h"
	35	#endif
	36
670d643f	37	vm_size_t os_vm_page_size;
9a8c1c2f	38
670d643f	39	void
dafb9e03	40	os_init0(const char argv[], const char envp[])
	41	{}
	42
	43	void
0f0aed07	44	os_init(const char argv[], const char envp[])
5ced0fdf	45	{
9a8c1c2f	46	os_vm_page_size = getpagesize();
5ced0fdf	47	}
5ced0fdf	48
9495c516	49	unsigned long *
	50	os_sigcontext_reg(ucontext_t *scp, int index)
	51	{
0faa382f	52	__register_t *rv;
00353423	53
9495c516	54	switch (index) {
00353423	55	case 0:
68ac9a3e	56	rv = &scp->uc_mcontext.mc_eax;
68ac9a3e	57	break;
00353423	58	case 2:
68ac9a3e	59	rv = &scp->uc_mcontext.mc_ecx;
68ac9a3e	60	break;
00353423	61	case 4:
68ac9a3e	62	rv = &scp->uc_mcontext.mc_edx;
68ac9a3e	63	break;
00353423	64	case 6:
68ac9a3e	65	rv = &scp->uc_mcontext.mc_ebx;
68ac9a3e	66	break;
00353423	67	case 8:
68ac9a3e	68	rv = &scp->uc_mcontext.mc_esp;
68ac9a3e	69	break;
00353423	70	case 10:
68ac9a3e	71	rv = &scp->uc_mcontext.mc_ebp;
68ac9a3e	72	break;
00353423	73	case 12:
68ac9a3e	74	rv = &scp->uc_mcontext.mc_esi;
68ac9a3e	75	break;
00353423	76	case 14:
68ac9a3e	77	rv = &scp->uc_mcontext.mc_edi;
68ac9a3e	78	break;
00353423	79	default:
68ac9a3e	80	rv = NULL;
9495c516	81	}
68ac9a3e	82
0faa382f	83	/* Pre-cast to (void *), to avoid the compiler warning:
00353423	84	* dereferencing type-punned pointer will break strict-aliasing rules
0faa382f	85	*/
00353423	86	return (unsigned long ) (void ) rv;
9495c516	87	}
	88
	89	unsigned long *
	90	os_sigcontext_pc(ucontext_t *scp)
	91	{
0faa382f	92	return (unsigned long ) (void ) &scp->uc_mcontext.mc_eip;
9495c516	93	}
	94
	95	unsigned char *
	96	os_sigcontext_fpu_reg(ucontext_t *scp, int index)
	97	{
	98	union savefpu sv = (union savefpu ) scp->uc_mcontext.mc_fpstate;
	99	int fpformat = scp->uc_mcontext.mc_fpformat;
	100	unsigned char *reg = NULL;
	101
	102	switch (fpformat) {
00353423	103	case _MC_FPFMT_XMM:
b9c7bd10	104	if (index < 8) {
	105	reg = sv->sv_xmm.sv_fp[index].fp_acc.fp_bytes;
	106	} else {
	107	reg = sv->sv_xmm.sv_xmm[index - 8].xmm_bytes;
	108	}
00353423	109	break;
	110	case _MC_FPFMT_387:
	111	reg = sv->sv_87.sv_ac[index].fp_bytes;
	112	break;
	113	case _MC_FPFMT_NODEV:
	114	reg = NULL;
	115	break;
5ced0fdf	116	}
9495c516	117	return reg;
9495c516	118	}
9a8c1c2f	119
b17a70c7	120	unsigned int
9495c516	121	os_sigcontext_fpu_modes(ucontext_t *scp)
9495c516	122	{
b17a70c7	123	unsigned int modes;
00353423	124
249dadb0	125	union savefpu sv = (union savefpu ) scp->uc_mcontext.mc_fpstate;
9495c516	126	int fpformat = scp->uc_mcontext.mc_fpformat;
249dadb0	127	struct env87 *env_87 = &sv->sv_87.sv_env;
	128	struct envxmm *env_xmm = &sv->sv_xmm.sv_env;
	129	u_int16_t cw;
	130	u_int16_t sw;
9495c516	131
9495c516	132	if (fpformat == _MC_FPFMT_XMM) {
249dadb0	133	cw = env_xmm->en_cw;
249dadb0	134	sw = env_xmm->en_sw;
9495c516	135	} else if (fpformat == _MC_FPFMT_387) {
249dadb0	136	cw = env_87->en_cw & 0xffff;
249dadb0	137	sw = env_87->en_sw & 0xffff;
00353423	138	} else { /* _MC_FPFMT_NODEV */
9495c516	139	cw = 0;
	140	sw = 0x3f;
	141	}
249dadb0	142
	143	modes = ((cw & 0x3f) << 7) \| (sw & 0x3f);
	144
	145	#ifdef FEATURE_SSE2
c2323072	146	if (fpu_mode == SSE2) {
00353423	147	u_int32_t mxcsr = env_xmm->en_mxcsr;
	148
	149	DPRINTF(0, (stderr, "SSE2 modes = %08x\n", (int)mxcsr));
249dadb0	150	modes \|= mxcsr;
	151	}
	152	#endif
	153	modes ^= (0x3f << 7);
9495c516	154	return modes;
5ced0fdf	155	}
a18df860	156
00353423	157	os_vm_address_t
00353423	158	os_validate(os_vm_address_t addr, os_vm_size_t len)
5ced0fdf	159	{
1e078503	160	int flags = MAP_PRIVATE \| MAP_ANON;
a18df860	161
9a8c1c2f	162	if (addr)
9a8c1c2f	163	flags \|= MAP_FIXED;
5ced0fdf	164
9a8c1c2f	165	addr = mmap(addr, len, OS_VM_PROT_ALL, flags, -1, 0);
a18df860	166
9a8c1c2f	167	if (addr == (os_vm_address_t) - 1) {
	168	perror("mmap");
	169	return NULL;
5ced0fdf	170	}
a18df860	171
9a8c1c2f	172	return addr;
5ced0fdf	173	}
5ced0fdf	174
670d643f	175	void
9a8c1c2f	176	os_invalidate(os_vm_address_t addr, os_vm_size_t len)
5ced0fdf	177	{
9a8c1c2f	178	if (munmap(addr, len) == -1)
9a8c1c2f	179	perror("munmap");
5ced0fdf	180	}
5ced0fdf	181
670d643f	182	os_vm_address_t
9a8c1c2f	183	os_map(int fd, int offset, os_vm_address_t addr, os_vm_size_t len)
5ced0fdf	184	{
9a8c1c2f	185	addr = mmap(addr, len, OS_VM_PROT_ALL,
9a8c1c2f	186	MAP_PRIVATE \| MAP_FILE \| MAP_FIXED, fd, (off_t) offset);
a18df860	187
9a8c1c2f	188	if (addr == (os_vm_address_t) - 1)
9a8c1c2f	189	perror("mmap");
a18df860	190
9a8c1c2f	191	return addr;
5ced0fdf	192	}
5ced0fdf	193
670d643f	194	void
9a8c1c2f	195	os_flush_icache(os_vm_address_t address, os_vm_size_t length)
5ced0fdf	196	{
	197	}
	198
670d643f	199	void
9a8c1c2f	200	os_protect(os_vm_address_t address, os_vm_size_t length, os_vm_prot_t prot)
5ced0fdf	201	{
9a8c1c2f	202	if (mprotect(address, length, prot) == -1)
9a8c1c2f	203	perror("mprotect");
5ced0fdf	204	}
5ced0fdf	205	\f
a18df860	206
9a8c1c2f	207
670d643f	208	static boolean
9a8c1c2f	209	in_range_p(os_vm_address_t a, lispobj sbeg, size_t slen)
5ced0fdf	210	{
9a8c1c2f	211	char beg = (char ) sbeg;
	212	char end = (char ) sbeg + slen;
	213	char adr = (char ) a;
	214
	215	return adr >= beg && adr < end;
5ced0fdf	216	}
a18df860	217
00353423	218	boolean
00353423	219	valid_addr(os_vm_address_t addr)
5ced0fdf	220	{
9a8c1c2f	221	os_vm_address_t newaddr;
	222
	223	newaddr = os_trunc_to_page(addr);
670d643f	224
44a8f0c7 RT	225	if (in_range_p(addr, READ_ONLY_SPACE_START, read_only_space_size)
44a8f0c7 RT	226	\|\| in_range_p(addr, STATIC_SPACE_START, static_space_size)
9a8c1c2f	227	\|\| in_range_p(addr, DYNAMIC_0_SPACE_START, dynamic_space_size)
670d643f	228	#ifndef GENCGC
9a8c1c2f	229	\|\| in_range_p(addr, DYNAMIC_1_SPACE_START, dynamic_space_size)
670d643f	230	#endif
44a8f0c7 RT	231	\|\| in_range_p(addr, CONTROL_STACK_START, control_stack_size)
44a8f0c7 RT	232	\|\| in_range_p(addr, BINDING_STACK_START, binding_stack_size))
9a8c1c2f	233	return TRUE;
9a8c1c2f	234	return FALSE;
5ced0fdf	235	}
5ced0fdf	236	\f
9a8c1c2f	237
670d643f	238	static void
00353423	239	protection_violation_handler(HANDLER_ARGS)
5ced0fdf	240	{
670d643f	241	#ifdef RED_ZONE_HIT
00353423	242	if (os_control_stack_overflow(code->si_addr, context))
9a8c1c2f	243	return;
5ced0fdf	244	#endif
9a8c1c2f	245
670d643f	246	#if defined GENCGC
00353423	247	if (code->si_code == PROTECTION_VIOLATION_CODE) {
00353423	248	if (gc_write_barrier(code->si_addr)) {
f3e5780e	249	return;
f3e5780e	250	}
0c41e522	251	}
00353423	252	#endif
0c41e522	253
00353423	254	interrupt_handle_now(signal, code, context);
5ced0fdf	255	}
a18df860	256
9495c516	257	/*
	258	* Restore the exception flags cleared by the kernel. These bits must
	259	* be set for Lisp to determine which exception caused the signal. At
	260	* present, there is no way to distinguish underflow exceptions from
	261	* denormalized operand exceptions. An underflow exception is assumed
	262	* if the subcode is FPE_FLTUND.
	263	*/
	264	static void
00353423	265	sigfpe_handler(HANDLER_ARGS)
9495c516	266	{
00353423	267	ucontext_t ucontext = (ucontext_t ) context;
	268	union savefpu sv = (union savefpu ) ucontext->uc_mcontext.mc_fpstate;
	269	int fpformat = ucontext->uc_mcontext.mc_fpformat;
	270	unsigned char trap = 0;
9495c516	271
00353423	272	switch (code->si_code) {
00353423	273	case FPE_FLTDIV: /* ZE */
9495c516	274	trap = 0x04;
9495c516	275	break;
00353423	276	case FPE_FLTOVF: /* OE */
9495c516	277	trap = 0x08;
9495c516	278	break;
00353423	279	case FPE_FLTUND: /* DE or UE */
9495c516	280	trap = 0x10;
9495c516	281	break;
00353423	282	case FPE_FLTRES: /* PE */
9495c516	283	trap = 0x20;
9495c516	284	break;
00353423	285	case FPE_FLTINV: /* IE */
9495c516	286	trap = 0x01;
9495c516	287	break;
00353423	288	}
	289
	290	switch (fpformat) {
	291	case _MC_FPFMT_XMM:
9495c516	292	sv->sv_xmm.sv_env.en_sw \|= trap;
9495c516	293	break;
00353423	294	case _MC_FPFMT_387:
9495c516	295	sv->sv_87.sv_env.en_sw \|= trap;
9495c516	296	break;
00353423	297	}
00353423	298	interrupt_handle_now(signal, code, context);
9495c516	299	}
9495c516	300
670d643f	301	void
9a8c1c2f	302	os_install_interrupt_handlers(void)
5ced0fdf	303	{
00353423	304	interrupt_install_low_level_handler(PROTECTION_VIOLATION_SIGNAL,
00353423	305	protection_violation_handler);
9495c516	306	interrupt_install_low_level_handler(SIGFPE, sigfpe_handler);
5ced0fdf	307	}
bf84be07	308
670d643f	309	void *
9a8c1c2f	310	os_dlsym(const char *sym_name, lispobj lib_list)
bf84be07	311	{
b45fb97e	312	static void *program_handle;
b45fb97e	313
	314	if (!program_handle)
	315	program_handle = dlopen((void *) 0, RTLD_LAZY \| RTLD_GLOBAL);
	316
9a8c1c2f	317	if (lib_list != NIL) {
	318	lispobj lib_list_head;
	319
	320	for (lib_list_head = lib_list;
	321	lib_list_head != NIL; lib_list_head = CONS(lib_list_head)->cdr) {
	322	struct cons *lib_cons = CONS(CONS(lib_list_head)->car);
00353423	323	struct sap dlhandle = (struct sap )PTR(lib_cons->car);
00353423	324	void sym_addr = dlsym((void )dlhandle->pointer, sym_name);
9a8c1c2f	325
	326	if (sym_addr)
	327	return sym_addr;
bf84be07	328	}
bf84be07	329	}
b45fb97e	330	return dlsym(program_handle, sym_name);
bf84be07	331	}
9495c516	332
	333	void
	334	restore_fpu(ucontext_t *scp)
	335	{
	336	union savefpu sv = (union savefpu ) scp->uc_mcontext.mc_fpstate;
	337	int fpformat = scp->uc_mcontext.mc_fpformat;
249dadb0	338	struct env87 *env_87 = &sv->sv_87.sv_env;
	339	struct envxmm *env_xmm = &sv->sv_xmm.sv_env;
	340	u_int16_t cw;
9495c516	341
9495c516	342	if (fpformat == _MC_FPFMT_XMM) {
249dadb0	343	cw = env_xmm->en_cw;
9495c516	344	} else if (fpformat == _MC_FPFMT_387) {
249dadb0	345	cw = env_87->en_cw & 0xffff;
00353423	346	} else { /* _MC_FPFMT_NODEV */
9495c516	347	return;
9495c516	348	}
00353423	349	DPRINTF(0, (stderr, "restore_fpu: cw = %08x\n", (int)cw));
	350	__asm__ __volatile__ ("fldcw %0"::"m"(*&cw));
	351
249dadb0	352	#ifdef FEATURE_SSE2
03f8a6a6	353	if (fpu_mode == SSE2) {
00353423	354	u_int32_t mxcsr = env_xmm->en_mxcsr;
	355
	356	DPRINTF(0, (stderr, "restore_fpu: mxcsr (raw) = %04x\n", mxcsr));
	357	__asm__ __volatile__ ("ldmxcsr %0"::"m"(*&mxcsr));
249dadb0	358	}
249dadb0	359	#endif
9495c516	360	}
aa9c2237	361
	362	#ifdef i386
	363	boolean
	364	os_support_sse2()
	365	{
	366	return TRUE;
	367	}
	368	#endif
	369