xref: /haiku/configure (revision 5ac9b506412b11afb993bb52d161efe7666958a5) 
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", "riscv32", "riscv64"
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		riscv32-*)	targetCpu=riscv32;;
275		riscv64-*)	targetCpu=riscv64;;
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	riscv32
634	riscv64
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				riscv32)	targetMachine=riscv32-unknown-haiku;;
684				riscv64)	targetMachine=riscv64-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				riscv32)	targetMachine=riscv32-unknown-haiku;;
744				riscv64)	targetMachine=riscv64-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# check if nasm can actually output ELF files
822# (the stock version in OSX can't)
823# XXX: should probably only test for x86* arch
824if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then
825	echo "$HAIKU_NASM cannot generate ELF files. Please install a working version."
826	if [ $HOST_PLATFORM = "darwin" ]; then
827		echo "You can install it from Mac Ports."
828		echo "Mac Ports is available at: http://www.macports.org/"
829	fi
830	exit 1
831fi
832
833# create output directory
834mkdir -p "$buildOutputDir" || exit 1
835
836if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then
837	invalidCommand=$sourceDir/build/scripts/host_build_only
838	HAIKU_AR=$invalidCommand
839	HAIKU_CC=$invalidCommand
840	HAIKU_LD=$invalidCommand
841	HAIKU_OBJCOPY=$invalidCommand
842	HAIKU_RANLIB=$invalidCommand
843	HAIKU_ELFEDIT=$invalidCommand
844	HAIKU_NASM=$invalidCommand
845	HAIKU_STRIP=$invalidCommand
846else
847	# On Haiku determine target architectures and tools automatically.
848	if [ -z "$targetArchs" ]; then
849		if [ $HOST_PLATFORM != haiku_host ]; then
850			echo "Please specify the build tools to use or build (via" \
851				"--cross-tools-prefix or --build-cross-tools) or specify a" \
852				"host-only build (--host-only)." >&2
853			echo "For more info, invoke $0 --help"
854			exit 1
855		fi
856
857		# determine primary architecture
858		targetArch=`package list -i /system/packages/haiku-*.hpkg \
859			| sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'`
860		is_in_list "$targetArch" "$supportedTargetArchs" || (
861			echo "Unsupported target architecture: \"$targetArch\"" >&2
862			exit 1
863		)
864		targetArchs=$targetArch
865
866		set_default_value HAIKU_AR_$targetArch			ar
867		set_default_value HAIKU_CC_$targetArch			gcc
868		set_default_value HAIKU_LD_$targetArch			ld
869		set_default_value HAIKU_OBJCOPY_$targetArch		objcopy
870		set_default_value HAIKU_RANLIB_$targetArch		ranlib
871		set_default_value HAIKU_ELFEDIT_$targetArch		elfedit
872		set_default_value HAIKU_STRIP_$targetArch		strip
873
874		# determine secondary architectures
875		for targetArch in $supportedTargetArchs; do
876			if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then
877				targetArchs="$targetArchs $targetArch"
878				set_default_value HAIKU_AR_$targetArch		ar-$targetArch
879				set_default_value HAIKU_CC_$targetArch		gcc-$targetArch
880				set_default_value HAIKU_LD_$targetArch		ld-$targetArch
881				set_default_value HAIKU_OBJCOPY_$targetArch	objcopy-$targetArch
882				set_default_value HAIKU_RANLIB_$targetArch	ranlib-$targetArch
883				set_default_value HAIKU_ELFEDIT_$targetArch	elfedit-$targetArch
884				set_default_value HAIKU_STRIP_$targetArch	strip-$targetArch
885			fi
886		done
887
888		# The target architectures might have been specified explicitly.
889		if [ -n "$haikuTargetArchs" ]; then
890			for targetArch in $haikuTargetArchs; do
891				is_in_list "$targetArch" "$targetArchs" || (
892					echo "Unsupported target architecture: \"$targetArch\"." \
893						"Only native architectures of the host platform can" \
894						"be specified." >&2
895					exit 1
896				)
897			done
898			targetArchs="$haikuTargetArchs"
899		fi
900	fi
901
902	isPrimaryArch=1
903	for targetArch in $targetArchs; do
904		# Note: targetArch is "unknown<n>" at this point if a cross-tools
905		# prefix was specified. The standard_gcc_settings call below will get
906		# the actual architecture.
907
908		if test "${HAIKU_PACKAGING_ARCHS#*$targetArch\b}" != "$HAIKU_PACKAGING_ARCHS"; then
909			# somehow we wound up with a duplicate arch; skip this one
910			continue
911		fi
912
913		crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch`
914
915		# build cross tools from sources
916		if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then
917			crossToolsDir="$outputDir/cross-tools-$targetArch"
918			targetMachine=`get_variable buildCrossToolsMachine_$targetArch`
919			script="$buildCrossToolsScript"
920			scriptArgs=
921			if [ $targetArch != x86_gcc2 ]; then
922				script="${script}_gcc4"
923				scriptArgs="$targetMachine"
924				set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch	\
925					$useGccGraphiteDefault
926			fi
927			secondaryArch=
928			if [ -z "$isPrimaryArch" ]; then
929				secondaryArch=$targetArch
930			fi
931
932			case $HOST_PLATFORM in
933				freebsd|openbsd)	MAKE=gmake;;
934				*)					MAKE=make;;
935			esac
936
937			if ! valid_toolchain "${targetMachine}" "${crossToolsDir}" "${buildCrossTools}"; then
938				MAKE=$MAKE \
939				SECONDARY_ARCH=$secondaryArch \
940				HAIKU_USE_GCC_GRAPHITE=`get_variable \
941					HAIKU_USE_GCC_GRAPHITE_$targetArch` \
942				HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \
943				HAIKU_USE_GDB="$gdbSources" \
944				"$script" $scriptArgs "$sourceDir" "$buildCrossTools" \
945					"$crossToolsDir" $buildCrossToolsJobs || exit 1
946			else
947				echo "$targetArch crosstools already exist in $crossToolsDir; skipping build"
948			fi
949			crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-"
950		fi
951
952		# prepare gcc settings and get the actual target architecture
953		if [ $useClang = 1 ]; then
954			gcc="$HAIKU_clang -target ${targetMachine}"
955			if [ ! -z "${crossToolsPrefix}" ]; then
956				gcc="$gcc -B ${crossToolsPrefix}"
957			fi
958
959			# Clang's compiler intrinsics are not compatible with GCC's or even
960			# across versions of Clang, so we must collect them for use in the build.
961			mkdir -p "$outputDir/clang_headers" || exit 1
962			clangHeadersDir=`$gcc -print-resource-dir`/include/
963			case $targetArch in
964				x86*) cp $clangHeadersDir/*intrin* $clangHeadersDir/mm3* "$outputDir/clang_headers" || exit 1 ;;
965				ppc*) cp $clangHeadersDir/*altivec* "$outputDir/clang_headers" || exit 1 ;;
966				arm*) cp $clangHeadersDir/*arm* "$outputDir/clang_headers" || exit 1 ;;
967			esac
968		elif [ -z "${crossToolsPrefix}" ]; then
969			gcc=`get_variable HAIKU_CC_$targetArch`
970		else
971			gcc="${crossToolsPrefix}gcc"
972		fi
973		standard_gcc_settings "$gcc"
974		targetArch=$standard_gcc_settings_targetArch
975
976		# set default values for flags
977		set_default_value HAIKU_CPPFLAGS_$targetArch	""
978		set_default_value HAIKU_CCFLAGS_$targetArch		""
979		set_default_value HAIKU_CXXFLAGS_$targetArch	""
980		set_default_value HAIKU_LINKFLAGS_$targetArch	""
981		set_default_value HAIKU_LDFLAGS_$targetArch		""
982		set_default_value HAIKU_ARFLAGS_$targetArch		cru
983		set_default_value HAIKU_UNARFLAGS_$targetArch	x
984
985		# Override the cross tools variables, if the tools were built or a
986		# prefix was specified.
987		if [ $useClang = 1 ]; then
988			get_build_tool_path LD_$targetArch ld.lld
989			get_build_tool_path ELFEDIT_$targetArch elfedit
990		elif [ -n "$crossToolsPrefix" ]; then
991			get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld
992			case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in
993				4.*|5.*|6.*|7.*|8.*)
994					get_build_tool_path ELFEDIT_$targetArch \
995						${crossToolsPrefix}elfedit
996				;;
997			esac
998		fi
999		if [ -n "$crossToolsPrefix" ]; then
1000			get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar
1001			get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy
1002			get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib
1003			get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip
1004		fi
1005
1006		# check whether the Haiku compiler really targets Haiku
1007		targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch`
1008		case "$targetMachine" in
1009			*-*-haiku)	;;
1010			*)
1011				echo The compiler specified as Haiku target compiler is not a \
1012				valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2
1013				echo compiler: $HAIKU_CC
1014				echo compiler is configured for target: $targetMachine
1015				exit 1 ;;
1016		esac
1017
1018		HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch"
1019		isPrimaryArch=
1020	done
1021fi
1022
1023# Generate BuildConfig
1024cat << EOF > "$buildConfigFile"
1025# -- WARNING --
1026# This file was AUTOMATICALLY GENERATED by configure, and will be completely
1027# overwritten the next time configure is run.
1028#
1029#d ${currentDir}
1030#c ${configurePath}
1031#e ${configureEnvirons}
1032#a ${configureArgs}
1033
1034HOST_PLATFORM				?= "${HOST_PLATFORM}" ;
1035TARGET_PLATFORM 			?= "${TARGET_PLATFORM}" ;
1036HAIKU_PACKAGING_ARCHS		?= ${HAIKU_PACKAGING_ARCHS} ;
1037
1038HAIKU_NO_DOWNLOADS			?= "${HAIKU_NO_DOWNLOADS}" ;
1039HAIKU_INCLUDE_SOURCES		?= "${HAIKU_INCLUDE_SOURCES}" ;
1040HAIKU_INCLUDE_3RDPARTY		?= "${HAIKU_INCLUDE_3RDPARTY}" ;
1041HAIKU_DISTRO_COMPATIBILITY	?= "${HAIKU_DISTRO_COMPATIBILITY}" ;
1042
1043HAIKU_USE_GCC_PIPE			?= "${HAIKU_USE_GCC_PIPE}" ;
1044HAIKU_HOST_USE_32BIT		?= "${HAIKU_HOST_USE_32BIT}" ;
1045HAIKU_HOST_USE_XATTR		?= "${HAIKU_HOST_USE_XATTR}" ;
1046HAIKU_HOST_USE_XATTR_REF	?= "${HAIKU_HOST_USE_XATTR_REF}" ;
1047HAIKU_HOST_BUILD_ONLY		?= "${HAIKU_HOST_BUILD_ONLY}" ;
1048
1049HOST_CC						?= ${CC} ;
1050HOST_GCC_RAW_VERSION		?= ${HOST_GCC_RAW_VERSION} ;
1051HOST_GCC_MACHINE			?= ${HOST_GCC_MACHINE} ;
1052HOST_LD						?= ${HOST_GCC_LD} ;
1053HOST_OBJCOPY				?= ${HOST_GCC_OBJCOPY} ;
1054HOST_EXTENDED_REGEX_SED		?= ${HOST_EXTENDED_REGEX_SED} ;
1055HOST_SHA256					?= ${HOST_SHA256} ;
1056HAIKU_NASM					?= ${HAIKU_NASM} ;
1057
1058HAIKU_BUILD_ATTRIBUTES_DIR	?= "${HAIKU_BUILD_ATTRIBUTES_DIR}" ;
1059
1060HOST_HAIKU_PORTER			?= ${HOST_HAIKU_PORTER} ;
1061HAIKU_PORTS					?= ${HAIKU_PORTS} ;
1062HAIKU_PORTS_CROSS			?= ${HAIKU_PORTS_CROSS} ;
1063HAIKU_IS_BOOTSTRAP			?= ${HAIKU_IS_BOOTSTRAP} ;
1064
1065EOF
1066
1067for targetArch in $HAIKU_PACKAGING_ARCHS; do
1068	variables="
1069		HAIKU_CC					HAIKU_CC
1070		HAIKU_CC_IS_CLANG			HAIKU_CC_IS_CLANG
1071		HAIKU_USE_GCC_GRAPHITE		HAIKU_USE_GCC_GRAPHITE
1072		HAIKU_CPU					HAIKU_CPU
1073		HAIKU_GCC_MACHINE			HAIKU_GCC_MACHINE
1074		HAIKU_GCC_RAW_VERSION		HAIKU_GCC_RAW_VERSION
1075		HAIKU_GCC_LIB_DIR			HAIKU_GCC_LIB_DIR
1076		HAIKU_BOOT_LIBGCC			HAIKU_BOOT_LIBGCC
1077		HAIKU_BOOT_LIBSUPC++		HAIKU_BOOT_LIBSUPCXX
1078		HAIKU_AR					HAIKU_AR
1079		HAIKU_LD					HAIKU_LD
1080		HAIKU_OBJCOPY				HAIKU_OBJCOPY
1081		HAIKU_RANLIB				HAIKU_RANLIB
1082		HAIKU_ELFEDIT				HAIKU_ELFEDIT
1083		HAIKU_STRIP					HAIKU_STRIP
1084		HAIKU_CPPFLAGS				HAIKU_CPPFLAGS
1085		HAIKU_CCFLAGS				HAIKU_CCFLAGS
1086		HAIKU_C++FLAGS				HAIKU_CXXFLAGS
1087		HAIKU_LINKFLAGS				HAIKU_LINKFLAGS
1088		HAIKU_LDFLAGS				HAIKU_LDFLAGS
1089		HAIKU_ARFLAGS				HAIKU_ARFLAGS
1090		HAIKU_UNARFLAGS				HAIKU_UNARFLAGS
1091		"
1092	set -- $variables
1093	while [ $# -ge 2 ]; do
1094		value=`get_variable ${2}_$targetArch`
1095		echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile"
1096		shift 2
1097	done
1098
1099	# For variables that may have long values, distribute them over multiple
1100	# lines so that jam doesn't hit the maximum line length.
1101	variables="
1102		HAIKU_BOOT_C++_HEADERS_DIR	HAIKU_BOOT_CXX_HEADERS_DIR
1103		"
1104	set -- $variables
1105	while [ $# -ge 2 ]; do
1106		echo "${1}_${targetArch} ?= " >> "$buildConfigFile"
1107		get_variable ${2}_$targetArch | xargs -n 1 echo "   " \
1108			>> "$buildConfigFile"
1109		echo "    ;" >> "$buildConfigFile"
1110		shift 2
1111	done
1112done
1113
1114
1115# Generate a Jamfile in the output directory.
1116
1117cat << EOF > $outputDir/Jamfile
1118# -- WARNING --
1119# This file was AUTOMATICALLY GENERATED by configure, and will be completely
1120# overwritten the next time configure is run.
1121
1122HAIKU_TOP			= $(relative_to "${sourceDir}" "${outputDir}") ;
1123HAIKU_OUTPUT_DIR	= . ;
1124
1125include [ FDirName \$(HAIKU_TOP) Jamfile ] ;
1126
1127EOF
1128
1129echo "Configured successfully!"
1130