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