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