xref: /haiku/configure (revision 088cebb96f8acf912cb13f1d92ce45a1729c25d6) 
1#!/bin/sh
2#
3# configure [ <options> ]
4
5# usage
6#
7# Prints usage.
8#
9usage()
10{
11	cat << EOF
12
13Usage: $0 <options>
14options:
15  --help                      Prints out this help.
16  --update                    Re-runs last configure invocation [must be given
17                              as first option!]
18  --bootstrap <haikuporter> <HaikuPorts cross repo> <HaikuPorts repo>
19                              Prepare for a bootstrap build. No pre-built
20                              packages will be used, instead they will be built
21                              from the sources (in several phases).
22                              <haikuporter> is the path to the haikuporter tool
23                              suitable for the host platform.
24                              <HaikuPorts cross repo> is the path to a checked
25                              out HaikuPorts cross-compilation repository.
26                              <HaikuPorts repo> is the path to a checked out
27                              HaikuPorts repository.
28  --build-cross-tools <arch> [ <build tools dir> ]
29                              Assume cross compilation. <build tools dir>
30                              defines the location of the build tools sources.
31                              They will be compiled and placed in the output
32                              directory under "cross-tools". The HAIKU_* tools
33                              variables will be set accordingly.
34                              <arch> specifies the target architecture, either
35                              "x86_gcc2", "x86", "x86_64", "ppc", "m68k",
36                              "arm", "arm64", "riscv64", "sparc"
37                              This option and --cross-tools-prefix can be
38                              specified multiple times. The first cross tools
39                              specify the primary tools, the subsequent ones the
40                              secondary tools (for "hybrid" images).
41                              For the first --build-cross-tools the
42                              <build tools dir> argument must be specified and
43                              for the subsequent ones it must be omitted.
44  --cross-tools-prefix <prefix>
45                              Assume cross compilation. <prefix> should be a
46                              path to the directory where the cross
47                              compilation tools are located, plus the platform
48                              prefix, e.g. "/path/to/tools/i586-pc-haiku-".
49                              This overrides the HAIKU_* tool variables.
50  --distro-compatibility <level>
51                              The distribution's level of compatibility with
52                              the official Haiku distribution. The generated
53                              files will contain the respective trademarks
54                              accordingly.
55                              official -- the official Haiku distribution.
56                              compatible -- a Haiku Compatible (tm) distro.
57                              default -- any other distro (default value).
58  --host-only                 Configure for building tools for the build host
59                              only. Haiku cannot be built when configured like
60                              this.
61  --include-sources           Includes the source code of projects that require
62                              either an offer of source code or a copy of the
63                              patched sources. This is preferable when
64                              distributing on physical mediums.
65  --include-3rdparty          Include 3rdparty/ in the build system.
66  -j<n>                       Only relevant for --build-cross-tools. Is passed
67                              on to the make building the build tools.
68  --no-downloads              Do not download anything. Useful when trying to
69                              bootstrap and build Haiku from source only.
70  --target-arch <arch>        Haiku only: Specify the target architecture to
71                              build for. Must be one of the architectures of the
72                              host system. The installed build tools for that
73                              architecture will be used.
74                              This option can be specified multiple times. The
75                              first occurrence specifies the primary
76                              architecture of the Haiku to build, subsequent
77                              ones the secondary architectures.
78  --use-clang <arch>          Build with host Clang instead of GCC cross
79                              compiler, targeting <arch>
80  --use-gcc-pipe              Build with GCC option -pipe. Speeds up the build
81                              process, but uses more memory.
82  --use-gcc-graphite          Build with GCC Graphite engine for loop
83                              optimizations. (Only for GCC 4+.)
84  --use-32bit                 Use -m32 flag on 64bit host gcc compiler.
85  --no-full-xattr             Do not use Linux/*BSD/Darwin's native extended file
86                              attributes as Haiku attributes. If they are still
87                              available, they will be used to store hashes for
88                              the attribute emulation layer.
89  --no-xattr                  Do not use Linux/*BSD/Darwin's native extended file
90                              attributes for Haiku extended attributes at all,
91                              even if they are available.
92  --with-gdb <gdb sources dir>
93                              specify the path to a GDB source dir, to build
94                              GDB for each arch we build the cross-tools for.
95
96environment variables:
97  CC                          The host compiler. Defaults to "gcc".
98  HAIKU_AR_<arch>             The static library archiver for <arch>.
99                              Defaults to "ar".
100  HAIKU_CC_<arch>             The compiler for <arch>. Defaults to "gcc".
101  HAIKU_LD_<arch>             The <arch> linker. Defaults to "ld".
102  HAIKU_OBJCOPY_<arch>        The <arch> objcopy to be used. Defaults to
103                              "objcopy".
104  HAIKU_RANLIB_<arch>         The static library indexer for <arch>. Defaults
105                              to "ranlib".
106  HAIKU_STRIP_<arch>          The <arch> strip command. Defaults to "strip".
107  HAIKU_NASM                  The nasm assembler (x86 and x86_64 only).
108  HAIKU_CPPFLAGS_<arch>       The preprocessor flags for target architecture
109                              <arch>. Defaults to "".
110  HAIKU_CCFLAGS_<arch>        The C flags for target architecture <arch>.
111                              Defaults to "".
112  HAIKU_CXXFLAGS_<arch>       The C++ flags for target architecture <arch>.
113                              Defaults to "".
114  HAIKU_LINKFLAGS_<arch>      The flags passed to the compiler when linking for
115                              target architecture <arch>. Defaults to "".
116  HAIKU_LDFLAGS_<arch>        The linker flags for target architecture <arch>.
117                              Defaults to "".
118  HAIKU_ARFLAGS_<arch>        The flags passed to HAIKU_AR for target
119                              architecture <arch> for archiving. Defaults to
120                              "cru".
121  HAIKU_UNARFLAGS_<arch>      The flags passed to HAIKU_AR for target
122                              architecture <arch> for unarchiving. Defaults to
123                              "x".
124
125Non-default output directories:
126  By default all objects, build configuration, and other related files are
127  stored in /path/to/haiku_source/generated.  To store objects in a non-default
128  location, run "../../relative/path/to/haiku_source/configure <options>" from
129  within your non-default location.  "jam [ options ] targets" can then be run
130  directly inside your non-default location.  Another option is to invoke "jam
131  [ options ] targets" from within haiku_source.  This can be accomplished by
132  either "export HAIKU_OUTPUT_DIR=your non-default location" before invoking
133  jam or by creating a symlink of haiku_source/generated pointing to your
134  non-default location and running jam.
135
136
137EOF
138}
139
140# assertparam
141#
142# Checks whether at least one parameter is left.
143#
144assertparam()
145{
146	if [ $2 -lt 2 ]; then
147		echo $0: \`$1\': Parameter expected.
148		exit 1
149	fi
150}
151
152# assertparams
153#
154# Checks whether at least a certain number of parameters is left.
155#
156assertparams()
157{
158	if [ $3 -le $2 ]; then
159		echo $0: \`$1\': Not enough parameters.
160		exit 1
161	fi
162}
163
164# absolute_path
165#
166# returns the absolute path of a given path.
167#
168absolute_path()
169{
170	if [ "x$1" != "x${1#/}" ]; then
171		echo "$1"
172	else
173		echo "`pwd`/$1"
174	fi
175}
176
177# check_dir_exists
178#
179# check if a directory exists or not
180#
181check_dir_exists()
182{
183	if [ -d "$1" ]; then
184		return 0
185	else
186		return 1
187	fi
188}
189
190# check_file_exists
191#
192# check if a file exists or not
193#
194check_file_exists()
195{
196	if [ -f "$1" ]; then
197		return 0
198	else
199		return 1
200	fi
201}
202
203# real_path
204#
205# returns the realpath of a symbolic link.
206#
207real_path()
208{
209	perl -MCwd=realpath -e'print realpath($ARGV[0]), "\n"' "$1"
210}
211
212# relative_to
213#
214# returns $1 relative to $2
215#
216relative_to()
217{
218	perl -e 'use File::Spec; print File::Spec->abs2rel(@ARGV) . "\n"' \
219		"$1" "$2"
220}
221
222# valid_toolchain
223#
224# check if a toolchain is valid
225#
226valid_toolchain()
227{
228	TRIPLET="$1"
229	BASE="$2"
230	SOURCE="$3"
231	if [ ! -d "$BASE" ]; then
232		return 1
233	fi
234	if [ -f "$BASE/bin/$TRIPLET-gcc" ]; then
235		[ "$BASE/bin/$TRIPLET-gcc" -nt "$SOURCE/legacy/gcc/configure" ] && \
236			[ "$BASE/bin/$TRIPLET-gcc" -nt "$SOURCE/gcc/gcc/configure" ]
237		return $?
238	fi
239	return 1
240}
241
242# standard_gcc_settings
243#
244# Sets the variables for a GCC platform.
245#
246standard_gcc_settings()
247{
248	local gcc="$1"
249
250	if which greadlink > /dev/null 2>&1; then
251		readlink="greadlink -e"
252	elif which realpath > /dev/null 2>&1; then
253		readlink=realpath
254	elif readlink -e / > /dev/null 2>&1; then
255		readlink="readlink -e"
256	else
257		readlink=real_path
258	fi
259
260	# PLATFORM_LINKLIBS
261	local gcclib=`$gcc -print-libgcc-file-name`
262	local gccdir=`dirname ${gcclib}`
263
264	local gccRawVersion=`$gcc -dumpversion`
265	local gccMachine=`$gcc -dumpmachine`
266
267	# determine architecture from machine triple
268	case $gccMachine in
269		arm-*)		targetCpu=arm;;
270		arm64-*)	targetCpu=arm64;;
271		i?86-*)		targetCpu=x86;;
272		m68k-*)		targetCpu=m68k;;
273		powerpc-*)	targetCpu=ppc;;
274		riscv64-*)	targetCpu=riscv64;;
275		sparc64-*)	targetCpu=sparc;;
276		x86_64-*)	targetCpu=x86_64;;
277		*)
278			echo "Unsupported gcc target machine: $gccMachine" >&2
279			exit 1
280			;;
281	esac
282
283	local targetArch=$targetCpu
284
285	case $gccRawVersion in
286		2.9*)
287			# check for correct (most up-to-date) legacy compiler and complain
288			# if an older one is installed
289			if [ $gccRawVersion != $haikuRequiredLegacyGCCVersion ]; then
290				echo "GCC version $haikuRequiredLegacyGCCVersion is required!";
291				echo "Please download it from www.haiku-os.org...";
292				exit 1;
293			fi
294
295			targetArch=x86_gcc2
296			;;
297	esac
298
299	local bootLibgcc
300	local bootLibSupCxx
301	local bootCxxHeaders
302	case $gccMachine in
303		x86_64-*)
304			# Boot loader is 32-bit, need the 32-bit libs and c++ config
305			bootLibgcc=`$gcc -m32 -print-file-name=libgcc.a`
306			bootLibSupCxx=`$gcc -m32 -print-file-name=libsupc++.a`
307
308			local headersBase=$gccdir/../../../..
309			local headers=$headersBase/$gccMachine/include/c++/$gccRawVersion
310			if [ ! -d $headers ]; then
311				headers=$headersBase/include/c++/$gccRawVersion
312			fi
313			bootCxxHeaders="$headers/$gccMachine/32"
314			;;
315	esac
316
317	# determine whether graphite loop optimization should/can be used
318	local useGraphite=`get_variable HAIKU_USE_GCC_GRAPHITE_$targetCpu`
319	if [ -z "$useGraphite" ]; then
320		useGraphite=$useGccGraphiteDefault
321	fi
322
323	if [ "$useGraphite" != 0 ]; then
324		UNUSED=`echo "int main() {}" | $gcc -xc -c -floop-block - 2>&1`
325		if [ $? != 0 ]; then
326			echo "GCC Graphite loop optimizations cannot be used on $targetArch"
327			useGraphite=0
328		fi
329	fi
330
331	set_variable HAIKU_CPU_$targetArch $targetCpu
332
333	get_build_tool_path CC_$targetArch "$gcc"
334	set_variable HAIKU_CC_IS_CLANG_$targetArch $useClang
335	set_variable HAIKU_GCC_RAW_VERSION_$targetArch $gccRawVersion
336	set_variable HAIKU_GCC_MACHINE_$targetArch $gccMachine
337	set_variable HAIKU_GCC_LIB_DIR_$targetArch $gccdir
338	set_variable HAIKU_BOOT_CXX_HEADERS_DIR_$targetArch "$bootCxxHeaders"
339	set_variable HAIKU_BOOT_LIBSUPCXX_$targetArch "$bootLibSupCxx"
340	set_variable HAIKU_BOOT_LIBGCC_$targetArch $bootLibgcc
341	set_variable HAIKU_USE_GCC_GRAPHITE_$targetArch $useGraphite
342
343	standard_gcc_settings_targetArch=$targetArch
344}
345
346# set_variable
347#
348# Set the value of a variable.
349#
350set_variable()
351{
352	eval "$1=\"$2\""
353}
354
355# get_variable
356#
357# Echo the value of a variable.
358#
359get_variable()
360{
361	eval "echo \${$1}"
362}
363
364# set_default_value
365#
366# Set the value for a variable, if no value is set yet.
367#
368set_default_value()
369{
370	eval "$1=\${$1-$2}"
371}
372
373# get_build_tool_path
374#
375# Gets a usable absolute path of a build tool.
376#
377get_build_tool_path()
378{
379	local var="HAIKU_$1"
380	local varval="`get_variable $var`"
381	local cmd="$2"
382
383	if [ ! -z "$varval" ]; then
384		# this variable is already set (probably by user) so grab its contents
385		cmd=$varval
386	fi
387
388	local path=${cmd%% *}
389
390	if [ -f "$path" ]; then
391		# get absolute path from relative path
392		local oldPwd="`pwd`"
393		cd "`dirname "$path"`"
394		path="`pwd`/`basename "$path"`"
395		cd $oldPwd
396	else
397		which "$path" > /dev/null 2>&1 || {
398			echo "Build tool \"$path\" not found (maybe specify it in $var?)" >&2
399			exit 1
400		}
401	fi
402
403	if test "${cmd#* }" != "$cmd"; then
404		# $cmd contains arguments, so preserve them (and only them)
405		cmd=${cmd#* }
406	else
407		# $cmd does not contain arguments, so unset it
408		cmd=
409	fi
410	eval "$var=\"$path $cmd\""
411}
412
413# check_native_xattrs
414#
415# Checks the host platform's support for extended attributes.
416# 0: no support, 1: only enough for xattr-ref, 2: full support
417#
418check_native_xattrs()
419{
420	local xattr_set=
421	local xattr_set_args=
422	local xattr_get=
423	local xattr_get_args=
424	case $HOST_PLATFORM in
425		haiku_host)
426			xattr_set="addattr"; xattr_set_args="\$NAME \"\$VALUE\""
427			xattr_get="catattr"; xattr_get_args="\$NAME"
428			;;
429		darwin)
430			xattr_set="xattr"; xattr_set_args="-w \$NAME \"\$VALUE\""
431			xattr_get="xattr"; xattr_get_args="-p \$NAME"
432			;;
433		freebsd)
434			xattr_set="setextattr"; xattr_set_args="user \$NAME \"\$VALUE\""
435			xattr_get="getextattr"; xattr_get_args="user \$NAME"
436			;;
437		linux)
438			xattr_set="setfattr"; xattr_set_args="-n user.\$NAME -v \"\$VALUE\""
439			xattr_get="getfattr"; xattr_get_args="-n user.\$NAME"
440			;;
441		*)
442			return 0
443			;;
444	esac
445	if ! type $xattr_set >/dev/null 2>&1; then
446		echo "$0: could not find $xattr_set, assuming host has no extended attributes"
447		return 0
448	elif ! type $xattr_get >/dev/null 2>&1; then
449		echo "$0: could not find $xattr_get, assuming host has no extended attributes"
450		return 0
451	fi
452
453	mkdir -p "$outputDir"
454	echo "xattr test file" >"$outputDir/xattrtest"
455	local i=0
456	# on round 0, we test if we can set 3 attrs of 1K each (enough for xattr-ref)
457	# on round 1, we test if we can set 3 attrs of 45K each (enough for full xattr)
458	while [ $i -lt 2 ]; do
459		local j=0
460		while [ $j -lt 3 ]; do
461			NAME=attr$j
462			VALUE=`printf '%*s' $((1024 + $i * 45056)) "" | tr ' ' x`
463			if [ `echo -n $VALUE | wc -c` -lt $((1024 + $i * 45056)) ]; then
464				echo "$0: warning: could not generate test data for extended attributes"
465				rm "$outputDir/xattrtest"
466				return $i
467			elif ! $xattr_set `eval echo \"$xattr_set_args\"` \
468					"$outputDir/xattrtest" >/dev/null 2>&1 ; then
469				rm "$outputDir/xattrtest"
470				return $i
471			fi
472			j=$((j+1))
473		done
474		i=$((i+1))
475	done
476	rm "$outputDir/xattrtest"
477	return 2
478}
479
480is_in_list()
481{
482	local element
483	for element in $2; do
484		if [ "$1" = "$element" ]; then
485			return 0
486		fi
487	done
488	return 1
489}
490
491# check for --help or -h and show usage immediately
492if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
493	usage; exit 0;
494fi
495
496# get cwd and the source directory
497currentDir=`pwd`
498cd `dirname "$0"`
499sourceDir=`pwd`
500cd "$currentDir"
501
502# determine output directory
503if [ "$currentDir" = "$sourceDir" ]; then
504	outputDir=$currentDir/generated
505else
506	outputDir=$currentDir
507fi
508buildOutputDir="$outputDir/build"
509HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes"
510buildConfigFile="$buildOutputDir/BuildConfig"
511
512# check for update request
513if [ "$1" = "--update" ]; then
514	if ! [ -e "$buildConfigFile" ]; then
515		echo $0 --update: \'$buildConfigFile\' not found - updating not possible.
516		exit 1
517	fi
518	# get last configure invocation and flags from BuildConfig and call ourselves with it
519	lastPwd=`grep "#d " "$buildConfigFile" | cut -c 4-`
520	lastConfig=`grep "#c " "$buildConfigFile" | cut -c 4-`
521	lastEnv=`grep "#e " "$buildConfigFile" | cut -c 4-`
522	lastArgs=`grep "#a " "$buildConfigFile" | cut -c 4-`
523	if [ -z "$lastConfig" ]; then
524		echo "$0 --update: The previous configure invocation was not properly" \
525			"encoded into '$buildConfigFile' - updating not possible."
526		exit 1
527	fi
528	cd "$lastPwd"
529	if [ -n "$lastEnv" ]; then
530		export $lastEnv
531	fi
532	$lastConfig $lastArgs
533	exit $?
534fi
535
536# backup the passed arguments
537configureArgs="$@"
538configurePath=$0
539
540# backup relevant environs
541configureEnvirons=
542for var in `env`; do
543	case "$var" in
544		CC\=*|HAIKU*\=*)
545			configureEnvirons="$configureEnvirons $var"
546			;;
547	esac
548done
549
550# ensure umask is not too restrictive
551if [ `umask` -gt 22 ]; then
552	echo Your umask is too restrictive "(should be <= 0022;" is actually `umask`")"
553	echo
554	echo Additionally, if the source tree was cloned with a too-restrictive umask,
555	echo you will need to run \"git checkout\" again to fix this.
556	exit 1
557fi
558# ensure git checkout was not done with a restrictive umask
559if [ `stat -c '%a' "$sourceDir/data/system/boot/SetupEnvironment"` -lt 644 ]; then
560	echo "The source tree was cloned with a umask > 0022. It seems you"
561	echo have already corrected your umask, but not re-checked-out the
562	echo source tree. Try running:
563	echo "	git checkout --force"
564	echo to fix this problem.
565	exit 1
566fi
567
568
569# internal default parameter values
570#
571platform=`uname`
572platformMachine=`uname  -m`
573targetArchs=
574buildCrossTools=
575buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools"
576buildCrossToolsJobs=
577useClang=0
578useGccGraphiteDefault=0
579unknownArchIndex=1
580haikuTargetArchs=
581gdbSources=
582
583if [ -z "$CC" ]; then
584	CC=gcc
585fi
586
587# exported (BuildSetup) default parameter values
588#
589HOST_GCC_RAW_VERSION=`$CC -dumpversion`
590HOST_GCC_MACHINE=`$CC -dumpmachine`
591HAIKU_INCLUDE_SOURCES=0
592HAIKU_INCLUDE_3RDPARTY=0
593HAIKU_DISTRO_COMPATIBILITY=default
594TARGET_PLATFORM=haiku
595HAIKU_USE_GCC_PIPE=0
596HAIKU_HOST_USE_32BIT=0
597HAIKU_HOST_USE_XATTR=
598HAIKU_HOST_USE_XATTR_REF=
599HAIKU_HOST_BUILD_ONLY=0
600HOST_EXTENDED_REGEX_SED="sed -r"
601HOST_GCC_LD=`$CC -print-prog-name=ld`
602HOST_GCC_OBJCOPY=`$CC -print-prog-name=objcopy`
603HOST_SHA256=
604HOST_HAIKU_PORTER=
605HAIKU_PORTS=
606HAIKU_PORTS_CROSS=
607HAIKU_IS_BOOTSTRAP=0
608HAIKU_NO_DOWNLOADS=0
609
610HAIKU_PACKAGING_ARCHS=
611
612set_default_value HAIKU_NASM		nasm
613
614if sha256sum < /dev/null > /dev/null 2>&1; then
615	HOST_SHA256=sha256sum
616elif sha256 < /dev/null > /dev/null 2>&1; then
617	HOST_SHA256="sha256 -q"
618elif shasum < /dev/null > /dev/null 2>&1; then
619	HOST_SHA256="shasum -a 256"
620else
621	echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2
622	exit 1
623fi
624
625haikuRequiredLegacyGCCVersion="2.95.3-haiku-2017_07_20"
626export haikuRequiredLegacyGCCVersion
627	# version of legacy gcc required to build haiku
628supportedTargetArchs="
629	arm
630	arm64
631	m68k
632	ppc
633	riscv64
634	sparc
635	x86
636	x86_64
637	x86_gcc2
638	"
639
640# parse parameters
641#
642while [ $# -gt 0 ] ; do
643	case "$1" in
644		--bootstrap)
645			assertparams "$1" 3 $#
646			HOST_HAIKU_PORTER="`absolute_path $2`"
647			HAIKU_PORTS_CROSS="`absolute_path $3`"
648			HAIKU_PORTS="`absolute_path $4`"
649			HAIKU_IS_BOOTSTRAP=1
650			HAIKU_NO_DOWNLOADS=1
651			check_file_exists "$HOST_HAIKU_PORTER" || (
652				echo "Invalid path to haikuporter: $HOST_HAIKU_PORTER" >&2
653				exit 1
654			)
655			check_dir_exists "$HAIKU_PORTS" || (
656				echo "Non-existent directory $HAIKU_PORTS" >&2
657				exit 1
658			)
659			check_dir_exists "$HAIKU_PORTS_CROSS" || (
660				echo "Non-existent directory $HAIKU_PORTS_CROSS" >&2
661				exit 1
662			)
663			shift 4
664			;;
665		--build-cross-tools)
666			if [ -z "$buildCrossTools" ]; then
667				assertparams "$1" 2 $#
668				targetArch=$2
669				buildCrossTools=$3
670				shift 3
671			else
672				assertparam "$1" $#
673				targetArch=$2
674				shift 2
675			fi
676			case "$targetArch" in
677				x86_gcc2)	targetMachine=i586-pc-haiku;;
678				x86)		targetMachine=i586-pc-haiku;;
679				x86_64)		targetMachine=x86_64-unknown-haiku;;
680				ppc)		targetMachine=powerpc-apple-haiku;;
681				m68k)		targetMachine=m68k-unknown-haiku;;
682				arm)		targetMachine=arm-unknown-haiku;;
683				riscv64)	targetMachine=riscv64-unknown-haiku;;
684				sparc)		targetMachine=sparc64-unknown-haiku;;
685				*)
686					echo "Unsupported target architecture: $targetArch" >&2
687					exit 1
688					;;
689			esac
690			set_variable buildCrossToolsMachine_$targetArch $targetMachine
691			targetArchs="$targetArchs $targetArch"
692			;;
693		--cross-tools-prefix)
694			assertparam "$1" $#
695			targetArch=unknown${unknownArchIndex}
696			set_variable crossToolsPrefix_$targetArch "$2"
697			targetArchs="$targetArchs $targetArch"
698			unknownArchIndex=$(($unknownArchIndex + 1))
699			shift 2
700			;;
701		--distro-compatibility)
702			assertparam "$1" $#
703			HAIKU_DISTRO_COMPATIBILITY=$2
704			case "$HAIKU_DISTRO_COMPATIBILITY" in
705				official)	;;
706				compatible)	;;
707				default)	;;
708				*)			echo "Invalid distro compatibility" \
709								"level: $HAIKU_DISTRO_COMPATIBILITY"
710							exit 1;;
711			esac
712			shift 2
713			;;
714		--host-only)	HAIKU_HOST_BUILD_ONLY=1; shift 1;;
715		--include-sources)	HAIKU_INCLUDE_SOURCES=1; shift 1;;
716		--include-3rdparty)	HAIKU_INCLUDE_3RDPARTY=1; shift 1;;
717        -j*)				buildCrossToolsJobs="$1"; shift 1;;
718		--no-downloads)	HAIKU_NO_DOWNLOADS=1; shift 1;;
719		--target-arch)
720			assertparam "$1" $#
721			targetArch=$2
722			shift 2
723			if [ ! "$platform" = Haiku ]; then
724				echo "--target-arch can only be specified on Haiku." >&2
725				exit 1
726			fi
727			is_in_list "$targetArch" "$supportedTargetArchs" || (
728				echo "Unsupported target architecture: \"$targetArch\"" >&2
729				exit 1
730			)
731			haikuTargetArchs="$haikuTargetArchs $targetArch"
732			;;
733		--use-clang)
734			assertparam "$1" $#
735			targetArch=$2
736			useClang=1
737			case "$targetArch" in
738				x86)		targetMachine=i586-pc-haiku;;
739				x86_64)		targetMachine=x86_64-unknown-haiku;;
740				ppc)		targetMachine=powerpc-apple-haiku;;
741				arm)		targetMachine=arm-unknown-haiku;;
742				arm64)		targetMachine=arm64-unknown-haiku;;
743				riscv64)	targetMachine=riscv64-unknown-haiku;;
744				sparc)		targetMachine=sparc64-unknown-haiku;;
745				*)
746					echo "Unsupported target architecture: $2" >&2
747					exit 1
748					;;
749			esac
750			get_build_tool_path clang clang
751			if [ -z `get_variable "crossToolsPrefix_$targetArch"` ] \
752					&& [ -z `get_variable buildCrossToolsMachine_$targetArch` ]; then
753				set_variable crossToolsPrefix_$targetArch llvm-
754			fi
755			clangVersion=`$HAIKU_clang -v 2>&1 | head -1 | cut -d " " -f3`
756			if [ `echo $clangVersion | head -c 1` -lt 7 ]; then
757				echo "Haiku requires Clang 7 or better to build, but you have $clangVersion."
758				echo "Please install a newer version."
759				exit 1
760			fi
761			targetArchs="$targetArchs $targetArch"
762			shift 2
763			;;
764		--use-gcc-pipe)	HAIKU_USE_GCC_PIPE=1; shift 1;;
765		--use-gcc-graphite)	useGccGraphiteDefault=1; shift 1;;
766		--use-32bit)	HAIKU_HOST_USE_32BIT=1; shift 1;;
767		--no-full-xattr)HAIKU_HOST_USE_XATTR=0; shift 1;;
768		--no-xattr)		HAIKU_HOST_USE_XATTR_REF=0; shift 1;;
769		--with-gdb)	gdbSources=$2; shift 2;;
770		*)				echo Invalid argument: \`$1\'; exit 1;;
771	esac
772done
773
774# detect the build platform
775case "${platform}" in
776	Darwin)	HOST_PLATFORM=darwin ;;
777	FreeBSD)	HOST_PLATFORM=freebsd
778				if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then
779					echo Unsupported platform: FreeBSD ${platformMachine}
780					exit 1
781				fi	;;
782	Haiku)	HOST_PLATFORM=haiku_host ;;
783	Linux)	HOST_PLATFORM=linux ;;
784	OpenBSD) HOST_PLATFORM=openbsd ;;
785	MINGW*) HOST_PLATFORM=mingw ;;
786	*)		echo Unsupported platform: ${platform}
787			exit 1 ;;
788esac
789
790# check for case-sensitive filesystem
791mkdir haikuCaseTest 2>/dev/null
792mkdir haikucasetest 2>/dev/null
793caseInsensitive=$?
794rmdir haikuCaseTest haikucasetest 2>/dev/null
795if [ $caseInsensitive != 0 ]; then
796	echo "You need a case-sensitive file-system to build Haiku."
797	if [ $HOST_PLATFORM = "darwin" ]; then
798		echo "You can create a case-sensitive disk image using Disk Utility."
799	fi
800	exit 1
801fi
802
803# check xattr support
804if [ -z $HAIKU_HOST_USE_XATTR_REF ]; then
805	check_native_xattrs
806	attrSupport=$?
807	if [ $attrSupport = 2 ] && [ -z $HAIKU_HOST_USE_XATTR ]; then
808		HAIKU_HOST_USE_XATTR=1
809	elif [ $attrSupport = 1 ]; then
810		HAIKU_HOST_USE_XATTR_REF=1
811	fi
812fi
813if [ -z $HAIKU_HOST_USE_XATTR ]; then HAIKU_HOST_USE_XATTR=0; fi
814if [ -z $HAIKU_HOST_USE_XATTR_REF ]; then HAIKU_HOST_USE_XATTR_REF=0; fi
815
816# determine how to invoke sed with extended regexp support for non-GNU sed
817if [ $HOST_PLATFORM = "darwin" ]; then
818	HOST_EXTENDED_REGEX_SED="sed -E"
819fi
820
821# locate python
822if python3 --version < /dev/null > /dev/null 2>&1; then
823	HOST_PYTHON="python3"
824elif python --version < /dev/null > /dev/null 2>&1; then
825	HOST_PYTHON="python"
826else
827	echo "a python interpreter is required"
828	exit 1
829fi
830
831# check if nasm can actually output ELF files
832# (the stock version in OSX can't)
833# XXX: should probably only test for x86* arch
834if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then
835	echo "$HAIKU_NASM cannot generate ELF files. Please install a working version."
836	if [ $HOST_PLATFORM = "darwin" ]; then
837		echo "You can install it from Mac Ports."
838		echo "Mac Ports is available at: http://www.macports.org/"
839	fi
840	exit 1
841fi
842
843# create output directory
844mkdir -p "$buildOutputDir" || exit 1
845
846if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then
847	invalidCommand=$sourceDir/build/scripts/host_build_only
848	HAIKU_AR=$invalidCommand
849	HAIKU_CC=$invalidCommand
850	HAIKU_LD=$invalidCommand
851	HAIKU_OBJCOPY=$invalidCommand
852	HAIKU_RANLIB=$invalidCommand
853	HAIKU_ELFEDIT=$invalidCommand
854	HAIKU_NASM=$invalidCommand
855	HAIKU_STRIP=$invalidCommand
856else
857	# On Haiku determine target architectures and tools automatically.
858	if [ -z "$targetArchs" ]; then
859		if [ $HOST_PLATFORM != haiku_host ]; then
860			echo "Please specify the build tools to use or build (via" \
861				"--cross-tools-prefix or --build-cross-tools) or specify a" \
862				"host-only build (--host-only)." >&2
863			echo "For more info, invoke $0 --help"
864			exit 1
865		fi
866
867		# determine primary architecture
868		targetArch=`package list -i /system/packages/haiku-*.hpkg \
869			| sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'`
870		is_in_list "$targetArch" "$supportedTargetArchs" || (
871			echo "Unsupported target architecture: \"$targetArch\"" >&2
872			exit 1
873		)
874		targetArchs=$targetArch
875
876		set_default_value HAIKU_AR_$targetArch			ar
877		set_default_value HAIKU_CC_$targetArch			gcc
878		set_default_value HAIKU_LD_$targetArch			ld
879		set_default_value HAIKU_OBJCOPY_$targetArch		objcopy
880		set_default_value HAIKU_RANLIB_$targetArch		ranlib
881		set_default_value HAIKU_ELFEDIT_$targetArch		elfedit
882		set_default_value HAIKU_STRIP_$targetArch		strip
883
884		# determine secondary architectures
885		for targetArch in $supportedTargetArchs; do
886			if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then
887				targetArchs="$targetArchs $targetArch"
888				set_default_value HAIKU_AR_$targetArch		ar-$targetArch
889				set_default_value HAIKU_CC_$targetArch		gcc-$targetArch
890				set_default_value HAIKU_LD_$targetArch		ld-$targetArch
891				set_default_value HAIKU_OBJCOPY_$targetArch	objcopy-$targetArch
892				set_default_value HAIKU_RANLIB_$targetArch	ranlib-$targetArch
893				set_default_value HAIKU_ELFEDIT_$targetArch	elfedit-$targetArch
894				set_default_value HAIKU_STRIP_$targetArch	strip-$targetArch
895			fi
896		done
897
898		# The target architectures might have been specified explicitly.
899		if [ -n "$haikuTargetArchs" ]; then
900			for targetArch in $haikuTargetArchs; do
901				is_in_list "$targetArch" "$targetArchs" || (
902					echo "Unsupported target architecture: \"$targetArch\"." \
903						"Only native architectures of the host platform can" \
904						"be specified." >&2
905					exit 1
906				)
907			done
908			targetArchs="$haikuTargetArchs"
909		fi
910	fi
911
912	isPrimaryArch=1
913	for targetArch in $targetArchs; do
914		# Note: targetArch is "unknown<n>" at this point if a cross-tools
915		# prefix was specified. The standard_gcc_settings call below will get
916		# the actual architecture.
917
918		if test "${HAIKU_PACKAGING_ARCHS#*$targetArch\b}" != "$HAIKU_PACKAGING_ARCHS"; then
919			# somehow we wound up with a duplicate arch; skip this one
920			continue
921		fi
922
923		crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
924
925		# build cross tools from sources
926		if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
927			crossToolsDir="$outputDir/cross-tools-$targetArch"
928			targetMachine=`get_variable buildCrossToolsMachine_$targetArch`
929			script="$buildCrossToolsScript"
930			scriptArgs=
931			if [ $targetArch != x86_gcc2 ]; then
932				script="${script}_gcc4"
933				scriptArgs="$targetMachine"
934				set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch	\
935					$useGccGraphiteDefault
936			fi
937			secondaryArch=
938			if [ -z "$isPrimaryArch" ]; then
939				secondaryArch=$targetArch
940			fi
941
942			case $HOST_PLATFORM in
943				freebsd|openbsd)	MAKE=gmake;;
944				*)					MAKE=make;;
945			esac
946
947			if ! valid_toolchain "${targetMachine}" "${crossToolsDir}" "${buildCrossTools}"; then
948				MAKE=$MAKE \
949				SECONDARY_ARCH=$secondaryArch \
950				HAIKU_USE_GCC_GRAPHITE=`get_variable \
951					HAIKU_USE_GCC_GRAPHITE_$targetArch` \
952				HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \
953				HAIKU_USE_GDB="$gdbSources" \
954				"$script" $scriptArgs "$sourceDir" "$buildCrossTools" \
955					"$crossToolsDir" $buildCrossToolsJobs || exit 1
956			else
957				echo "$targetArch crosstools already exist in $crossToolsDir; skipping build"
958			fi
959			crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-"
960		fi
961
962		# prepare gcc settings and get the actual target architecture
963		if [ $useClang = 1 ]; then
964			gcc="$HAIKU_clang -target ${targetMachine}"
965			if [ ! -z "${crossToolsPrefix}" ]; then
966				gcc="$gcc -B ${crossToolsPrefix}"
967			fi
968
969			# Clang's compiler intrinsics are not compatible with GCC's or even
970			# across versions of Clang, so we must collect them for use in the build.
971			mkdir -p "$outputDir/clang_headers" || exit 1
972			clangHeadersDir=`$gcc -print-resource-dir`/include/
973			case $targetArch in
974				x86*) cp $clangHeadersDir/*intrin* $clangHeadersDir/mm3* "$outputDir/clang_headers" || exit 1 ;;
975				ppc*) cp $clangHeadersDir/*altivec* "$outputDir/clang_headers" || exit 1 ;;
976				arm*) cp $clangHeadersDir/*arm* "$outputDir/clang_headers" || exit 1 ;;
977			esac
978		elif [ -z "${crossToolsPrefix}" ]; then
979			gcc=`get_variable HAIKU_CC_$targetArch`
980		else
981			gcc="${crossToolsPrefix}gcc"
982		fi
983		standard_gcc_settings "$gcc"
984		targetArch=$standard_gcc_settings_targetArch
985
986		# set default values for flags
987		set_default_value HAIKU_CPPFLAGS_$targetArch	""
988		set_default_value HAIKU_CCFLAGS_$targetArch		""
989		set_default_value HAIKU_CXXFLAGS_$targetArch	""
990		set_default_value HAIKU_LINKFLAGS_$targetArch	""
991		set_default_value HAIKU_LDFLAGS_$targetArch		""
992		set_default_value HAIKU_ARFLAGS_$targetArch		cru
993		set_default_value HAIKU_UNARFLAGS_$targetArch	x
994
995		# Override the cross tools variables, if the tools were built or a
996		# prefix was specified.
997		if [ $useClang = 1 ]; then
998			get_build_tool_path LD_$targetArch ld.lld
999			get_build_tool_path ELFEDIT_$targetArch elfedit
1000		elif [ -n "$crossToolsPrefix" ]; then
1001			get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld
1002			case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in
1003				4.*|5.*|6.*|7.*|8.*)
1004					get_build_tool_path ELFEDIT_$targetArch \
1005						${crossToolsPrefix}elfedit
1006				;;
1007			esac
1008		fi
1009		if [ -n "$crossToolsPrefix" ]; then
1010			get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar
1011			get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy
1012			get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib
1013			get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip
1014		fi
1015
1016		# check whether the Haiku compiler really targets Haiku
1017		targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch`
1018		case "$targetMachine" in
1019			*-*-haiku)	;;
1020			*)
1021				echo The compiler specified as Haiku target compiler is not a \
1022				valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
1023				echo compiler: $HAIKU_CC
1024				echo compiler is configured for target: $targetMachine
1025				exit 1 ;;
1026		esac
1027
1028		HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
1029		isPrimaryArch=
1030	done
1031fi
1032
1033# Generate BuildConfig
1034cat << EOF > "$buildConfigFile"
1035# -- WARNING --
1036# This file was AUTOMATICALLY GENERATED by configure, and will be completely
1037# overwritten the next time configure is run.
1038#
1039#d ${currentDir}
1040#c ${configurePath}
1041#e ${configureEnvirons}
1042#a ${configureArgs}
1043
1044HOST_PLATFORM				?= "${HOST_PLATFORM}" ;
1045TARGET_PLATFORM 			?= "${TARGET_PLATFORM}" ;
1046HAIKU_PACKAGING_ARCHS		?= ${HAIKU_PACKAGING_ARCHS} ;
1047
1048HAIKU_NO_DOWNLOADS			?= "${HAIKU_NO_DOWNLOADS}" ;
1049HAIKU_INCLUDE_SOURCES		?= "${HAIKU_INCLUDE_SOURCES}" ;
1050HAIKU_INCLUDE_3RDPARTY		?= "${HAIKU_INCLUDE_3RDPARTY}" ;
1051HAIKU_DISTRO_COMPATIBILITY	?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
1052
1053HAIKU_USE_GCC_PIPE			?= "${HAIKU_USE_GCC_PIPE}" ;
1054HAIKU_HOST_USE_32BIT		?= "${HAIKU_HOST_USE_32BIT}" ;
1055HAIKU_HOST_USE_XATTR		?= "${HAIKU_HOST_USE_XATTR}" ;
1056HAIKU_HOST_USE_XATTR_REF	?= "${HAIKU_HOST_USE_XATTR_REF}" ;
1057HAIKU_HOST_BUILD_ONLY		?= "${HAIKU_HOST_BUILD_ONLY}" ;
1058
1059HOST_CC						?= ${CC} ;
1060HOST_GCC_RAW_VERSION		?= ${HOST_GCC_RAW_VERSION} ;
1061HOST_GCC_MACHINE			?= ${HOST_GCC_MACHINE} ;
1062HOST_LD						?= ${HOST_GCC_LD} ;
1063HOST_OBJCOPY				?= ${HOST_GCC_OBJCOPY} ;
1064HOST_EXTENDED_REGEX_SED		?= ${HOST_EXTENDED_REGEX_SED} ;
1065HOST_SHA256					?= ${HOST_SHA256} ;
1066HOST_PYTHON					?= ${HOST_PYTHON} ;
1067HAIKU_NASM					?= ${HAIKU_NASM} ;
1068
1069HAIKU_BUILD_ATTRIBUTES_DIR	?= "${HAIKU_BUILD_ATTRIBUTES_DIR}" ;
1070
1071HOST_HAIKU_PORTER			?= ${HOST_HAIKU_PORTER} ;
1072HAIKU_PORTS					?= ${HAIKU_PORTS} ;
1073HAIKU_PORTS_CROSS			?= ${HAIKU_PORTS_CROSS} ;
1074HAIKU_IS_BOOTSTRAP			?= ${HAIKU_IS_BOOTSTRAP} ;
1075
1076EOF
1077
1078for targetArch in $HAIKU_PACKAGING_ARCHS; do
1079	variables="
1080		HAIKU_CC					HAIKU_CC
1081		HAIKU_CC_IS_CLANG			HAIKU_CC_IS_CLANG
1082		HAIKU_USE_GCC_GRAPHITE		HAIKU_USE_GCC_GRAPHITE
1083		HAIKU_CPU					HAIKU_CPU
1084		HAIKU_GCC_MACHINE			HAIKU_GCC_MACHINE
1085		HAIKU_GCC_RAW_VERSION		HAIKU_GCC_RAW_VERSION
1086		HAIKU_GCC_LIB_DIR			HAIKU_GCC_LIB_DIR
1087		HAIKU_BOOT_LIBGCC			HAIKU_BOOT_LIBGCC
1088		HAIKU_BOOT_LIBSUPC++		HAIKU_BOOT_LIBSUPCXX
1089		HAIKU_AR					HAIKU_AR
1090		HAIKU_LD					HAIKU_LD
1091		HAIKU_OBJCOPY				HAIKU_OBJCOPY
1092		HAIKU_RANLIB				HAIKU_RANLIB
1093		HAIKU_ELFEDIT				HAIKU_ELFEDIT
1094		HAIKU_STRIP					HAIKU_STRIP
1095		HAIKU_CPPFLAGS				HAIKU_CPPFLAGS
1096		HAIKU_CCFLAGS				HAIKU_CCFLAGS
1097		HAIKU_C++FLAGS				HAIKU_CXXFLAGS
1098		HAIKU_LINKFLAGS				HAIKU_LINKFLAGS
1099		HAIKU_LDFLAGS				HAIKU_LDFLAGS
1100		HAIKU_ARFLAGS				HAIKU_ARFLAGS
1101		HAIKU_UNARFLAGS				HAIKU_UNARFLAGS
1102		"
1103	set -- $variables
1104	while [ $# -ge 2 ]; do
1105		value=`get_variable ${2}_$targetArch`
1106		echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile"
1107		shift 2
1108	done
1109
1110	# For variables that may have long values, distribute them over multiple
1111	# lines so that jam doesn't hit the maximum line length.
1112	variables="
1113		HAIKU_BOOT_C++_HEADERS_DIR	HAIKU_BOOT_CXX_HEADERS_DIR
1114		"
1115	set -- $variables
1116	while [ $# -ge 2 ]; do
1117		echo "${1}_${targetArch} ?= " >> "$buildConfigFile"
1118		get_variable ${2}_$targetArch | xargs -n 1 echo "   " \
1119			>> "$buildConfigFile"
1120		echo "    ;" >> "$buildConfigFile"
1121		shift 2
1122	done
1123done
1124
1125
1126# Generate a Jamfile in the output directory.
1127
1128cat << EOF > $outputDir/Jamfile
1129# -- WARNING --
1130# This file was AUTOMATICALLY GENERATED by configure, and will be completely
1131# overwritten the next time configure is run.
1132
1133HAIKU_TOP			= $(relative_to "${sourceDir}" "${outputDir}") ;
1134HAIKU_OUTPUT_DIR	= . ;
1135
1136include [ FDirName \$(HAIKU_TOP) Jamfile ] ;
1137
1138EOF
1139
1140echo "Configured successfully!"
1141