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 aarch64-*) 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 559# internal default parameter values 560# 561platform=`uname` 562platformMachine=`uname -m` 563targetArchs= 564buildCrossTools= 565buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools" 566buildCrossToolsJobs= 567useClang=0 568useGccGraphiteDefault=0 569unknownArchIndex=1 570haikuTargetArchs= 571gdbSources= 572 573if [ -z "$CC" ]; then 574 CC=gcc 575fi 576 577# detect the build platform 578case "${platform}" in 579 Darwin) HOST_PLATFORM=darwin ;; 580 FreeBSD) HOST_PLATFORM=freebsd 581 if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then 582 echo Unsupported platform: FreeBSD ${platformMachine} 583 exit 1 584 fi ;; 585 Haiku) HOST_PLATFORM=haiku_host ;; 586 Linux) HOST_PLATFORM=linux ;; 587 OpenBSD) HOST_PLATFORM=openbsd ;; 588 MINGW*) HOST_PLATFORM=mingw ;; 589 *) echo Unsupported platform: ${platform} 590 exit 1 ;; 591esac 592 593case $HOST_PLATFORM in 594 darwin|freebsd|openbsd) statCmd='stat -f' ;; 595 *) statCmd='stat -c' ;; 596esac 597 598# ensure git checkout was not done with a restrictive umask 599if [ `$statCmd '%a' "$sourceDir/data/system/boot/SetupEnvironment"` -lt 644 ]; then 600 echo "The source tree was cloned with a umask > 0022. It seems you" 601 echo have already corrected your umask, but not re-checked-out the 602 echo source tree. Try running: 603 echo " git checkout --force" 604 echo to fix this problem. 605 exit 1 606fi 607 608# exported (BuildSetup) default parameter values 609# 610HOST_GCC_RAW_VERSION=`$CC -dumpversion` 611HOST_GCC_MACHINE=`$CC -dumpmachine` 612HAIKU_INCLUDE_SOURCES=0 613HAIKU_INCLUDE_3RDPARTY=0 614HAIKU_DISTRO_COMPATIBILITY=default 615TARGET_PLATFORM=haiku 616HAIKU_USE_GCC_PIPE=0 617HAIKU_HOST_USE_32BIT=0 618HAIKU_HOST_USE_XATTR= 619HAIKU_HOST_USE_XATTR_REF= 620HAIKU_HOST_BUILD_ONLY=0 621HOST_EXTENDED_REGEX_SED="sed -r" 622HOST_GCC_LD=`$CC -print-prog-name=ld` 623HOST_GCC_OBJCOPY=`$CC -print-prog-name=objcopy` 624HOST_SHA256= 625HOST_HAIKU_PORTER= 626HAIKU_PORTS= 627HAIKU_PORTS_CROSS= 628HAIKU_IS_BOOTSTRAP=0 629HAIKU_NO_DOWNLOADS=0 630 631HAIKU_PACKAGING_ARCHS= 632 633set_default_value HAIKU_NASM nasm 634 635if sha256sum < /dev/null > /dev/null 2>&1; then 636 HOST_SHA256=sha256sum 637elif sha256 < /dev/null > /dev/null 2>&1; then 638 HOST_SHA256="sha256 -q" 639elif shasum < /dev/null > /dev/null 2>&1; then 640 HOST_SHA256="shasum -a 256" 641else 642 echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2 643 exit 1 644fi 645 646haikuRequiredLegacyGCCVersion="2.95.3-haiku-2017_07_20" 647export haikuRequiredLegacyGCCVersion 648 # version of legacy gcc required to build haiku 649supportedTargetArchs=" 650 arm 651 arm64 652 m68k 653 ppc 654 riscv64 655 sparc 656 x86 657 x86_64 658 x86_gcc2 659 " 660 661# parse parameters 662# 663while [ $# -gt 0 ] ; do 664 case "$1" in 665 --bootstrap) 666 assertparams "$1" 3 $# 667 HOST_HAIKU_PORTER="`absolute_path $2`" 668 HAIKU_PORTS_CROSS="`absolute_path $3`" 669 HAIKU_PORTS="`absolute_path $4`" 670 HAIKU_IS_BOOTSTRAP=1 671 HAIKU_NO_DOWNLOADS=1 672 check_file_exists "$HOST_HAIKU_PORTER" || ( 673 echo "Invalid path to haikuporter: $HOST_HAIKU_PORTER" >&2 674 exit 1 675 ) 676 check_dir_exists "$HAIKU_PORTS" || ( 677 echo "Non-existent directory $HAIKU_PORTS" >&2 678 exit 1 679 ) 680 check_dir_exists "$HAIKU_PORTS_CROSS" || ( 681 echo "Non-existent directory $HAIKU_PORTS_CROSS" >&2 682 exit 1 683 ) 684 shift 4 685 ;; 686 --build-cross-tools) 687 if [ -z "$buildCrossTools" ]; then 688 assertparams "$1" 2 $# 689 targetArch=$2 690 buildCrossTools=$3 691 shift 3 692 else 693 assertparam "$1" $# 694 targetArch=$2 695 shift 2 696 fi 697 case "$targetArch" in 698 x86_gcc2) targetMachine=i586-pc-haiku;; 699 x86) targetMachine=i586-pc-haiku;; 700 x86_64) targetMachine=x86_64-unknown-haiku;; 701 ppc) targetMachine=powerpc-apple-haiku;; 702 m68k) targetMachine=m68k-unknown-haiku;; 703 arm) targetMachine=arm-unknown-haiku;; 704 arm64) targetMachine=aarch64-unknown-haiku;; 705 riscv64) targetMachine=riscv64-unknown-haiku;; 706 sparc) targetMachine=sparc64-unknown-haiku;; 707 *) 708 echo "Unsupported target architecture: $targetArch" >&2 709 exit 1 710 ;; 711 esac 712 set_variable buildCrossToolsMachine_$targetArch $targetMachine 713 targetArchs="$targetArchs $targetArch" 714 ;; 715 --cross-tools-prefix) 716 assertparam "$1" $# 717 targetArch=unknown${unknownArchIndex} 718 set_variable crossToolsPrefix_$targetArch "$2" 719 targetArchs="$targetArchs $targetArch" 720 unknownArchIndex=$(($unknownArchIndex + 1)) 721 shift 2 722 ;; 723 --distro-compatibility) 724 assertparam "$1" $# 725 HAIKU_DISTRO_COMPATIBILITY=$2 726 case "$HAIKU_DISTRO_COMPATIBILITY" in 727 official) ;; 728 compatible) ;; 729 default) ;; 730 *) echo "Invalid distro compatibility" \ 731 "level: $HAIKU_DISTRO_COMPATIBILITY" 732 exit 1;; 733 esac 734 shift 2 735 ;; 736 --host-only) HAIKU_HOST_BUILD_ONLY=1; shift 1;; 737 --include-sources) HAIKU_INCLUDE_SOURCES=1; shift 1;; 738 --include-3rdparty) HAIKU_INCLUDE_3RDPARTY=1; shift 1;; 739 -j*) buildCrossToolsJobs="$1"; shift 1;; 740 --no-downloads) HAIKU_NO_DOWNLOADS=1; shift 1;; 741 --target-arch) 742 assertparam "$1" $# 743 targetArch=$2 744 shift 2 745 if [ ! "$platform" = Haiku ]; then 746 echo "--target-arch can only be specified on Haiku." >&2 747 exit 1 748 fi 749 is_in_list "$targetArch" "$supportedTargetArchs" || ( 750 echo "Unsupported target architecture: \"$targetArch\"" >&2 751 exit 1 752 ) 753 haikuTargetArchs="$haikuTargetArchs $targetArch" 754 ;; 755 --use-clang) 756 assertparam "$1" $# 757 targetArch=$2 758 useClang=1 759 case "$targetArch" in 760 x86) targetMachine=i586-pc-haiku;; 761 x86_64) targetMachine=x86_64-unknown-haiku;; 762 ppc) targetMachine=powerpc-apple-haiku;; 763 arm) targetMachine=arm-unknown-haiku;; 764 arm64) targetMachine=aarch64-unknown-haiku;; 765 riscv64) targetMachine=riscv64-unknown-haiku;; 766 sparc) targetMachine=sparc64-unknown-haiku;; 767 *) 768 echo "Unsupported target architecture: $2" >&2 769 exit 1 770 ;; 771 esac 772 get_build_tool_path clang clang 773 if [ -z `get_variable "crossToolsPrefix_$targetArch"` ] \ 774 && [ -z `get_variable buildCrossToolsMachine_$targetArch` ]; then 775 set_variable crossToolsPrefix_$targetArch llvm- 776 fi 777 clangVersion=`$HAIKU_clang -v 2>&1 | head -1 | cut -d " " -f3` 778 if [ `echo $clangVersion | head -c 1` -lt 7 ]; then 779 echo "Haiku requires Clang 7 or better to build, but you have $clangVersion." 780 echo "Please install a newer version." 781 exit 1 782 fi 783 targetArchs="$targetArchs $targetArch" 784 shift 2 785 ;; 786 --use-gcc-pipe) HAIKU_USE_GCC_PIPE=1; shift 1;; 787 --use-gcc-graphite) useGccGraphiteDefault=1; shift 1;; 788 --use-32bit) HAIKU_HOST_USE_32BIT=1; shift 1;; 789 --no-full-xattr)HAIKU_HOST_USE_XATTR=0; shift 1;; 790 --no-xattr) HAIKU_HOST_USE_XATTR_REF=0; shift 1;; 791 --with-gdb) gdbSources=$2; shift 2;; 792 *) echo Invalid argument: \`$1\'; exit 1;; 793 esac 794done 795 796# check for case-sensitive filesystem 797mkdir haikuCaseTest 2>/dev/null 798mkdir haikucasetest 2>/dev/null 799caseInsensitive=$? 800rmdir haikuCaseTest haikucasetest 2>/dev/null 801if [ $caseInsensitive != 0 ]; then 802 echo "You need a case-sensitive file-system to build Haiku." 803 if [ $HOST_PLATFORM = "darwin" ]; then 804 echo "You can create a case-sensitive disk image using Disk Utility." 805 fi 806 exit 1 807fi 808 809# check xattr support 810if [ -z $HAIKU_HOST_USE_XATTR_REF ]; then 811 check_native_xattrs 812 attrSupport=$? 813 if [ $attrSupport = 2 ] && [ -z $HAIKU_HOST_USE_XATTR ]; then 814 HAIKU_HOST_USE_XATTR=1 815 elif [ $attrSupport = 1 ]; then 816 HAIKU_HOST_USE_XATTR_REF=1 817 fi 818fi 819if [ -z $HAIKU_HOST_USE_XATTR ]; then HAIKU_HOST_USE_XATTR=0; fi 820if [ -z $HAIKU_HOST_USE_XATTR_REF ]; then HAIKU_HOST_USE_XATTR_REF=0; fi 821 822# determine how to invoke sed with extended regexp support for non-GNU sed 823if [ $HOST_PLATFORM = "darwin" ]; then 824 HOST_EXTENDED_REGEX_SED="sed -E" 825fi 826 827# locate python 828if python3 --version < /dev/null > /dev/null 2>&1; then 829 HOST_PYTHON="python3" 830elif python --version < /dev/null > /dev/null 2>&1; then 831 HOST_PYTHON="python" 832else 833 echo "a python interpreter is required" 834 exit 1 835fi 836 837# check if nasm can actually output ELF files 838# (the stock version in OSX can't) 839# XXX: should probably only test for x86* arch 840if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then 841 echo "$HAIKU_NASM cannot generate ELF files. Please install a working version." 842 if [ $HOST_PLATFORM = "darwin" ]; then 843 echo "You can install it from Mac Ports." 844 echo "Mac Ports is available at: http://www.macports.org/" 845 fi 846 exit 1 847fi 848 849# create output directory 850mkdir -p "$buildOutputDir" || exit 1 851 852if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then 853 invalidCommand=$sourceDir/build/scripts/host_build_only 854 HAIKU_AR=$invalidCommand 855 HAIKU_CC=$invalidCommand 856 HAIKU_LD=$invalidCommand 857 HAIKU_OBJCOPY=$invalidCommand 858 HAIKU_RANLIB=$invalidCommand 859 HAIKU_ELFEDIT=$invalidCommand 860 HAIKU_NASM=$invalidCommand 861 HAIKU_STRIP=$invalidCommand 862else 863 # On Haiku determine target architectures and tools automatically. 864 if [ -z "$targetArchs" ]; then 865 if [ $HOST_PLATFORM != haiku_host ]; then 866 echo "Please specify the build tools to use or build (via" \ 867 "--cross-tools-prefix or --build-cross-tools) or specify a" \ 868 "host-only build (--host-only)." >&2 869 echo "For more info, invoke $0 --help" 870 exit 1 871 fi 872 873 # determine primary architecture 874 targetArch=`package list -i /system/packages/haiku-*.hpkg \ 875 | sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'` 876 is_in_list "$targetArch" "$supportedTargetArchs" || ( 877 echo "Unsupported target architecture: \"$targetArch\"" >&2 878 exit 1 879 ) 880 targetArchs=$targetArch 881 882 set_default_value HAIKU_AR_$targetArch ar 883 set_default_value HAIKU_CC_$targetArch gcc 884 set_default_value HAIKU_LD_$targetArch ld 885 set_default_value HAIKU_OBJCOPY_$targetArch objcopy 886 set_default_value HAIKU_RANLIB_$targetArch ranlib 887 set_default_value HAIKU_ELFEDIT_$targetArch elfedit 888 set_default_value HAIKU_STRIP_$targetArch strip 889 890 # determine secondary architectures 891 for targetArch in $supportedTargetArchs; do 892 if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then 893 targetArchs="$targetArchs $targetArch" 894 set_default_value HAIKU_AR_$targetArch ar-$targetArch 895 set_default_value HAIKU_CC_$targetArch gcc-$targetArch 896 set_default_value HAIKU_LD_$targetArch ld-$targetArch 897 set_default_value HAIKU_OBJCOPY_$targetArch objcopy-$targetArch 898 set_default_value HAIKU_RANLIB_$targetArch ranlib-$targetArch 899 set_default_value HAIKU_ELFEDIT_$targetArch elfedit-$targetArch 900 set_default_value HAIKU_STRIP_$targetArch strip-$targetArch 901 fi 902 done 903 904 # The target architectures might have been specified explicitly. 905 if [ -n "$haikuTargetArchs" ]; then 906 for targetArch in $haikuTargetArchs; do 907 is_in_list "$targetArch" "$targetArchs" || ( 908 echo "Unsupported target architecture: \"$targetArch\"." \ 909 "Only native architectures of the host platform can" \ 910 "be specified." >&2 911 exit 1 912 ) 913 done 914 targetArchs="$haikuTargetArchs" 915 fi 916 fi 917 918 isPrimaryArch=1 919 for targetArch in $targetArchs; do 920 # Note: targetArch is "unknown<n>" at this point if a cross-tools 921 # prefix was specified. The standard_gcc_settings call below will get 922 # the actual architecture. 923 924 if test "${HAIKU_PACKAGING_ARCHS#*$targetArch\b}" != "$HAIKU_PACKAGING_ARCHS"; then 925 # somehow we wound up with a duplicate arch; skip this one 926 continue 927 fi 928 929 crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch` 930 931 # build cross tools from sources 932 if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then 933 crossToolsDir="$outputDir/cross-tools-$targetArch" 934 targetMachine=`get_variable buildCrossToolsMachine_$targetArch` 935 script="$buildCrossToolsScript" 936 scriptArgs= 937 if [ $targetArch != x86_gcc2 ]; then 938 script="${script}_gcc4" 939 scriptArgs="$targetMachine" 940 set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch \ 941 $useGccGraphiteDefault 942 fi 943 secondaryArch= 944 if [ -z "$isPrimaryArch" ]; then 945 secondaryArch=$targetArch 946 fi 947 948 case $HOST_PLATFORM in 949 freebsd|openbsd) MAKE=gmake;; 950 *) MAKE=make;; 951 esac 952 953 if ! valid_toolchain "${targetMachine}" "${crossToolsDir}" "${buildCrossTools}"; then 954 MAKE=$MAKE \ 955 SECONDARY_ARCH=$secondaryArch \ 956 HAIKU_USE_GCC_GRAPHITE=`get_variable \ 957 HAIKU_USE_GCC_GRAPHITE_$targetArch` \ 958 HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \ 959 HAIKU_USE_GDB="$gdbSources" \ 960 "$script" $scriptArgs "$sourceDir" "$buildCrossTools" \ 961 "$crossToolsDir" $buildCrossToolsJobs || exit 1 962 else 963 echo "$targetArch crosstools already exist in $crossToolsDir; skipping build" 964 fi 965 crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-" 966 fi 967 968 # prepare gcc settings and get the actual target architecture 969 if [ $useClang = 1 ]; then 970 gcc="$HAIKU_clang -target ${targetMachine}" 971 if [ ! -z "${crossToolsPrefix}" ]; then 972 gcc="$gcc -B ${crossToolsPrefix}" 973 fi 974 975 # Clang's compiler intrinsics are not compatible with GCC's or even 976 # across versions of Clang, so we must collect them for use in the build. 977 mkdir -p "$outputDir/clang_headers" || exit 1 978 clangHeadersDir=`$gcc -print-resource-dir`/include/ 979 case $targetArch in 980 x86*) cp $clangHeadersDir/*intrin* $clangHeadersDir/mm3* "$outputDir/clang_headers" || exit 1 ;; 981 ppc*) cp $clangHeadersDir/*altivec* "$outputDir/clang_headers" || exit 1 ;; 982 arm*) cp $clangHeadersDir/*arm* "$outputDir/clang_headers" || exit 1 ;; 983 esac 984 elif [ -z "${crossToolsPrefix}" ]; then 985 gcc=`get_variable HAIKU_CC_$targetArch` 986 else 987 gcc="${crossToolsPrefix}gcc" 988 fi 989 standard_gcc_settings "$gcc" 990 targetArch=$standard_gcc_settings_targetArch 991 992 # set default values for flags 993 set_default_value HAIKU_CPPFLAGS_$targetArch "" 994 set_default_value HAIKU_CCFLAGS_$targetArch "" 995 set_default_value HAIKU_CXXFLAGS_$targetArch "" 996 set_default_value HAIKU_LINKFLAGS_$targetArch "" 997 set_default_value HAIKU_LDFLAGS_$targetArch "" 998 set_default_value HAIKU_ARFLAGS_$targetArch cru 999 set_default_value HAIKU_UNARFLAGS_$targetArch x 1000 1001 # Override the cross tools variables, if the tools were built or a 1002 # prefix was specified. 1003 if [ $useClang = 1 ]; then 1004 get_build_tool_path LD_$targetArch ld.lld 1005 get_build_tool_path ELFEDIT_$targetArch elfedit 1006 elif [ -n "$crossToolsPrefix" ]; then 1007 get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld 1008 case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in 1009 4.*|5.*|6.*|7.*|8.*) 1010 get_build_tool_path ELFEDIT_$targetArch \ 1011 ${crossToolsPrefix}elfedit 1012 ;; 1013 esac 1014 fi 1015 if [ -n "$crossToolsPrefix" ]; then 1016 get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar 1017 get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy 1018 get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib 1019 get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip 1020 fi 1021 1022 # check whether the Haiku compiler really targets Haiku 1023 targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch` 1024 case "$targetMachine" in 1025 *-*-haiku) ;; 1026 *) 1027 echo The compiler specified as Haiku target compiler is not a \ 1028 valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2 1029 echo compiler: $HAIKU_CC 1030 echo compiler is configured for target: $targetMachine 1031 exit 1 ;; 1032 esac 1033 1034 HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch" 1035 isPrimaryArch= 1036 done 1037fi 1038 1039# Generate BuildConfig 1040cat << EOF > "$buildConfigFile" 1041# -- WARNING -- 1042# This file was AUTOMATICALLY GENERATED by configure, and will be completely 1043# overwritten the next time configure is run. 1044# 1045#d ${currentDir} 1046#c ${configurePath} 1047#e ${configureEnvirons} 1048#a ${configureArgs} 1049 1050HOST_PLATFORM ?= "${HOST_PLATFORM}" ; 1051TARGET_PLATFORM ?= "${TARGET_PLATFORM}" ; 1052HAIKU_PACKAGING_ARCHS ?= ${HAIKU_PACKAGING_ARCHS} ; 1053 1054HAIKU_NO_DOWNLOADS ?= "${HAIKU_NO_DOWNLOADS}" ; 1055HAIKU_INCLUDE_SOURCES ?= "${HAIKU_INCLUDE_SOURCES}" ; 1056HAIKU_INCLUDE_3RDPARTY ?= "${HAIKU_INCLUDE_3RDPARTY}" ; 1057HAIKU_DISTRO_COMPATIBILITY ?= "${HAIKU_DISTRO_COMPATIBILITY}" ; 1058 1059HAIKU_USE_GCC_PIPE ?= "${HAIKU_USE_GCC_PIPE}" ; 1060HAIKU_HOST_USE_32BIT ?= "${HAIKU_HOST_USE_32BIT}" ; 1061HAIKU_HOST_USE_XATTR ?= "${HAIKU_HOST_USE_XATTR}" ; 1062HAIKU_HOST_USE_XATTR_REF ?= "${HAIKU_HOST_USE_XATTR_REF}" ; 1063HAIKU_HOST_BUILD_ONLY ?= "${HAIKU_HOST_BUILD_ONLY}" ; 1064 1065HOST_CC ?= ${CC} ; 1066HOST_GCC_RAW_VERSION ?= ${HOST_GCC_RAW_VERSION} ; 1067HOST_GCC_MACHINE ?= ${HOST_GCC_MACHINE} ; 1068HOST_LD ?= ${HOST_GCC_LD} ; 1069HOST_OBJCOPY ?= ${HOST_GCC_OBJCOPY} ; 1070HOST_EXTENDED_REGEX_SED ?= ${HOST_EXTENDED_REGEX_SED} ; 1071HOST_SHA256 ?= ${HOST_SHA256} ; 1072HOST_PYTHON ?= ${HOST_PYTHON} ; 1073HAIKU_NASM ?= ${HAIKU_NASM} ; 1074 1075HAIKU_BUILD_ATTRIBUTES_DIR ?= "${HAIKU_BUILD_ATTRIBUTES_DIR}" ; 1076 1077HOST_HAIKU_PORTER ?= ${HOST_HAIKU_PORTER} ; 1078HAIKU_PORTS ?= ${HAIKU_PORTS} ; 1079HAIKU_PORTS_CROSS ?= ${HAIKU_PORTS_CROSS} ; 1080HAIKU_IS_BOOTSTRAP ?= ${HAIKU_IS_BOOTSTRAP} ; 1081 1082EOF 1083 1084for targetArch in $HAIKU_PACKAGING_ARCHS; do 1085 variables=" 1086 HAIKU_CC HAIKU_CC 1087 HAIKU_CC_IS_CLANG HAIKU_CC_IS_CLANG 1088 HAIKU_USE_GCC_GRAPHITE HAIKU_USE_GCC_GRAPHITE 1089 HAIKU_CPU HAIKU_CPU 1090 HAIKU_GCC_MACHINE HAIKU_GCC_MACHINE 1091 HAIKU_GCC_RAW_VERSION HAIKU_GCC_RAW_VERSION 1092 HAIKU_GCC_LIB_DIR HAIKU_GCC_LIB_DIR 1093 HAIKU_BOOT_LIBGCC HAIKU_BOOT_LIBGCC 1094 HAIKU_BOOT_LIBSUPC++ HAIKU_BOOT_LIBSUPCXX 1095 HAIKU_AR HAIKU_AR 1096 HAIKU_LD HAIKU_LD 1097 HAIKU_OBJCOPY HAIKU_OBJCOPY 1098 HAIKU_RANLIB HAIKU_RANLIB 1099 HAIKU_ELFEDIT HAIKU_ELFEDIT 1100 HAIKU_STRIP HAIKU_STRIP 1101 HAIKU_CPPFLAGS HAIKU_CPPFLAGS 1102 HAIKU_CCFLAGS HAIKU_CCFLAGS 1103 HAIKU_C++FLAGS HAIKU_CXXFLAGS 1104 HAIKU_LINKFLAGS HAIKU_LINKFLAGS 1105 HAIKU_LDFLAGS HAIKU_LDFLAGS 1106 HAIKU_ARFLAGS HAIKU_ARFLAGS 1107 HAIKU_UNARFLAGS HAIKU_UNARFLAGS 1108 " 1109 set -- $variables 1110 while [ $# -ge 2 ]; do 1111 value=`get_variable ${2}_$targetArch` 1112 echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile" 1113 shift 2 1114 done 1115 1116 # For variables that may have long values, distribute them over multiple 1117 # lines so that jam doesn't hit the maximum line length. 1118 variables=" 1119 HAIKU_BOOT_C++_HEADERS_DIR HAIKU_BOOT_CXX_HEADERS_DIR 1120 " 1121 set -- $variables 1122 while [ $# -ge 2 ]; do 1123 echo "${1}_${targetArch} ?= " >> "$buildConfigFile" 1124 get_variable ${2}_$targetArch | xargs -n 1 echo " " \ 1125 >> "$buildConfigFile" 1126 echo " ;" >> "$buildConfigFile" 1127 shift 2 1128 done 1129done 1130 1131 1132# Generate a Jamfile in the output directory. 1133 1134cat << EOF > $outputDir/Jamfile 1135# -- WARNING -- 1136# This file was AUTOMATICALLY GENERATED by configure, and will be completely 1137# overwritten the next time configure is run. 1138 1139HAIKU_TOP = $(relative_to "${sourceDir}" "${outputDir}") ; 1140HAIKU_OUTPUT_DIR = . ; 1141 1142include [ FDirName \$(HAIKU_TOP) Jamfile ] ; 1143 1144EOF 1145 1146echo "Configured successfully!" 1147