ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/cebix/BasiliskII/src/Unix/configure.in

Comparing BasiliskII/src/Unix/configure.in (file contents):
Revision 1.38 by cebix, 2001-03-29T14:20:53Z vs.
Revision 1.48 by cebix, 2001-09-02T13:50:05Z

#	Line 9 | Line 9 | dnl Options.
9		AC_ARG_ENABLE(xf86-dga,      [  --enable-xf86-dga       use the XFree86 DGA extension [default=yes]], [WANT_XF86_DGA=$enableval], [WANT_XF86_DGA=yes])
10		AC_ARG_ENABLE(xf86-vidmode,  [  --enable-xf86-vidmode   use the XFree86 VidMode extension [default=yes]], [WANT_XF86_VIDMODE=$enableval], [WANT_XF86_VIDMODE=yes])
11		AC_ARG_ENABLE(fbdev-dga,     [  --enable-fbdev-dga      use direct frame buffer access via /dev/fb [default=yes]], [WANT_FBDEV_DGA=$enableval], [WANT_FBDEV_DGA=yes])
12	<	AC_ARG_ENABLE(vosf,          [  --enable-vosf           enable video on SEGV signals [default=no]], [WANT_VOSF=$enableval], [WANT_VOSF=no])
12	>	AC_ARG_ENABLE(vosf,          [  --enable-vosf           enable video on SEGV signals [default=yes]], [WANT_VOSF=$enableval], [WANT_VOSF=yes])
13
14		dnl FPU emulation core.
15		AC_ARG_ENABLE(fpe,
#	Line 52 | Line 52 | case "$target_os" in
52		netbsd*)      OS_TYPE=netbsd;;
53		freebsd*)     OS_TYPE=freebsd;;
54		solaris*)     OS_TYPE=solaris;;
55	<	*)            OS_TYPE=`echo $target_os | sed -e 's/-/_/' | sed -e 's/\./_/'`;;
55	>	darwin*)      OS_TYPE=darwin;;
56	>	*)            OS_TYPE=`echo $target_os | sed -e 's/-/_/g' | sed -e 's/\./_/g'`;;
57		esac
58		DEFINES="$DEFINES -DOS_$OS_TYPE"
59
#	Line 66 | Line 67 | case "$target_cpu" in
67		m68k* ) CPU_TYPE=m68k HAVE_M68K=yes;;
68		sparc* ) CPU_TYPE=sparc HAVE_SPARC=yes;;
69		powerpc* ) CPU_TYPE=powerpc HAVE_POWERPC=yes;;
70	<	*) CPU_TYPE=`echo $target_cpu | sed -e 's/-/_/'`;;
70	>	*) CPU_TYPE=`echo $target_cpu | sed -e 's/-/_/g'`;;
71		esac
72		DEFINES="$DEFINES -DCPU_$CPU_TYPE"
73
#	Line 100 | Line 101 | fi
101
102		dnl Checks for libraries.
103		AC_CHECK_LIB(posix4, sem_init)
104	+	AC_CHECK_LIB(rt, timer_create)
105
106		dnl We need X11.
107		AC_PATH_XTRA
#	Line 191 | Line 193 | fi
193
194		dnl Checks for header files.
195		AC_HEADER_STDC
196	<	AC_CHECK_HEADERS(unistd.h fcntl.h sys/time.h)
196	>	AC_CHECK_HEADERS(unistd.h fcntl.h sys/time.h sys/mman.h)
197
198		dnl Checks for typedefs, structures, and compiler characteristics.
199		AC_C_BIGENDIAN
#	Line 204 | Line 206 | AC_CHECK_SIZEOF(long long, 8)
206		AC_CHECK_SIZEOF(void *, 4)
207		AC_TYPE_OFF_T
208		AC_CHECK_TYPE(loff_t, off_t)
209	+	TYPE_SOCKLEN_T
210		AC_TYPE_SIZE_T
211		AC_TYPE_SIGNAL
212		AC_HEADER_TIME
#	Line 212 | Line 215 | AC_STRUCT_TM
215		dnl Checks for library functions.
216		AC_CHECK_FUNCS(strdup cfmakeraw)
217		AC_CHECK_FUNCS(clock_gettime timer_create)
218	+	AC_CHECK_FUNCS(sigaction signal)
219	+	AC_CHECK_FUNCS(mmap mprotect munmap)
220	+	AC_CHECK_FUNCS(vm_allocate vm_deallocate vm_protect)
221	+
222	+	dnl Darwin seems to define mach_task_self() instead of task_self().
223	+	AC_CHECK_FUNCS(mach_task_self task_self)
224
225		dnl Select system-dependant source files.
226		SERIALSRC=serial_unix.cpp
#	Line 257 | Line 266 | solaris*)
266		DEFINES="$DEFINES -DBSD_COMP -D_POSIX_PTHREAD_SEMANTICS"
267		;;
268		irix*)
269	+	ETHERSRC=ether_unix.cpp
270		AUDIOSRC=Irix/audio_irix.cpp
271		EXTRASYSSRCS=Irix/unaligned.c
272		dnl IRIX headers work fine, but somehow don't define or use "STDC_HEADERS"
273		DEFINES="$DEFINES -DCRTSCTS=CNEW_RTSCTS -DB230400=B115200 -DSTDC_HEADERS"
274		LIBS="$LIBS -laudio"
275	+	WANT_ESD=no
276
277		dnl Check if our compiler supports -Ofast (MIPSPro)
278		HAVE_OFAST=no
#	Line 296 | Line 307 | dnl to be put into the config.h file
307		dnl $1 -- the macro to define
308		dnl $2 -- the value to translate
309		AC_DEFUN(AC_TRANSLATE_DEFINE, [
310	<	if [[ "x$2" = "xyes" ]]; then
310	>	if [[ "x$2" = "xyes" -o "x$2" = "xguessing yes" ]]; then
311		AC_DEFINE($1)
312		fi
313		])
314
315	+	dnl Various checks if the system supports vm_allocate() and the like functions.
316	+	have_mach_vm=no
317	+	if [[ "x$ac_cv_func_vm_allocate" = "xyes" -a "x$ac_cv_func_vm_deallocate" = "xyes" -a \
318	+	"x$ac_cv_func_vm_protect" = "xyes" ]]; then
319	+	have_mach_vm=yes
320	+	fi
321	+	AC_TRANSLATE_DEFINE(HAVE_MACH_VM, "$have_mach_vm")
322	+
323	+	dnl Check that vm_allocate(), vm_protect() work
324	+	if [[ "x$have_mach_vm" = "xyes" ]]; then
325	+
326	+	AC_CACHE_CHECK("whether vm_protect works",
327	+	ac_cv_vm_protect_works, [
328	+	AC_LANG_SAVE
329	+	AC_LANG_CPLUSPLUS
330	+	ac_cv_vm_protect_works=yes
331	+	dnl First the tests that should segfault
332	+	for test_def in NONE_READ NONE_WRITE READ_WRITE; do
333	+	AC_TRY_RUN([
334	+	#define CONFIGURE_TEST_VM_MAP
335	+	#define TEST_VM_PROT_$test_def
336	+	#include "vm_alloc.cpp"
337	+	], ac_cv_vm_protect_works=no, rm -f core,
338	+	dnl When cross-compiling, do not assume anything
339	+	ac_cv_vm_protect_works="guessing no"
340	+	)
341	+	done
342	+	AC_TRY_RUN([
343	+	#define CONFIGURE_TEST_VM_MAP
344	+	#define TEST_VM_PROT_RDWR_WRITE
345	+	#include "vm_alloc.cpp"
346	+	], , ac_cv_vm_protect_works=no,
347	+	dnl When cross-compiling, do not assume anything
348	+	ac_cv_vm_protect_works="guessing no"
349	+	)
350	+	AC_LANG_RESTORE
351	+	]
352	+	)
353	+
354	+	dnl Remove support for vm_allocate() if vm_protect() does not work
355	+	if [[ "x$have_mach_vm" = "xyes" ]]; then
356	+	case $ac_cv_vm_protect_works in
357	+	*yes) have_mach_vm=yes;;
358	+	*no) have_mach_vm=no;;
359	+	esac
360	+	fi
361	+	AC_TRANSLATE_DEFINE(HAVE_MACH_VM, "$have_mach_vm")
362	+
363	+	fi dnl HAVE_MACH_VM
364	+
365	+	dnl Various checks if the system supports mmap() and the like functions.
366	+	dnl ... and Mach memory allocators are not supported
367	+	have_mmap_vm=no
368	+	if [[ "x$ac_cv_func_mmap" = "xyes" -a "x$ac_cv_func_munmap" = "xyes" -a \
369	+	"x$ac_cv_func_mprotect" = "xyes" ]]; then
370	+	if [[ "x$have_mach_vm" = "xno" ]]; then
371	+	have_mmap_vm=yes
372	+	fi
373	+	fi
374	+	AC_TRANSLATE_DEFINE(HAVE_MMAP_VM, "$have_mmap_vm")
375	+
376	+	dnl Check that mmap() and associated functions work.
377	+	if [[ "x$have_mmap_vm" = "xyes" ]]; then
378	+
379	+	dnl Check if we have a working anonymous mmap()
380	+	AC_CACHE_CHECK("whether mmap supports MAP_ANON",
381	+	ac_cv_mmap_anon, [
382	+	AC_LANG_SAVE
383	+	AC_LANG_CPLUSPLUS
384	+	AC_TRY_RUN([
385	+	#define HAVE_MMAP_ANON
386	+	#define CONFIGURE_TEST_VM_MAP
387	+	#define TEST_VM_MMAP_ANON
388	+	#include "vm_alloc.cpp"
389	+	], ac_cv_mmap_anon=yes, ac_cv_mmap_anon=no,
390	+	dnl When cross-compiling, do not assume anything.
391	+	ac_cv_mmap_anon="guessing no"
392	+	)
393	+	AC_LANG_RESTORE
394	+	]
395	+	)
396	+	AC_TRANSLATE_DEFINE(HAVE_MMAP_ANON, "$ac_cv_mmap_anon")
397	+
398	+	AC_CACHE_CHECK("whether mmap supports MAP_ANONYMOUS",
399	+	ac_cv_mmap_anonymous, [
400	+	AC_LANG_SAVE
401	+	AC_LANG_CPLUSPLUS
402	+	AC_TRY_RUN([
403	+	#define HAVE_MMAP_ANONYMOUS
404	+	#define CONFIGURE_TEST_VM_MAP
405	+	#define TEST_VM_MMAP_ANON
406	+	#include "vm_alloc.cpp"
407	+	], ac_cv_mmap_anonymous=yes, ac_cv_mmap_anonymous=no,
408	+	dnl When cross-compiling, do not assume anything.
409	+	ac_cv_mmap_anonymous="guessing no"
410	+	)
411	+	AC_LANG_RESTORE
412	+	]
413	+	)
414	+	AC_TRANSLATE_DEFINE(HAVE_MMAP_ANONYMOUS, "$ac_cv_mmap_anonymous")
415	+
416	+	AC_CACHE_CHECK("whether mprotect works",
417	+	ac_cv_mprotect_works, [
418	+	AC_LANG_SAVE
419	+	AC_LANG_CPLUSPLUS
420	+	ac_cv_mprotect_works=yes
421	+	dnl First the tests that should segfault
422	+	for test_def in NONE_READ NONE_WRITE READ_WRITE; do
423	+	AC_TRY_RUN([
424	+	#define CONFIGURE_TEST_VM_MAP
425	+	#define TEST_VM_PROT_$test_def
426	+	#include "vm_alloc.cpp"
427	+	], ac_cv_mprotect_works=no, rm -f core,
428	+	dnl When cross-compiling, do not assume anything
429	+	ac_cv_mprotect_works="guessing no"
430	+	)
431	+	done
432	+	AC_TRY_RUN([
433	+	#define CONFIGURE_TEST_VM_MAP
434	+	#define TEST_VM_PROT_RDWR_WRITE
435	+	#include "vm_alloc.cpp"
436	+	], , ac_cv_mprotect_works=no,
437	+	dnl When cross-compiling, do not assume anything
438	+	ac_cv_mprotect_works="guessing no"
439	+	)
440	+	AC_LANG_RESTORE
441	+	]
442	+	)
443	+
444	+	dnl Remove support for mmap() if mprotect() does not work
445	+	if [[ "x$have_mmap_vm" = "xyes" ]]; then
446	+	case $ac_cv_mprotect_works in
447	+	*yes) have_mmap_vm=yes;;
448	+	*no) have_mmap_vm=no;;
449	+	esac
450	+	fi
451	+	AC_TRANSLATE_DEFINE(HAVE_MMAP_VM, $have_mmap_vm)
452	+
453	+	fi dnl HAVE_MMAP_VM
454	+
455		dnl Check if we can mmap 0x2000 bytes from 0x0000
456		AC_CACHE_CHECK("whether we can map Low Memory area 0x0000-0x2000",
457		ac_cv_can_map_lm, [
458		AC_LANG_SAVE
459		AC_LANG_CPLUSPLUS
460		AC_TRY_RUN([
461	<	#include <unistd.h>
462	<	#include <fcntl.h>
463	<	#include <sys/mman.h>
464	<
465	<	int main()
466	<	{ int zero_fd; char * lm;
467	<	if ((zero_fd = open("/dev/zero", O_RDWR)) < 0) exit(1);
468	<	if ((lm = (char *)mmap((caddr_t)0x0000, 0x2000, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_PRIVATE, zero_fd, 0)) == MAP_FAILED) exit(1);
318	<	lm[0] = 0x12;
319	<	munmap(lm, 0x2000);
320	<	close(zero_fd);
321	<	exit(0);
461	>	#include "vm_alloc.cpp"
462	>	int main(void) { /* returns 0 if we could map the lowmem globals */
463	>	volatile char * lm;
464	>	if (vm_init() < 0) exit(1);
465	>	if ((lm = (volatile char *)vm_acquire_fixed(0, 0x2000)) == VM_MAP_FAILED) exit(1);
466	>	lm[0] = 'z';
467	>	if (vm_release((char *)lm, 0x2000) < 0) exit(1);
468	>	vm_exit(); exit(0);
469		}
470	<	],
471	<	[ac_cv_can_map_lm=yes],
472	<	[ac_cv_can_map_lm=no]
470	>	], ac_cv_can_map_lm=yes, ac_cv_can_map_lm=no,
471	>	dnl When cross-compiling, do not assume anything.
472	>	ac_cv_can_map_lm="guessing no"
473		)
474		AC_LANG_RESTORE
475		]
476		)
477
478	<	dnl Check if extended signals are supported.
479	<	AC_CACHE_CHECK("whether your system supports extended signal handlers",
480	<	ac_cv_have_extended_signals, [
478	>	dnl Check signal handlers need to be reinstalled
479	>	AC_CACHE_CHECK("whether signal handlers need to be reinstalled",
480	>	ac_cv_signal_need_reinstall, [
481		AC_LANG_SAVE
482		AC_LANG_CPLUSPLUS
483		AC_TRY_RUN([
337	–	#include <unistd.h>
484		#include <stdlib.h>
485	+	#ifdef HAVE_UNISTD_H
486	+	#include <unistd.h>
487	+	#endif
488		#include <signal.h>
489	<	#include <fcntl.h>
490	<	#include <sys/mman.h>
491	<
492	<	static volatile caddr_t mem = 0;
493	<	static int zero_fd = -1;
489	>	static int handled_signal = 0;
490	>	RETSIGTYPE sigusr1_handler(int) { handled_signal++; }
491	>	int main(void) { /* returns 0 if signals need not to be reinstalled */
492	>	signal(SIGUSR1, sigusr1_handler); raise(SIGUSR1); raise(SIGUSR1);
493	>	exit(handled_signal == 2);
494	>	}
495	>	], ac_cv_signal_need_reinstall=yes, ac_cv_signal_need_reinstall=no,
496	>	dnl When cross-compiling, do not assume anything.
497	>	ac_cv_signal_need_reinstall="guessing yes"
498	>	)
499	>	AC_LANG_RESTORE
500	>	]
501	>	)
502	>	AC_TRANSLATE_DEFINE(SIGNAL_NEED_REINSTALL, "$ac_cv_signal_need_reinstall")
503
504	<	static RETSIGTYPE segfault_handler(int, siginfo_t * sip, void *)
505	<	{ if ((caddr_t)(sip->si_addr) != mem) exit(1);
506	<	munmap(mem, getpagesize()); close(zero_fd); exit(0); }
507	<
508	<	int main()
509	<	{ if ((zero_fd = open("/dev/zero", O_RDWR)) < 0) exit(1);
510	<	if ((mem = (caddr_t)mmap(0, getpagesize(), PROT_READ, MAP_PRIVATE, zero_fd, 0)) == (caddr_t)MAP_FAILED) exit(1);
511	<	struct sigaction sa; sa.sa_sigaction = segfault_handler; sa.sa_flags = SA_SIGINFO;
512	<	sigaction(SIGSEGV, &sa, 0);
513	<	mem[0] = 0;
514	<	exit(1); // should not be reached
504	>	dnl Check if sigaction handlers need to be reinstalled
505	>	AC_CACHE_CHECK("whether sigaction handlers need to be reinstalled",
506	>	ac_cv_sigaction_need_reinstall, [
507	>	AC_LANG_SAVE
508	>	AC_LANG_CPLUSPLUS
509	>	AC_TRY_RUN([
510	>	#include <stdlib.h>
511	>	#ifdef HAVE_UNISTD_H
512	>	#include <unistd.h>
513	>	#endif
514	>	#include <signal.h>
515	>	static int handled_signal = 0;
516	>	RETSIGTYPE sigusr1_handler(int) { handled_signal++; }
517	>	typedef RETSIGTYPE (*signal_handler)(int);
518	>	static signal_handler mysignal(int sig, signal_handler handler) {
519	>	struct sigaction old_sa;
520	>	struct sigaction new_sa;
521	>	new_sa.sa_handler = handler;
522	>	return ((sigaction(sig,&new_sa,&old_sa) < 0) ? SIG_IGN : old_sa.sa_handler);
523	>	}
524	>	int main(void) { /* returns 0 if signals need not to be reinstalled */
525	>	mysignal(SIGUSR1, sigusr1_handler); raise(SIGUSR1); raise(SIGUSR1);
526	>	exit(handled_signal == 2);
527		}
528	<	],
529	<	[ac_cv_have_extended_signals=yes],
530	<	[ac_cv_have_extended_signals=no]
528	>	], ac_cv_sigaction_need_reinstall=yes, ac_cv_sigaction_need_reinstall=no,
529	>	dnl When cross-compiling, do not assume anything.
530	>	ac_cv_sigaction_need_reinstall="guessing yes"
531	>	)
532	>	AC_LANG_RESTORE
533	>	]
534	>	)
535	>	AC_TRANSLATE_DEFINE(SIGACTION_NEED_REINSTALL, "$ac_cv_sigaction_need_reinstall")
536	>
537	>	dnl Check if extended signals are supported.
538	>	AC_CACHE_CHECK("whether your system supports extended signal handlers",
539	>	ac_cv_have_extended_signals, [
540	>	AC_LANG_SAVE
541	>	AC_LANG_CPLUSPLUS
542	>	AC_TRY_RUN([
543	>	#define HAVE_SIGINFO_T 1
544	>	#define CONFIGURE_TEST_SIGSEGV_RECOVERY
545	>	#include "vm_alloc.cpp"
546	>	#include "sigsegv.cpp"
547	>	], ac_cv_have_extended_signals=yes, ac_cv_have_extended_signals=no,
548	>	dnl When cross-compiling, do not assume anything.
549	>	ac_cv_have_extended_signals=no
550		)
551		AC_LANG_RESTORE
552		]
#	Line 366 | Line 555 | AC_TRANSLATE_DEFINE(HAVE_SIGINFO_T, "$ac
555
556		dnl Otherwise, check for subterfuges.
557		if [[ "x$ac_cv_have_extended_signals" = "xno" ]]; then
558	<	case "$target_os" in
559	<	linux*)
560	<	if [[ "x$HAVE_I386" = "xyes" ]]; then
561	<	AC_CACHE_CHECK("whether we then have a subterfuge for your system",
562	<	ac_cv_have_sigcontext_hack, [
563	<	AC_LANG_SAVE
564	<	AC_LANG_CPLUSPLUS
565	<	AC_TRY_RUN([
566	<	#include <unistd.h>
567	<	#include <signal.h>
568	<	#include <fcntl.h>
569	<	#include <sys/mman.h>
570	<
571	<	static volatile caddr_t mem = 0;
572	<	static int zero_fd = -1;
573	<
385	<	static RETSIGTYPE segfault_handler(int, struct sigcontext scs)
386	<	{ if ((caddr_t)(scs.cr2) != mem) exit(1);
387	<	munmap(mem, getpagesize()); close(zero_fd); exit(0); }
388	<
389	<	int main()
390	<	{ if ((zero_fd = open("/dev/zero", O_RDWR)) < 0) exit(1);
391	<	if ((mem = (caddr_t)mmap(0, getpagesize(), PROT_READ, MAP_PRIVATE, zero_fd, 0)) == (caddr_t)MAP_FAILED) exit(1);
392	<	struct sigaction sa; sa.sa_flags = 0;
393	<	sa.sa_handler = (RETSIGTYPE (*)(int))segfault_handler;
394	<	sigaction(SIGSEGV, &sa, 0);
395	<	mem[0] = 0;
396	<	exit(1); // should not be reached
397	<	}
398	<	],
399	<	[ac_cv_have_sigcontext_hack=yes],
400	<	[ac_cv_have_sigcontext_hack=no]
401	<	)
402	<	AC_LANG_RESTORE
403	<	])
404	<	AC_TRANSLATE_DEFINE(HAVE_SIGCONTEXT_SUBTERFUGE, $ac_cv_have_sigcontext_hack)
405	<	elif [[ "x$HAVE_POWERPC" = "xyes" ]]; then
406	<	AC_CACHE_CHECK("whether we then have a subterfuge for your system",
407	<	ac_cv_have_sigcontext_hack, [
408	<	AC_LANG_SAVE
409	<	AC_LANG_CPLUSPLUS
410	<	AC_TRY_RUN([
411	<	#include <unistd.h>
412	<	#include <signal.h>
413	<	#include <fcntl.h>
414	<	#include <sys/mman.h>
415	<
416	<	static volatile caddr_t mem = 0;
417	<	static int zero_fd = -1;
418	<
419	<	static RETSIGTYPE segfault_handler(int, struct sigcontext_struct *scs)
420	<	{ if ((caddr_t)(scs->regs->dar) != mem) exit(1);
421	<	munmap(mem, getpagesize()); close(zero_fd); exit(0); }
422	<
423	<	int main()
424	<	{ if ((zero_fd = open("/dev/zero", O_RDWR)) < 0) exit(1);
425	<	if ((mem = (caddr_t)mmap(0, getpagesize(), PROT_READ, MAP_PRIVATE, zero_fd, 0)) == (caddr_t)MAP_FAILED) exit(1);
426	<	struct sigaction sa; sa.sa_flags = 0;
427	<	sa.sa_handler = (RETSIGTYPE (*)(int))segfault_handler;
428	<	sigaction(SIGSEGV, &sa, 0);
429	<	mem[0] = 0;
430	<	exit(1); // should not be reached
431	<	}
432	<	],
433	<	[ac_cv_have_sigcontext_hack=yes],
434	<	[ac_cv_have_sigcontext_hack=no]
435	<	)
436	<	AC_LANG_RESTORE
437	<	])
438	<	AC_TRANSLATE_DEFINE(HAVE_SIGCONTEXT_SUBTERFUGE, $ac_cv_have_sigcontext_hack)
439	<	fi
440	<	;;
441	<	netbsd*)
442	<	if [[ "x$HAVE_M68K" = "xyes" ]]; then
443	<	AC_CACHE_CHECK("whether we then have a subterfuge for your system",
444	<	ac_cv_have_sigcontext_hack, [
445	<	AC_LANG_SAVE
446	<	AC_LANG_CPLUSPLUS
447	<	AC_TRY_RUN([
448	<	#include <unistd.h>
449	<	#include <signal.h>
450	<	#include <fcntl.h>
451	<	#include <sys/mman.h>
452	<
453	<	static volatile caddr_t mem = 0;
454	<	static int zero_fd = -1;
455	<
456	<	static RETSIGTYPE segfault_handler(int, int code)
457	<	{ if ((caddr_t)code != mem) exit(1);
458	<	munmap(mem, getpagesize()); close(zero_fd); exit(0); }
459	<
460	<	int main()
461	<	{ if ((zero_fd = open("/dev/zero", O_RDWR)) < 0) exit(1);
462	<	if ((mem = (caddr_t)mmap(0, getpagesize(), PROT_READ, MAP_PRIVATE, zero_fd, 0)) == (caddr_t)MAP_FAILED) exit(1);
463	<	struct sigaction sa; sa.sa_flags = 0;
464	<	sa.sa_handler = (RETSIGTYPE (*)(int))segfault_handler;
465	<	sigaction(SIGSEGV, &sa, 0);
466	<	mem[0] = 0;
467	<	exit(1); // should not be reached
468	<	}
469	<	],
470	<	[ac_cv_have_sigcontext_hack=yes],
471	<	[ac_cv_have_sigcontext_hack=no]
472	<	)
473	<	AC_LANG_RESTORE
474	<	])
475	<	AC_TRANSLATE_DEFINE(HAVE_SIGCONTEXT_SUBTERFUGE, $ac_cv_have_sigcontext_hack)
476	<	fi
477	<	;;
478	<	esac
558	>	AC_CACHE_CHECK("whether we then have a subterfuge for your system",
559	>	ac_cv_have_sigcontext_hack, [
560	>	AC_LANG_SAVE
561	>	AC_LANG_CPLUSPLUS
562	>	AC_TRY_RUN([
563	>	#define HAVE_SIGCONTEXT_SUBTERFUGE 1
564	>	#define CONFIGURE_TEST_SIGSEGV_RECOVERY
565	>	#include "vm_alloc.cpp"
566	>	#include "sigsegv.cpp"
567	>	], ac_cv_have_sigcontext_hack=yes, ac_cv_have_sigcontext_hack=no,
568	>	dnl When cross-compiling, do not assume anything.
569	>	ac_cv_have_sigcontext_hack=no
570	>	)
571	>	AC_LANG_RESTORE
572	>	])
573	>	AC_TRANSLATE_DEFINE(HAVE_SIGCONTEXT_SUBTERFUGE, "$ac_cv_have_sigcontext_hack")
574		fi
575
576		dnl Can we do Video on SEGV Signals ?
#	Line 558 | Line 653 | AC_EGREP_CPP(yes,
653		#endif
654		], [AC_MSG_RESULT(yes); HAVE_GCC27=yes], AC_MSG_RESULT(no))
655
656	+	dnl Check for GCC 3.0 or higher.
657	+	HAVE_GCC30=no
658	+	AC_MSG_CHECKING(for GCC 3.0 or higher)
659	+	AC_EGREP_CPP(yes,
660	+	[#if __GNUC__ >= 3
661	+	yes
662	+	#endif
663	+	], [AC_MSG_RESULT(yes); HAVE_GCC30=yes], AC_MSG_RESULT(no))
664	+
665		dnl Set "-fomit-frame-pointer" on i386 GCC 2.7 or higher.
666		if [[ "x$HAVE_GCC27" = "xyes" -a "x$HAVE_I386" = "xyes" ]]; then
667		CFLAGS="$CFLAGS -fomit-frame-pointer"
668		CXXFLAGS="$CXXFLAGS -fomit-frame-pointer"
669		fi
670
671	+	dnl (gb) Do not merge constants since it breaks fpu/fpu_x86.cpp.
672	+	dnl As of 2001/08/02, this affects the following compilers:
673	+	dnl Official: probably gcc-3.1 (mainline CVS)
674	+	dnl Mandrake: gcc-2.96 >= 0.59mdk, gcc-3.0.1 >= 0.1mdk
675	+	dnl Red Hat : gcc-2.96 >= 89, gcc-3.0 >= 1
676	+	if [[ "x$HAVE_GCC27" = "xyes" ]]; then
677	+	SAVED_CXXFLAGS="$CXXFLAGS"
678	+	CXXFLAGS="$CXXFLAGS -fno-merge-constants"
679	+	AC_CACHE_CHECK([whether GCC supports constants merging], ac_cv_gcc_constants_merging, [
680	+	AC_LANG_SAVE
681	+	AC_LANG_CPLUSPLUS
682	+	AC_TRY_COMPILE([],[],[ac_cv_gcc_constants_merging=yes],[ac_cv_gcc_constants_merging=no])
683	+	AC_LANG_RESTORE
684	+	])
685	+	if [[ "x$ac_cv_gcc_constants_merging" != "xyes" ]]; then
686	+	CXXFLAGS="$SAVED_CXXFLAGS"
687	+	fi
688	+	fi
689	+
690		dnl Select appropriate CPU source and REGPARAM define.
691		ASM_OPTIMIZATIONS=none
692		CPUSRCS="cpuemu1.cpp cpuemu2.cpp cpuemu3.cpp cpuemu4.cpp cpuemu5.cpp cpuemu6.cpp cpuemu7.cpp cpuemu8.cpp"
693	<	FPUSRCS="../uae_cpu/fpp.cpp"
693	>	FPUSRCS="../uae_cpu/fpu/fpu_uae.cpp"
694		if [[ "x$HAVE_GCC27" = "xyes" -a "x$HAVE_I386" = "xyes" -a "x$OS_TYPE" != "xfreebsd" ]]; then
695		dnl i386 CPU
696		DEFINES="$DEFINES -DREGPARAM=\"__attribute__((regparm(3)))\""
#	Line 614 | Line 737 | if [[ "x$FPE_CORE" = "xdefault" ]]; then
737		DEFINES="$DEFINES -DFPU_X86"
738		FPE_CORE_STR="i386 optimized core"
739		FPUSRCS="../uae_cpu/fpu/fpu_x86.cpp"
740	+	FPE_CORE="i386"
741		else
742		FPE_CORE="uae"
743		fi
#	Line 654 | Line 778 | fi
778
779		dnl Remove the "-g" option if set for GCC.
780		if [[ "x$HAVE_GCC27" = "xyes" ]]; then
781	<	dnl gb-- Probably not the cleanest way to take
782	<	CFLAGS=`echo $CFLAGS | sed -e 's/ -g / /;s/^-g / /;s/ -g$/ /;s/^-g$//'`
659	<	CXXFLAGS=`echo $CXXFLAGS | sed -e 's/ -g / /;s/^-g / /;s/ -g$/ /;s/^-g$//'`
781	>	CFLAGS=`echo $CFLAGS | sed -e 's/-g//g'`
782	>	CXXFLAGS=`echo $CXXFLAGS | sed -e 's/-g//g'`
783		fi
784
785		dnl Or if we have -Ofast
786		if [[ "x$HAVE_OFAST" = "xyes" ]]; then
787	<	CFLAGS=`echo $CFLAGS | sed -e 's/ -g / -Ofast /;s/^-g /-Ofast /;s/-g$/ -Ofast/;s/^-g$/-Ofast/'`
788	<	CXXFLAGS=`echo $CXXFLAGS | sed -e 's/ -g / -Ofast /;s/^-g /-Ofast/;s/ -g$/ -Ofast/;s/^-g$/-Ofast/'`
787	>	CFLAGS="`echo $CFLAGS | sed -e 's/-g//g'` -Ofast"
788	>	CXXFLAGS="`echo $CXXFLAGS | sed -e 's/-g//g'` -Ofast"
789		CXXFLAGS="-LANG:std $CXXFLAGS"
790		LDFLAGS="$LDFLAGS -Ofast"
791		fi

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines