[thirdparty/cups.git] / config-scripts / cups-compiler.m4

dnl
dnl "$Id: cups-compiler.m4 7871 2008-08-27 21:12:43Z mike $"
dnl
dnl   Compiler stuff for the Common UNIX Printing System (CUPS).
dnl
dnl   Copyright 2007-2009 by Apple Inc.
dnl   Copyright 1997-2007 by Easy Software Products, all rights reserved.
dnl
dnl   These coded instructions, statements, and computer programs are the
dnl   property of Apple Inc. and are protected by Federal copyright
dnl   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
dnl   which should have been included with this file.  If this file is
dnl   file is missing or damaged, see the license at "http://www.cups.org/".
dnl

dnl Clear the debugging and non-shared library options unless the user asks
dnl for them...
INSTALL_STRIP=""
OPTIM=""
AC_SUBST(INSTALL_STRIP)
AC_SUBST(OPTIM)

AC_ARG_WITH(optim, [  --with-optim            set optimization flags ])
AC_ARG_ENABLE(debug, [  --enable-debug          build with debugging symbols])
AC_ARG_ENABLE(debug_guards, [  --enable-debug-guards   build with memory allocation guards])
AC_ARG_ENABLE(debug_printfs, [  --enable-debug-printfs  build with CUPS_DEBUG_LOG support])
AC_ARG_ENABLE(unit_tests, [  --enable-unit-tests     build and run unit tests])

dnl For debugging, keep symbols, otherwise strip them...
if test x$enable_debug = xyes; then
	OPTIM="-g"
else
	INSTALL_STRIP="-s"
fi

dnl Debug printfs can slow things down, so provide a separate option for that
if test x$enable_debug_printfs = xyes; then
	CFLAGS="$CFLAGS -DDEBUG"
	CXXFLAGS="$CXXFLAGS -DDEBUG"
fi

dnl Debug guards use an extra 4 bytes for some structures like strings in the
dnl string pool, so provide a separate option for that
if test x$enable_debug_guards = xyes; then
	CFLAGS="$CFLAGS -DDEBUG_GUARDS"
	CXXFLAGS="$CXXFLAGS -DDEBUG_GUARDS"
fi

dnl Unit tests take up time during a compile...
if test x$enable_unit_tests = xyes; then
	UNITTESTS="unittests"
else
	UNITTESTS=""
fi
AC_SUBST(UNITTESTS)

dnl Setup general architecture flags...
AC_ARG_WITH(archflags, [  --with-archflags        set default architecture flags ])
AC_ARG_WITH(ldarchflags, [  --with-ldarchflags      set program architecture flags ])

if test -z "$with_archflags"; then
	ARCHFLAGS=""
else
	ARCHFLAGS="$with_archflags"
fi

if test -z "$with_ldarchflags"; then
	if test "$uname" = Darwin; then
		# Only create 32-bit programs by default
		LDARCHFLAGS="`echo $ARCHFLAGS | sed -e '1,$s/-arch x86_64//' -e '1,$s/-arch ppc64//'`"
	else
		LDARCHFLAGS="$ARCHFLAGS"
	fi
else
	LDARCHFLAGS="$with_ldarchflags"
fi

AC_SUBST(ARCHFLAGS)
AC_SUBST(LDARCHFLAGS)

dnl Setup support for separate 32/64-bit library generation...
AC_ARG_WITH(arch32flags, [  --with-arch32flags      set 32-bit architecture flags])
ARCH32FLAGS=""
AC_SUBST(ARCH32FLAGS)

AC_ARG_WITH(arch64flags, [  --with-arch64flags      set 64-bit architecture flags])
ARCH64FLAGS=""
AC_SUBST(ARCH64FLAGS)

dnl Read-only data/program support on Linux...
AC_ARG_ENABLE(relro, [  --enable-relro          build with the GCC relro option])

dnl Update compiler options...
CXXLIBS="${CXXLIBS:=}"
AC_SUBST(CXXLIBS)

PIEFLAGS=""
AC_SUBST(PIEFLAGS)

RELROFLAGS=""
AC_SUBST(RELROFLAGS)

PHPOPTIONS=""
AC_SUBST(PHPOPTIONS)

if test -n "$GCC"; then
	# Add GCC-specific compiler options...
	if test -z "$OPTIM"; then
		if test "x$with_optim" = x; then
			# Default to optimize-for-size and debug
       			OPTIM="-Os -g"
		else
			OPTIM="$with_optim $OPTIM"
		fi
	fi

	# Generate position-independent code as needed...
	if test $PICFLAG = 1 -a $uname != AIX; then
    		OPTIM="-fPIC $OPTIM"
	fi

	# The -fstack-protector option is available with some versions of
	# GCC and adds "stack canaries" which detect when the return address
	# has been overwritten, preventing many types of exploit attacks.
	AC_MSG_CHECKING(if GCC supports -fstack-protector)
	OLDCFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS -fstack-protector"
	AC_TRY_LINK(,,
		OPTIM="$OPTIM -fstack-protector"
		AC_MSG_RESULT(yes),
		AC_MSG_RESULT(no))
	CFLAGS="$OLDCFLAGS"

	# The -pie option is available with some versions of GCC and adds
	# randomization of addresses, which avoids another class of exploits
	# that depend on a fixed address for common functions.
	AC_MSG_CHECKING(if GCC supports -pie)
	OLDCFLAGS="$CFLAGS"
	CFLAGS="$CFLAGS -pie -fPIE"
	AC_TRY_COMPILE(,,
		PIEFLAGS="-pie -fPIE"
		AC_MSG_RESULT(yes),
		AC_MSG_RESULT(no))
	CFLAGS="$OLDCFLAGS"

	if test "x$with_optim" = x; then
		# Add useful warning options for tracking down problems...
		OPTIM="-Wall -Wno-format-y2k $OPTIM"
		# Additional warning options for development testing...
		if test -d .svn; then
			OPTIM="-Wshadow -Wunused $OPTIM"
			CFLAGS="-Werror-implicit-function-declaration $CFLAGS"
			PHPOPTIONS="-Wno-shadow"
		fi
	fi

	case "$uname" in
		Darwin*)
			# -D_FORTIFY_SOURCE=2 adds additional object size
			# checking, basically wrapping all string functions
			# with buffer-limited ones.  Not strictly needed for
			# CUPS since we already use buffer-limited calls, but
			# this will catch any additions that are broken.		
			CFLAGS="$CFLAGS -D_FORTIFY_SOURCE=2"

			if test x$enable_pie = xyes; then
				# GCC 4 on Mac OS X needs -Wl,-pie as well
				LDFLAGS="$LDFLAGS -Wl,-pie"
			fi
			;;

		HP-UX*)
			if test "x$enable_32bit" = xyes; then
				# Build 32-bit libraries, 64-bit base...
				if test -z "$with_arch32flags"; then
					ARCH32FLAGS="-milp32"
				else
					ARCH32FLAGS="$with_arch32flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch64flags"; then
						ARCHFLAGS="-mlp64"
					else
						ARCHFLAGS="$with_arch64flags"
					fi
				fi
			fi

			if test "x$enable_64bit" = xyes; then
				# Build 64-bit libraries, 32-bit base...
				if test -z "$with_arch64flags"; then
					ARCH64FLAGS="-mlp64"
				else
					ARCH64FLAGS="$with_arch64flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch32flags"; then
						ARCHFLAGS="-milp32"
					else
						ARCHFLAGS="$with_arch32flags"
					fi
				fi
			fi
			;;

		IRIX)
			if test "x$enable_32bit" = xyes; then
				# Build 32-bit libraries, 64-bit base...
				if test -z "$with_arch32flags"; then
					ARCH32FLAGS="-n32 -mips3"
				else
					ARCH32FLAGS="$with_arch32flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch64flags"; then
						ARCHFLAGS="-64 -mips4"
					else
						ARCHFLAGS="$with_arch64flags"
					fi
				fi
			fi

			if test "x$enable_64bit" = xyes; then
				# Build 64-bit libraries, 32-bit base...
				if test -z "$with_arch64flags"; then
					ARCH64FLAGS="-64 -mips4"
				else
					ARCH64FLAGS="$with_arch64flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch32flags"; then
						ARCHFLAGS="-n32 -mips3"
					else
						ARCHFLAGS="$with_arch32flags"
					fi
				fi
			fi
			;;

		Linux*)
			# The -z relro option is provided by the Linux linker command to
			# make relocatable data read-only.
			if test x$enable_relro = xyes; then
				RELROFLAGS="-Wl,-z,relro"
			fi

			if test "x$enable_32bit" = xyes; then
				# Build 32-bit libraries, 64-bit base...
				if test -z "$with_arch32flags"; then
					ARCH32FLAGS="-m32"
				else
					ARCH32FLAGS="$with_arch32flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch64flags"; then
						ARCHFLAGS="-m64"
					else
						ARCHFLAGS="$with_arch64flags"
					fi
				fi
			fi

			if test "x$enable_64bit" = xyes; then
				# Build 64-bit libraries, 32-bit base...
				if test -z "$with_arch64flags"; then
					ARCH64FLAGS="-m64"
				else
					ARCH64FLAGS="$with_arch64flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch32flags"; then
						ARCHFLAGS="-m32"
					else
						ARCHFLAGS="$with_arch32flags"
					fi
				fi
			fi
			;;

		SunOS*)
			if test "x$enable_32bit" = xyes; then
				# Build 32-bit libraries, 64-bit base...
				if test -z "$with_arch32flags"; then
					ARCH32FLAGS="-m32"
				else
					ARCH32FLAGS="$with_arch32flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch64flags"; then
						ARCHFLAGS="-m64"
					else
						ARCHFLAGS="$with_arch64flags"
					fi
				fi
			fi

			if test "x$enable_64bit" = xyes; then
				# Build 64-bit libraries, 32-bit base...
				if test -z "$with_arch64flags"; then
					ARCH64FLAGS="-m64"
				else
					ARCH64FLAGS="$with_arch64flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch32flags"; then
						ARCHFLAGS="-m32"
					else
						ARCHFLAGS="$with_arch32flags"
					fi
				fi
			fi
			;;
	esac
else
	# Add vendor-specific compiler options...
	case $uname in
		AIX*)
			if test -z "$OPTIM"; then
				if test "x$with_optim" = x; then
					OPTIM="-O2 -qmaxmem=6000"
				else
					OPTIM="$with_optim $OPTIM"
				fi
			fi
			;;
		HP-UX*)
			if test -z "$OPTIM"; then
				if test "x$with_optim" = x; then
					OPTIM="+O2"
				else
					OPTIM="$with_optim $OPTIM"
				fi
			fi

			CFLAGS="-Ae $CFLAGS"

			if test $PICFLAG = 1; then
				OPTIM="+z $OPTIM"
			fi

			if test "x$enable_32bit" = xyes; then
				# Build 32-bit libraries, 64-bit base...
				if test -z "$with_arch32flags"; then
					ARCH32FLAGS="+DD32"
				else
					ARCH32FLAGS="$with_arch32flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch64flags"; then
						ARCHFLAGS="+DD64"
					else
						ARCHFLAGS="$with_arch64flags"
					fi
				fi
			fi

			if test "x$enable_64bit" = xyes; then
				# Build 64-bit libraries, 32-bit base...
				if test -z "$with_arch64flags"; then
					ARCH64FLAGS="+DD64"
				else
					ARCH64FLAGS="$with_arch64flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch32flags"; then
						ARCHFLAGS="+DD32"
					else
						ARCHFLAGS="$with_arch32flags"
					fi
				fi
			fi
			;;
        	IRIX)
			if test -z "$OPTIM"; then
				if test "x$with_optim" = x; then
					OPTIM="-O2"
				else
					OPTIM="$with_optim $OPTIM"
				fi
			fi

			if test "x$with_optim" = x; then
				OPTIM="-fullwarn -woff 1183,1209,1349,1506,3201 $OPTIM"
			fi

			if test "x$enable_32bit" = xyes; then
				# Build 32-bit libraries, 64-bit base...
				if test -z "$with_arch32flags"; then
					ARCH32FLAGS="-n32 -mips3"
				else
					ARCH32FLAGS="$with_arch32flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch64flags"; then
						ARCHFLAGS="-64 -mips4"
					else
						ARCHFLAGS="$with_arch64flags"
					fi
				fi
			fi

			if test "x$enable_64bit" = xyes; then
				# Build 64-bit libraries, 32-bit base...
				if test -z "$with_arch64flags"; then
					ARCH64FLAGS="-64 -mips4"
				else
					ARCH64FLAGS="$with_arch64flags"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch32flags"; then
						ARCHFLAGS="-n32 -mips3"
					else
						ARCHFLAGS="$with_arch32flags"
					fi
				fi
			fi
			;;
		OSF*)
			# Tru64 UNIX aka Digital UNIX aka OSF/1
			if test -z "$OPTIM"; then
				if test "x$with_optim" = x; then
					OPTIM="-O"
				else
					OPTIM="$with_optim"
				fi
			fi
			;;
		SunOS*)
			# Solaris
			if test -z "$OPTIM"; then
				if test "x$with_optim" = x; then
					OPTIM="-xO2"
				else
					OPTIM="$with_optim $OPTIM"
				fi
			fi

			if test $PICFLAG = 1; then
				OPTIM="-KPIC $OPTIM"
			fi

			if test "x$enable_32bit" = xyes; then
				# Compiling on a Solaris system, build 64-bit
				# binaries with separate 32-bit libraries...
				ARCH32FLAGS="-xarch=generic"

				if test "x$with_optim" = x; then
					# Suppress all of Sun's questionable
					# warning messages, and default to
					# 64-bit compiles of everything else...
					OPTIM="-w $OPTIM"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch64flags"; then
						ARCHFLAGS="-xarch=generic64"
					else
						ARCHFLAGS="$with_arch64flags"
					fi
				fi
			else
				if test "x$enable_64bit" = xyes; then
					# Build 64-bit libraries...
					ARCH64FLAGS="-xarch=generic64"
				fi

				if test "x$with_optim" = x; then
					# Suppress all of Sun's questionable
					# warning messages, and default to
					# 32-bit compiles of everything else...
					OPTIM="-w $OPTIM"
				fi

				if test -z "$with_archflags"; then
					if test -z "$with_arch32flags"; then
						ARCHFLAGS="-xarch=generic"
					else
						ARCHFLAGS="$with_arch32flags"
					fi
				fi
			fi
			;;
		UNIX_SVR*)
			# UnixWare
			if test -z "$OPTIM"; then
				if test "x$with_optim" = x; then
					OPTIM="-O"
				else
					OPTIM="$with_optim $OPTIM"
				fi
			fi

			if test $PICFLAG = 1; then
				OPTIM="-KPIC $OPTIM"
			fi
			;;
		*)
			# Running some other operating system; inform the user they
			# should contribute the necessary options to
			# cups-support@cups.org...
			echo "Building CUPS with default compiler optimizations; contact"
			echo "cups-bugs@cups.org with uname and compiler options needed"
			echo "for your platform, or set the CFLAGS and LDFLAGS environment"
			echo "variables before running configure."
			;;
	esac
