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