fi

# Add general compiler options per platform...
case $uname in
	HP-UX*)
		# HP-UX 10.20 (at least) needs this definition to get the
		# h_errno global...
		OPTIM="$OPTIM -D_XOPEN_SOURCE_EXTENDED"

		# HP-UX 11.00 (at least) needs this definition to get the
		# u_short type used by the IP headers...
		OPTIM="$OPTIM -D_INCLUDE_HPUX_SOURCE"

		# HP-UX 11.23 (at least) needs this definition to get the
		# IPv6 header to work...
		OPTIM="$OPTIM -D_HPUX_SOURCE"
		;;

	Linux*)
		# glibc 2.8 and higher breaks peer credentials unless you
		# define _GNU_SOURCE...
		OPTIM="$OPTIM -D_GNU_SOURCE"
		;;

	OSF*)
		# Tru64 UNIX aka Digital UNIX aka OSF/1 need to be told
		# to be POSIX-compliant...
		OPTIM="$OPTIM -D_XOPEN_SOURCE=500 -D_XOPEN_SOURCE_EXTENDED -D_OSF_SOURCE"
		;;
esac

dnl
dnl End of "$Id: cups-compiler.m4 7871 2008-08-27 21:12:43Z mike $".
dnl
Commit	Line	Data
ef416fc2	1	dnl
b19ccc9e	2	dnl "$Id: cups-compiler.m4 7871 2008-08-27 21:12:43Z mike $"
ef416fc2	3	dnl
	4	dnl Compiler stuff for the Common UNIX Printing System (CUPS).
	5	dnl
745129be	6	dnl Copyright 2007-2009 by Apple Inc.
f7deaa1a	7	dnl Copyright 1997-2007 by Easy Software Products, all rights reserved.
ef416fc2	8	dnl
ef416fc2	9	dnl These coded instructions, statements, and computer programs are the
bc44d920	10	dnl property of Apple Inc. and are protected by Federal copyright
	11	dnl law. Distribution and use rights are outlined in the file "LICENSE.txt"
	12	dnl which should have been included with this file. If this file is
	13	dnl file is missing or damaged, see the license at "http://www.cups.org/".
ef416fc2	14	dnl
	15
	16	dnl Clear the debugging and non-shared library options unless the user asks
	17	dnl for them...
50fe7201	18	INSTALL_STRIP=""
ef416fc2	19	OPTIM=""
50fe7201	20	AC_SUBST(INSTALL_STRIP)
ef416fc2	21	AC_SUBST(OPTIM)
ef416fc2	22
bf3816c7 MS	23	AC_ARG_WITH(optim, [ --with-optim set optimization flags ])
	24	AC_ARG_ENABLE(debug, [ --enable-debug build with debugging symbols])
	25	AC_ARG_ENABLE(debug_guards, [ --enable-debug-guards build with memory allocation guards])
	26	AC_ARG_ENABLE(debug_printfs, [ --enable-debug-printfs build with CUPS_DEBUG_LOG support])
	27	AC_ARG_ENABLE(unit_tests, [ --enable-unit-tests build and run unit tests])
839a51c8 MS	28
	29	dnl For debugging, keep symbols, otherwise strip them...
	30	if test x$enable_debug = xyes; then
	31	OPTIM="-g"
	32	else
	33	INSTALL_STRIP="-s"
	34	fi
ef416fc2	35
5f64df29	36	dnl Debug printfs can slow things down, so provide a separate option for that
52f6f666	37	if test x$enable_debug_printfs = xyes; then
5f64df29	38	CFLAGS="$CFLAGS -DDEBUG"
94da7e34	39	CXXFLAGS="$CXXFLAGS -DDEBUG"
5f64df29 MS	40	fi
5f64df29 MS	41
745129be MS	42	dnl Debug guards use an extra 4 bytes for some structures like strings in the
	43	dnl string pool, so provide a separate option for that
	44	if test x$enable_debug_guards = xyes; then
	45	CFLAGS="$CFLAGS -DDEBUG_GUARDS"
94da7e34	46	CXXFLAGS="$CXXFLAGS -DDEBUG_GUARDS"
745129be MS	47	fi
745129be MS	48
5f64df29 MS	49	dnl Unit tests take up time during a compile...
	50	if test x$enable_unit_tests = xyes; then
	51	UNITTESTS="unittests"
	52	else
	53	UNITTESTS=""
	54	fi
	55	AC_SUBST(UNITTESTS)
	56
ed486911	57	dnl Setup general architecture flags...
bf3816c7 MS	58	AC_ARG_WITH(archflags, [ --with-archflags set default architecture flags ])
bf3816c7 MS	59	AC_ARG_WITH(ldarchflags, [ --with-ldarchflags set program architecture flags ])
ed486911	60
	61	if test -z "$with_archflags"; then
	62	ARCHFLAGS=""
	63	else
	64	ARCHFLAGS="$with_archflags"
a603edef MS	65	fi
	66
	67	if test -z "$with_ldarchflags"; then
09a101d6	68	if test "$uname" = Darwin; then
a603edef	69	# Only create 32-bit programs by default
09a101d6	70	LDARCHFLAGS="`echo $ARCHFLAGS \| sed -e '1,$s/-arch x86_64//' -e '1,$s/-arch ppc64//'`"
	71	else
	72	LDARCHFLAGS="$ARCHFLAGS"
	73	fi
a603edef	74	else
839a51c8	75	LDARCHFLAGS="$with_ldarchflags"
ed486911	76	fi
	77
	78	AC_SUBST(ARCHFLAGS)
09a101d6	79	AC_SUBST(LDARCHFLAGS)
ed486911	80
e1d6a774	81	dnl Setup support for separate 32/64-bit library generation...
bf3816c7	82	AC_ARG_WITH(arch32flags, [ --with-arch32flags set 32-bit architecture flags])
e1d6a774	83	ARCH32FLAGS=""
e1d6a774	84	AC_SUBST(ARCH32FLAGS)
e1d6a774	85
bf3816c7	86	AC_ARG_WITH(arch64flags, [ --with-arch64flags set 64-bit architecture flags])
e1d6a774	87	ARCH64FLAGS=""
e1d6a774	88	AC_SUBST(ARCH64FLAGS)
e1d6a774	89
f7deaa1a	90	dnl Read-only data/program support on Linux...
bf3816c7	91	AC_ARG_ENABLE(relro, [ --enable-relro build with the GCC relro option])
f7deaa1a	92
ef416fc2	93	dnl Update compiler options...
ac884b6a MS	94	CXXLIBS="${CXXLIBS:=}"
	95	AC_SUBST(CXXLIBS)
	96
a74454a7	97	PIEFLAGS=""
	98	AC_SUBST(PIEFLAGS)
	99
f7deaa1a	100	RELROFLAGS=""
	101	AC_SUBST(RELROFLAGS)
	102
7a14d768 MS	103	PHPOPTIONS=""
	104	AC_SUBST(PHPOPTIONS)
	105
ef416fc2	106	if test -n "$GCC"; then
2abf387c	107	# Add GCC-specific compiler options...
ef416fc2	108	if test -z "$OPTIM"; then
	109	if test "x$with_optim" = x; then
	110	# Default to optimize-for-size and debug
	111	OPTIM="-Os -g"
	112	else
	113	OPTIM="$with_optim $OPTIM"
	114	fi
	115	fi
	116
a4924f6c	117	# Generate position-independent code as needed...
ef416fc2	118	if test $PICFLAG = 1 -a $uname != AIX; then
	119	OPTIM="-fPIC $OPTIM"
	120	fi
	121
a4924f6c MS	122	# The -fstack-protector option is available with some versions of
	123	# GCC and adds "stack canaries" which detect when the return address
	124	# has been overwritten, preventing many types of exploit attacks.
	125	AC_MSG_CHECKING(if GCC supports -fstack-protector)
	126	OLDCFLAGS="$CFLAGS"
	127	CFLAGS="$CFLAGS -fstack-protector"
68b10830	128	AC_TRY_LINK(,,
a4924f6c MS	129	OPTIM="$OPTIM -fstack-protector"
	130	AC_MSG_RESULT(yes),
	131	AC_MSG_RESULT(no))
	132	CFLAGS="$OLDCFLAGS"
	133
	134	# The -pie option is available with some versions of GCC and adds
	135	# randomization of addresses, which avoids another class of exploits
	136	# that depend on a fixed address for common functions.
	137	AC_MSG_CHECKING(if GCC supports -pie)
	138	OLDCFLAGS="$CFLAGS"
	139	CFLAGS="$CFLAGS -pie -fPIE"
	140	AC_TRY_COMPILE(,,
	141	PIEFLAGS="-pie -fPIE"
	142	AC_MSG_RESULT(yes),
	143	AC_MSG_RESULT(no))
	144	CFLAGS="$OLDCFLAGS"
ef416fc2	145
	146	if test "x$with_optim" = x; then
	147	# Add useful warning options for tracking down problems...
	148	OPTIM="-Wall -Wno-format-y2k $OPTIM"
a4924f6c	149	# Additional warning options for development testing...
d9bca400 MS	150	if test -d .svn; then
d9bca400 MS	151	OPTIM="-Wshadow -Wunused $OPTIM"
749b1e90	152	CFLAGS="-Werror-implicit-function-declaration $CFLAGS"
7a14d768	153	PHPOPTIONS="-Wno-shadow"
d9bca400	154	fi
ef416fc2	155	fi
e1d6a774	156
e1d6a774	157	case "$uname" in
a4924f6c MS	158	Darwin*)
	159	# -D_FORTIFY_SOURCE=2 adds additional object size
	160	# checking, basically wrapping all string functions
	161	# with buffer-limited ones. Not strictly needed for
	162	# CUPS since we already use buffer-limited calls, but
	163	# this will catch any additions that are broken.
	164	CFLAGS="$CFLAGS -D_FORTIFY_SOURCE=2"
568fa3fa MS	165
	166	if test x$enable_pie = xyes; then
	167	# GCC 4 on Mac OS X needs -Wl,-pie as well
	168	LDFLAGS="$LDFLAGS -Wl,-pie"
	169	fi
a4924f6c MS	170	;;
a4924f6c MS	171
b86bc4cf	172	HP-UX*)
	173	if test "x$enable_32bit" = xyes; then
	174	# Build 32-bit libraries, 64-bit base...
	175	if test -z "$with_arch32flags"; then
	176	ARCH32FLAGS="-milp32"
	177	else
	178	ARCH32FLAGS="$with_arch32flags"
	179	fi
	180
	181	if test -z "$with_archflags"; then
	182	if test -z "$with_arch64flags"; then
	183	ARCHFLAGS="-mlp64"
	184	else
	185	ARCHFLAGS="$with_arch64flags"
	186	fi
	187	fi
	188	fi
	189
	190	if test "x$enable_64bit" = xyes; then
	191	# Build 64-bit libraries, 32-bit base...
	192	if test -z "$with_arch64flags"; then
	193	ARCH64FLAGS="-mlp64"
	194	else
	195	ARCH64FLAGS="$with_arch64flags"
	196	fi
	197
	198	if test -z "$with_archflags"; then
	199	if test -z "$with_arch32flags"; then
	200	ARCHFLAGS="-milp32"
	201	else
	202	ARCHFLAGS="$with_arch32flags"
	203	fi
	204	fi
	205	fi
	206	;;
	207
e1d6a774	208	IRIX)
	209	if test "x$enable_32bit" = xyes; then
	210	# Build 32-bit libraries, 64-bit base...
	211	if test -z "$with_arch32flags"; then
	212	ARCH32FLAGS="-n32 -mips3"
	213	else
	214	ARCH32FLAGS="$with_arch32flags"
	215	fi
e1d6a774	216
	217	if test -z "$with_archflags"; then
	218	if test -z "$with_arch64flags"; then
	219	ARCHFLAGS="-64 -mips4"
	220	else
	221	ARCHFLAGS="$with_arch64flags"
	222	fi
e1d6a774	223	fi
	224	fi
	225
	226	if test "x$enable_64bit" = xyes; then
	227	# Build 64-bit libraries, 32-bit base...
	228	if test -z "$with_arch64flags"; then
	229	ARCH64FLAGS="-64 -mips4"
	230	else
	231	ARCH64FLAGS="$with_arch64flags"
	232	fi
e1d6a774	233
	234	if test -z "$with_archflags"; then
	235	if test -z "$with_arch32flags"; then
	236	ARCHFLAGS="-n32 -mips3"
	237	else
	238	ARCHFLAGS="$with_arch32flags"
	239	fi
e1d6a774	240	fi
	241	fi
	242	;;
	243
	244	Linux*)
a4924f6c MS	245	# The -z relro option is provided by the Linux linker command to
	246	# make relocatable data read-only.
	247	if test x$enable_relro = xyes; then
	248	RELROFLAGS="-Wl,-z,relro"
	249	fi
	250
e1d6a774	251	if test "x$enable_32bit" = xyes; then
	252	# Build 32-bit libraries, 64-bit base...
	253	if test -z "$with_arch32flags"; then
	254	ARCH32FLAGS="-m32"
	255	else
	256	ARCH32FLAGS="$with_arch32flags"
	257	fi
e1d6a774	258
	259	if test -z "$with_archflags"; then
	260	if test -z "$with_arch64flags"; then
	261	ARCHFLAGS="-m64"
	262	else
	263	ARCHFLAGS="$with_arch64flags"
	264	fi
e1d6a774	265	fi
	266	fi
	267
	268	if test "x$enable_64bit" = xyes; then
	269	# Build 64-bit libraries, 32-bit base...
	270	if test -z "$with_arch64flags"; then
	271	ARCH64FLAGS="-m64"
	272	else
	273	ARCH64FLAGS="$with_arch64flags"
	274	fi
e1d6a774	275
	276	if test -z "$with_archflags"; then
	277	if test -z "$with_arch32flags"; then
	278	ARCHFLAGS="-m32"
	279	else
	280	ARCHFLAGS="$with_arch32flags"
	281	fi
e1d6a774	282	fi
	283	fi
	284	;;
	285
	286	SunOS*)
	287	if test "x$enable_32bit" = xyes; then
	288	# Build 32-bit libraries, 64-bit base...
	289	if test -z "$with_arch32flags"; then
	290	ARCH32FLAGS="-m32"
	291	else
	292	ARCH32FLAGS="$with_arch32flags"
	293	fi
e1d6a774	294
	295	if test -z "$with_archflags"; then
	296	if test -z "$with_arch64flags"; then
	297	ARCHFLAGS="-m64"
	298	else
	299	ARCHFLAGS="$with_arch64flags"
	300	fi
e1d6a774	301	fi
	302	fi
	303
	304	if test "x$enable_64bit" = xyes; then
	305	# Build 64-bit libraries, 32-bit base...
	306	if test -z "$with_arch64flags"; then
	307	ARCH64FLAGS="-m64"
	308	else
	309	ARCH64FLAGS="$with_arch64flags"
	310	fi
e1d6a774	311
	312	if test -z "$with_archflags"; then
	313	if test -z "$with_arch32flags"; then
	314	ARCHFLAGS="-m32"
	315	else
	316	ARCHFLAGS="$with_arch32flags"
	317	fi
e1d6a774	318	fi
	319	fi
	320	;;
	321	esac
ef416fc2	322	else
2abf387c	323	# Add vendor-specific compiler options...
ef416fc2	324	case $uname in
	325	AIX*)
	326	if test -z "$OPTIM"; then
	327	if test "x$with_optim" = x; then
	328	OPTIM="-O2 -qmaxmem=6000"
	329	else
	330	OPTIM="$with_optim $OPTIM"
	331	fi
	332	fi
	333	;;
	334	HP-UX*)
	335	if test -z "$OPTIM"; then
	336	if test "x$with_optim" = x; then
	337	OPTIM="+O2"
	338	else
	339	OPTIM="$with_optim $OPTIM"
	340	fi
	341	fi
	342
	343	CFLAGS="-Ae $CFLAGS"
	344
ef416fc2	345	if test $PICFLAG = 1; then
	346	OPTIM="+z $OPTIM"
	347	fi
c277e2f8 MS	348
	349	if test "x$enable_32bit" = xyes; then
	350	# Build 32-bit libraries, 64-bit base...
	351	if test -z "$with_arch32flags"; then
	352	ARCH32FLAGS="+DD32"
	353	else
	354	ARCH32FLAGS="$with_arch32flags"
	355	fi
	356
	357	if test -z "$with_archflags"; then
	358	if test -z "$with_arch64flags"; then
	359	ARCHFLAGS="+DD64"
	360	else
	361	ARCHFLAGS="$with_arch64flags"
	362	fi
	363	fi
	364	fi
	365
	366	if test "x$enable_64bit" = xyes; then
	367	# Build 64-bit libraries, 32-bit base...
	368	if test -z "$with_arch64flags"; then
	369	ARCH64FLAGS="+DD64"
	370	else
	371	ARCH64FLAGS="$with_arch64flags"
	372	fi
	373
	374	if test -z "$with_archflags"; then
	375	if test -z "$with_arch32flags"; then
	376	ARCHFLAGS="+DD32"
	377	else
	378	ARCHFLAGS="$with_arch32flags"
	379	fi
	380	fi
	381	fi
ef416fc2	382	;;
	383	IRIX)
	384	if test -z "$OPTIM"; then
	385	if test "x$with_optim" = x; then
	386	OPTIM="-O2"
	387	else
	388	OPTIM="$with_optim $OPTIM"
	389	fi
	390	fi
	391
e1d6a774	392	if test "x$with_optim" = x; then
e1d6a774	393	OPTIM="-fullwarn -woff 1183,1209,1349,1506,3201 $OPTIM"
ef416fc2	394	fi
ef416fc2	395
e1d6a774	396	if test "x$enable_32bit" = xyes; then
	397	# Build 32-bit libraries, 64-bit base...
	398	if test -z "$with_arch32flags"; then
	399	ARCH32FLAGS="-n32 -mips3"
	400	else
	401	ARCH32FLAGS="$with_arch32flags"
	402	fi
e1d6a774	403
	404	if test -z "$with_archflags"; then
	405	if test -z "$with_arch64flags"; then
	406	ARCHFLAGS="-64 -mips4"
	407	else
	408	ARCHFLAGS="$with_arch64flags"
	409	fi
e1d6a774	410	fi
	411	fi
	412
	413	if test "x$enable_64bit" = xyes; then
	414	# Build 64-bit libraries, 32-bit base...
	415	if test -z "$with_arch64flags"; then
	416	ARCH64FLAGS="-64 -mips4"
	417	else
	418	ARCH64FLAGS="$with_arch64flags"
	419	fi
e1d6a774	420
	421	if test -z "$with_archflags"; then
	422	if test -z "$with_arch32flags"; then
	423	ARCHFLAGS="-n32 -mips3"
	424	else
	425	ARCHFLAGS="$with_arch32flags"
	426	fi
ef416fc2	427	fi
	428	fi
	429	;;
2abf387c	430	OSF*)
	431	# Tru64 UNIX aka Digital UNIX aka OSF/1
	432	if test -z "$OPTIM"; then
	433	if test "x$with_optim" = x; then
	434	OPTIM="-O"
	435	else
	436	OPTIM="$with_optim"
	437	fi
	438	fi
	439	;;
ef416fc2	440	SunOS*)
	441	# Solaris
	442	if test -z "$OPTIM"; then
	443	if test "x$with_optim" = x; then
ed486911	444	OPTIM="-xO2"
ef416fc2	445	else
	446	OPTIM="$with_optim $OPTIM"
	447	fi
	448	fi
	449
ef416fc2	450	if test $PICFLAG = 1; then
	451	OPTIM="-KPIC $OPTIM"
	452	fi
e1d6a774	453
	454	if test "x$enable_32bit" = xyes; then
	455	# Compiling on a Solaris system, build 64-bit
	456	# binaries with separate 32-bit libraries...
	457	ARCH32FLAGS="-xarch=generic"
e1d6a774	458
	459	if test "x$with_optim" = x; then
	460	# Suppress all of Sun's questionable
	461	# warning messages, and default to
	462	# 64-bit compiles of everything else...
	463	OPTIM="-w $OPTIM"
f301802f	464	fi
	465
	466	if test -z "$with_archflags"; then
	467	if test -z "$with_arch64flags"; then
	468	ARCHFLAGS="-xarch=generic64"
	469	else
	470	ARCHFLAGS="$with_arch64flags"
	471	fi
e1d6a774	472	fi
	473	else
	474	if test "x$enable_64bit" = xyes; then
	475	# Build 64-bit libraries...
	476	ARCH64FLAGS="-xarch=generic64"
f301802f	477	fi
	478
	479	if test "x$with_optim" = x; then
	480	# Suppress all of Sun's questionable
	481	# warning messages, and default to
	482	# 32-bit compiles of everything else...
	483	OPTIM="-w $OPTIM"
	484	fi
e1d6a774	485
f301802f	486	if test -z "$with_archflags"; then
	487	if test -z "$with_arch32flags"; then
	488	ARCHFLAGS="-xarch=generic"
	489	else
	490	ARCHFLAGS="$with_arch32flags"
e1d6a774	491	fi
e1d6a774	492	fi
e1d6a774	493	fi
ef416fc2	494	;;
	495	UNIX_SVR*)
	496	# UnixWare
	497	if test -z "$OPTIM"; then
	498	if test "x$with_optim" = x; then
	499	OPTIM="-O"
	500	else
	501	OPTIM="$with_optim $OPTIM"
	502	fi
	503	fi
	504
	505	if test $PICFLAG = 1; then
	506	OPTIM="-KPIC $OPTIM"
	507	fi
	508	;;
	509	*)
	510	# Running some other operating system; inform the user they
	511	# should contribute the necessary options to
	512	# cups-support@cups.org...
	513	echo "Building CUPS with default compiler optimizations; contact"
	514	echo "cups-bugs@cups.org with uname and compiler options needed"
5bd77a73 MS	515	echo "for your platform, or set the CFLAGS and LDFLAGS environment"
5bd77a73 MS	516	echo "variables before running configure."
ef416fc2	517	;;
	518	esac
	519	fi
	520
2abf387c	521	# Add general compiler options per platform...
	522	case $uname in
	523	HP-UX*)
	524	# HP-UX 10.20 (at least) needs this definition to get the
	525	# h_errno global...
	526	OPTIM="$OPTIM -D_XOPEN_SOURCE_EXTENDED"
	527
	528	# HP-UX 11.00 (at least) needs this definition to get the
	529	# u_short type used by the IP headers...
	530	OPTIM="$OPTIM -D_INCLUDE_HPUX_SOURCE"
b94498cf	531
	532	# HP-UX 11.23 (at least) needs this definition to get the
	533	# IPv6 header to work...
	534	OPTIM="$OPTIM -D_HPUX_SOURCE"
2abf387c	535	;;
2abf387c	536
dd1abb6b MS	537	Linux*)
	538	# glibc 2.8 and higher breaks peer credentials unless you
	539	# define _GNU_SOURCE...
	540	OPTIM="$OPTIM -D_GNU_SOURCE"
	541	;;
	542
2abf387c	543	OSF*)
	544	# Tru64 UNIX aka Digital UNIX aka OSF/1 need to be told
	545	# to be POSIX-compliant...
	546	OPTIM="$OPTIM -D_XOPEN_SOURCE=500 -D_XOPEN_SOURCE_EXTENDED -D_OSF_SOURCE"
	547	;;
	548	esac
ef416fc2	549
ef416fc2	550	dnl
b19ccc9e	551	dnl End of "$Id: cups-compiler.m4 7871 2008-08-27 21:12:43Z mike $".
ef416fc2	552	dnl