1#!/bin/sh 2# 3# configure [ <options> ] 4 5# set flag to exit script when exit command is executed 6set -e 7 8# usage 9# 10# Prints usage. 11# 12usage() 13{ 14 cat << EOF 15 16Usage: $0 <options> 17options: 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", "arm" 36 This option and --cross-tools-prefix can be 37 specified multiple times. The first cross tools 38 specify the primary tools, the subsequent ones the 39 secondary tools (for "hybrid" images). 40 For the first --build-cross-tools the 41 <build tools dir> argument must be specified and 42 for the subsequent ones it must be omitted. 43 --cross-tools-prefix <prefix> 44 Assume cross compilation. <prefix> should be a 45 path to the directory where the cross 46 compilation tools are located, plus the platform 47 prefix, e.g. "/path/to/tools/i586-pc-haiku-". 48 This overrides the HAIKU_* tool variables. 49 --distro-compatibility <level> 50 The distribution's level of compatibility with 51 the official Haiku distribution. The generated 52 files will contain the respective trademarks 53 accordingly. 54 official -- the official Haiku distribution. 55 compatible -- a Haiku Compatible (tm) distro. 56 default -- any other distro (default value). 57 --enable-multiuser Enable experimental multiuser support. 58 --help Prints out this help. 59 --host-only Configure for building tools for the build host 60 only. Haiku cannot be built when configured like 61 this. 62 --include-gpl-addons Include GPL licensed add-ons. 63 --include-patented-code Enable code that is known to implemented patented 64 ideas and techniques. If this option is not 65 specified, the resulting distribution may still 66 implement patented ideas and techniques. This 67 option only disables code that is currently known 68 to be problematic. 69 --include-sources Includes the source code of projects that require 70 either an offer of source code or a copy of the 71 patched sources. This is preferable when 72 distributing on physical mediums. 73 --include-3rdparty Include 3rdparty/ in the build system. 74 -j<n> Only relevant for --build-cross-tools. Is passed 75 on to the make building the build tools. 76 --no-downloads Do not download anything. Useful when trying to 77 bootstrap and build Haiku from source only. 78 --remote-user <username> Use given username when logging into 79 git.haiku-os.org (via ssh). 80 --target=TARGET Select build target platform. 81 [default=${TARGET_PLATFORM}] 82 valid targets=r5,bone,dano,haiku 83 --target-arch <arch> Haiku only: Specify the target architecture to 84 build for. Must be one of the architectures of the 85 host system. The installed build tools for that 86 architecture will be used. 87 This option can be specified multiple times. The 88 first occurrence specifies the primary 89 architecture of the Haiku to build, subsequent 90 ones the secondary architectures. 91 --target-board <board> ARM only: Specify the board to build for. Must be 92 one of beagle,raspberry_pi,verdex. 93 --update re-runs last configure invocation [must be given 94 as first option!] 95 --use-clang Build with host Clang instead of GCC cross 96 compiler 97 --use-gcc-pipe Build with GCC option -pipe. Speeds up the build 98 process, but uses more memory. 99 --use-gcc-graphite Build with GCC Graphite engine for loop 100 optimizations. Only for gcc 4. 101 --use-32bit Use -m32 flag on 64bit host gcc compiler. 102 --use-xattr Use Linux xattr respectively *BSD extattr support 103 for BeOS attribute emulation. Warning: Make sure 104 your file system supports sufficient attribute 105 sizes (4 KB per file for all attributes won't 106 suffice). 107 --use-xattr-ref Use the generic BeOS attribute emulation, but use 108 Linux xattr respectively *BSD extattr support to 109 make it more robust (i.e. attribute mix-ups become 110 less likely). 111 112environment variables: 113 CC The host compiler. Defaults to "gcc". 114 HAIKU_AR_x86_gcc2 The static library archiver for x86_gcc2. 115 Defaults to "ar". 116 HAIKU_CC_x86_gcc2 The x86_gcc2 compiler. Defaults to "gcc". 117 HAIKU_LD_x86_gcc2 The x86_gcc2 linker. Defaults to "ld". 118 HAIKU_OBJCOPY_x86_gcc2 The x86_gcc2 objcopy to be used. Defaults to 119 "objcopy". 120 HAIKU_RANLIB_x86_gcc2 The static library indexer for x86_gcc2. Defaults 121 to "ranlib". 122 HAIKU_STRIP_x86_gcc2 The x86_gcc2 strip command. Defaults to "strip". 123 HAIKU_NASM The nasm assembler (x86 and x86_64 only). 124 HAIKU_CPPFLAGS_<arch> The preprocessor flags for target architecture 125 <arch>. Defaults to "". 126 HAIKU_CCFLAGS_<arch> The C flags for target architecture <arch>. 127 Defaults to "". 128 HAIKU_CXXFLAGS_<arch> The C++ flags for target architecture <arch>. 129 Defaults to "". 130 HAIKU_LDFLAGS_<arch> The linker flags for target architecture <arch>. 131 Defaults to "". 132 HAIKU_ARFLAGS_<arch> The flags passed to HAIKU_AR for target 133 architecture <arch> for archiving. Defaults to 134 "cru". 135 HAIKU_UNARFLAGS_<arch> The flags passed to HAIKU_AR for target 136 architecture <arch> for unarchiving. Defaults to 137 "x". 138 139Non-default output directories: 140 By default all objects, build configuration, and other related files are 141 stored in /path/to/haiku_source/generated. To store objects in a non-default 142 location, run "../../relative/path/to/haiku_source/configure <options>" from 143 within your non-default location. "jam [ options ] targets" can then be run 144 directly inside your non-default location. Another option is to invoke "jam 145 [ options ] targets" from within haiku_source. This can be accomplished by 146 either "export HAIKU_OUTPUT_DIR=your non-default location" before invoking 147 jam or by creating a symlink of haiku_source/generated pointing to your 148 non-default location and running jam. 149 150 151EOF 152} 153 154# assertparam 155# 156# Checks whether at least one parameter is left. 157# 158assertparam() 159{ 160 if [ $2 -lt 2 ]; then 161 echo $0: \`$1\': Parameter expected. 162 exit 1 163 fi 164} 165 166# assertparams 167# 168# Checks whether at least a certain number of parameters is left. 169# 170assertparams() 171{ 172 if [ $3 -le $2 ]; then 173 echo $0: \`$1\': Not enough parameters. 174 exit 1 175 fi 176} 177 178# absolute_path 179# 180# returns the absolute path of a given path. 181# 182absolute_path() 183{ 184 if [ "x$1" != "x${1#/}" ]; then 185 echo "$1" 186 else 187 echo "`pwd`/$1" 188 fi 189} 190 191# check_dir_exists 192# 193# check if a directory exists or not 194# 195check_dir_exists() 196{ 197 if [ -d "$1" ]; then 198 return 0 199 else 200 return 1 201 fi 202} 203 204# check_file_exists 205# 206# check if a file exists or not 207# 208check_file_exists() 209{ 210 if [ -f "$1" ]; then 211 return 0 212 else 213 return 1 214 fi 215} 216 217# real_path 218# 219# returns the realpath of a symbolic link. 220# 221real_path() 222{ 223 perl -MCwd=realpath -e'print realpath($ARGV[0]), "\n"' "$1" 224} 225 226# standard_gcc_settings 227# 228# Sets the variables for a GCC platform. 229# 230standard_gcc_settings() 231{ 232 local gcc=$1 233 234 if which greadlink > /dev/null 2>&1; then 235 readlink="greadlink -e" 236 elif which realpath > /dev/null 2>&1; then 237 readlink=realpath 238 elif readlink -e / > /dev/null 2>&1; then 239 readlink="readlink -e" 240 else 241 readlink=real_path 242 fi 243 244 # PLATFORM_LINKLIBS 245 local gcclib=`$gcc -print-libgcc-file-name` 246 local gccdir=`dirname ${gcclib}` 247 248 local gccRawVersion=`$gcc -dumpversion` 249 local gccMachine=`$gcc -dumpmachine` 250 251 # determine architecture from machine triple 252 case $gccMachine in 253 arm-*) targetCpu=arm;; 254 i?86-*) targetCpu=x86;; 255 m68k-*) targetCpu=m68k;; 256 powerpc-*) targetCpu=ppc;; 257 x86_64-*) targetCpu=x86_64;; 258 *) 259 echo "Unsupported gcc target machine: $gccMachine" >&2 260 exit 1 261 ;; 262 esac 263 264 local targetArch=$targetCpu 265 266 case $gccRawVersion in 267 2.9*) 268 # check for correct (most up-to-date) legacy compiler and complain 269 # if an older one is installed 270 if [ $gccRawVersion != $haikuRequiredLegacyGCCVersion ]; then 271 echo "GCC version $haikuRequiredLegacyGCCVersion is required!"; 272 echo "Please download it from www.haiku-os.org..."; 273 exit 1; 274 fi 275 276 targetArch=x86_gcc2 277 ;; 278 esac 279 280 local bootLibgcc 281 local bootLibSupCxx 282 local bootCxxHeaders 283 case $gccMachine in 284 x86_64-*) 285 # Boot loader is 32-bit, need the 32-bit libs and c++ config 286 bootLibgcc=`$gcc -m32 -print-file-name=libgcc.a` 287 bootLibSupCxx=`$gcc -m32 -print-file-name=libsupc++.a` 288 289 local headersBase=$gccdir/../../../.. 290 local headers=$headersBase/$gccMachine/include/c++/$gccRawVersion 291 if [ ! -d $headers ]; then 292 headers=$headersBase/include/c++/$gccRawVersion 293 fi 294 bootCxxHeaders="$headers/$gccMachine/32" 295 ;; 296 esac 297 298 # determine whether graphite loop optimization should/can be used 299 local useGraphite=`get_variable HAIKU_USE_GCC_GRAPHITE_$targetCpu` 300 if [ -z "$useGraphite" ]; then 301 useGraphite=$useGccGraphiteDefault 302 fi 303 304 if [ "$useGraphite" != 0 ]; then 305 UNUSED=`echo "int main() {}" | $gcc -xc -c -floop-block - 2>&1` 306 if [ $? != 0 ]; then 307 echo "GCC Graphite loop optimizations cannot be used on $targetArch" 308 useGraphite=0 309 fi 310 fi 311 312 set_variable HAIKU_CPU_$targetArch $targetCpu 313 314 get_build_tool_path CC_$targetArch "$gcc" 315 if [ $useClang = 1 ]; then 316 # The get_build_tool_path above is needed to get the path to the rest 317 # of the build tools 318 local path=`dirname $(get_variable HAIKU_CC_$targetArch)` 319 set_variable HAIKU_CC_$targetArch \ 320 "PATH=\\\"$path:\\\$PATH\\\" clang -target $gccMachine" 321 set_variable HAIKU_CC_IS_CLANG_$targetArch 1 322 else 323 set_variable HAIKU_CC_IS_CLANG_$targetArch 0 324 fi 325 set_variable HAIKU_GCC_RAW_VERSION_$targetArch $gccRawVersion 326 set_variable HAIKU_GCC_MACHINE_$targetArch $gccMachine 327 set_variable HAIKU_GCC_LIB_DIR_$targetArch $gccdir 328 set_variable HAIKU_BOOT_CXX_HEADERS_DIR_$targetArch "$bootCxxHeaders" 329 set_variable HAIKU_BOOT_LIBSUPCXX_$targetArch "$bootLibSupCxx" 330 set_variable HAIKU_BOOT_LIBGCC_$targetArch $bootLibgcc 331 set_variable HAIKU_USE_GCC_GRAPHITE_$targetArch $useGraphite 332 333 standard_gcc_settings_targetArch=$targetArch 334} 335 336# set_variable 337# 338# Set the value of a variable. 339# 340set_variable() 341{ 342 eval "$1=\"$2\"" 343} 344 345# get_variable 346# 347# Echo the value of a variable. 348# 349get_variable() 350{ 351 eval "echo \${$1}" 352} 353 354# set_default_value 355# 356# Set the value for a variable, if no value is set yet. 357# 358set_default_value() 359{ 360 eval "$1=\${$1-$2}" 361} 362 363# get_build_tool_path 364# 365# Gets a usable absolute path of a build tool. 366# 367get_build_tool_path() 368{ 369 local var="HAIKU_$1" 370 local path=$2 371 372 if [ -f "$path" ]; then 373 # get absolute path 374 local oldPwd="`pwd`" 375 cd "`dirname "$path"`" 376 path="`pwd`/`basename "$path"`" 377 cd $oldPwd 378 else 379 which "$path" > /dev/null 2>&1 || { 380 echo "Build tool \"$path\" not found." >&2 381 exit 1 382 } 383 fi 384 385 eval "$var=$path" 386} 387 388is_in_list() 389{ 390 local element 391 for element in $2; do 392 if [ "$1" = "$element" ]; then 393 return 0 394 fi 395 done 396 return 1 397} 398 399# check for --help or -h and show usage immediately 400if [ "$1" = "--help" ] || [ "$1" = "-h" ]; then 401 usage; exit 0; 402fi 403 404 405# get cwd and the source directory 406currentDir=`pwd` 407cd `dirname "$0"` 408sourceDir=`pwd` 409cd "$currentDir" 410 411# backup the passed arguments 412configureArgs="$@" 413 414# internal default parameter values 415# 416platform=`uname` 417platformMachine=`uname -m` 418targetArchs= 419buildCrossTools= 420buildCrossToolsScript="$sourceDir/build/scripts/build_cross_tools" 421buildCrossToolsJobs= 422useClang=0 423useGccGraphiteDefault=0 424unknownArchIndex=1 425haikuTargetArchs= 426 427if [ -z "$CC" ]; then 428 CC=gcc 429fi 430 431# exported (BuildSetup) default parameter values 432# 433HOST_GCC_RAW_VERSION=`$CC -dumpversion` 434HOST_GCC_MACHINE=`$CC -dumpmachine` 435HAIKU_INCLUDE_GPL_ADDONS=0 436HAIKU_INCLUDE_PATENTED_CODE=0 437HAIKU_INCLUDE_SOURCES=0 438HAIKU_INCLUDE_3RDPARTY=0 439HAIKU_ENABLE_MULTIUSER=0 440HAIKU_DISTRO_COMPATIBILITY=default 441TARGET_PLATFORM=haiku 442HAIKU_USE_GCC_PIPE=0 443HAIKU_HOST_USE_32BIT=0 444HAIKU_HOST_USE_XATTR=0 445HAIKU_HOST_USE_XATTR_REF=0 446HAIKU_HOST_BUILD_ONLY=0 447HOST_EXTENDED_REGEX_SED="sed -r" 448HOST_GCC_LD=`$CC -print-prog-name=ld` 449HOST_GCC_OBJCOPY=`$CC -print-prog-name=objcopy` 450HOST_SHA256= 451HOST_HAIKU_PORTER= 452HAIKU_PORTS= 453HAIKU_PORTS_CROSS= 454HAIKU_IS_BOOTSTRAP=0 455HAIKU_BOOT_BOARD= 456HAIKU_NO_DOWNLOADS=0 457 458HAIKU_PACKAGING_ARCHS= 459 460set_default_value HAIKU_NASM nasm 461 462if sha256sum < /dev/null > /dev/null 2>&1; then 463 HOST_SHA256=sha256sum 464elif sha256 < /dev/null > /dev/null 2>&1; then 465 HOST_SHA256="sha256 -q" 466elif shasum < /dev/null > /dev/null 2>&1; then 467 HOST_SHA256="shasum -a 256" 468else 469 echo "Error: Neither sha256sum nor sha256 seem to be available!" >&2 470 exit 1 471fi 472 473haikuRequiredLegacyGCCVersion="2.95.3-haiku-2014_07_26" 474export haikuRequiredLegacyGCCVersion 475 # version of legacy gcc required to build haiku 476supportedTargetArchs=" 477 arm 478 m68k 479 ppc 480 x86 481 x86_64 482 x86_gcc2 483 " 484supportedTargetBoards=" 485 beagle 486 raspberry_pi 487 verdex 488 " 489 490# determine output directory 491if [ "$currentDir" = "$sourceDir" ]; then 492 outputDir=$currentDir/generated 493else 494 outputDir=$currentDir 495fi 496buildOutputDir="$outputDir/build" 497HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes" 498buildConfigFile="$buildOutputDir/BuildConfig" 499 500# check for update request 501if [ "$1" = "--update" ]; then 502 if ! [ -e "$buildConfigFile" ]; then 503 echo $0 --update: \'$buildConfigFile\' not found - updating not possible. 504 exit 1 505 fi 506 if ! type perl >/dev/null 2>&1; then 507 echo $0 --update: \'perl\' not found - updating not possible. 508 exit 1 509 fi 510 # convert BuildConfig from jam format to shell format and evaluate it 511 shellConfigFile="${buildConfigFile}.shell" 512 perl "$sourceDir/build/scripts/convert_build_config_to_shell_format.pl" \ 513 <"$buildConfigFile" >"$shellConfigFile" 514 . "$shellConfigFile" 515 rm "$shellConfigFile" 516 shift 517fi 518 519# parse parameters 520# 521while [ $# -gt 0 ] ; do 522 case "$1" in 523 --bootstrap) 524 assertparams "$1" 3 $# 525 HOST_HAIKU_PORTER="`absolute_path $2`" 526 HAIKU_PORTS_CROSS="`absolute_path $3`" 527 HAIKU_PORTS="`absolute_path $4`" 528 HAIKU_IS_BOOTSTRAP=1 529 HAIKU_NO_DOWNLOADS=1 530 check_file_exists "$HOST_HAIKU_PORTER" || ( 531 echo "Invalid path to haikuporter: $HOST_HAIKU_PORTER" >&2 532 exit 1 533 ) 534 check_dir_exists "$HAIKU_PORTS" || ( 535 echo "Non-existent directory $HAIKU_PORTS" >&2 536 exit 1 537 ) 538 check_dir_exists "$HAIKU_PORTS_CROSS" || ( 539 echo "Non-existent directory $HAIKU_PORTS_CROSS" >&2 540 exit 1 541 ) 542 shift 4 543 ;; 544 --build-cross-tools) 545 if [ -z "$buildCrossTools" ]; then 546 assertparams "$1" 2 $# 547 targetArch=$2 548 buildCrossTools=$3 549 shift 3 550 else 551 assertparam "$1" $# 552 targetArch=$2 553 shift 2 554 fi 555 case "$targetArch" in 556 x86_gcc2) targetMachine=i586-pc-haiku;; 557 x86) targetMachine=i586-pc-haiku;; 558 x86_64) targetMachine=x86_64-unknown-haiku;; 559 ppc) targetMachine=powerpc-apple-haiku;; 560 m68k) targetMachine=m68k-unknown-haiku;; 561 arm) targetMachine=arm-unknown-haiku;; 562 *) 563 echo "Unsupported target architecture: $2" >&2 564 exit 1 565 ;; 566 esac 567 set_variable buildCrossToolsMachine_$targetArch $targetMachine 568 targetArchs="$targetArchs $targetArch" 569 HAIKU_PACKAGING_ARCHS= 570 ;; 571 --cross-tools-prefix) 572 assertparam "$1" $# 573 targetArch=unknown${unknownArchIndex} 574 set_variable crossToolsPrefix_$targetArch "$2" 575 targetArchs="$targetArchs $targetArch" 576 HAIKU_PACKAGING_ARCHS= 577 unknownArchIndex=$(($unknownArchIndex + 1)) 578 shift 2 579 ;; 580 --distro-compatibility) 581 assertparam "$1" $# 582 HAIKU_DISTRO_COMPATIBILITY=$2 583 case "$HAIKU_DISTRO_COMPATIBILITY" in 584 official) ;; 585 compatible) ;; 586 default) ;; 587 *) echo "Invalid distro compatibility" \ 588 "level: $HAIKU_DISTRO_COMPATIBILITY" 589 exit 1;; 590 esac 591 shift 2 592 ;; 593 --enable-multiuser) HAIKU_ENABLE_MULTIUSER=1; shift 1;; 594 --host-only) HAIKU_HOST_BUILD_ONLY=1; shift 1;; 595 --include-gpl-addons) HAIKU_INCLUDE_GPL_ADDONS=1; shift 1;; 596 --include-patented-code) HAIKU_INCLUDE_PATENTED_CODE=1; shift 1;; 597 --include-sources) HAIKU_INCLUDE_SOURCES=1; shift 1;; 598 --include-3rdparty) HAIKU_INCLUDE_3RDPARTY=1; shift 1;; 599 -j*) buildCrossToolsJobs="$1"; shift 1;; 600 --no-downloads) HAIKU_NO_DOWNLOADS=1; shift 1;; 601 --target=*) TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;; 602 --target-arch) 603 assertparam "$1" $# 604 targetArch=$2 605 shift 2 606 if [ ! "$platform" = Haiku ]; then 607 echo "--target-arch can only be specified on Haiku." >&2 608 exit 1 609 fi 610 is_in_list "$targetArch" "$supportedTargetArchs" || ( 611 echo "Unsupported target architecture: \"$targetArch\"" >&2 612 exit 1 613 ) 614 haikuTargetArchs="$haikuTargetArchs $targetArch" 615 ;; 616 --target-board) 617 assertparam "$1" $# 618 HAIKU_BOOT_BOARD=$2 619 is_in_list "$HAIKU_BOOT_BOARD" "$supportedTargetBoards" || ( 620 echo "Unsupported target board: \"$HAIKU_BOOT_BOARD\"" >&2 621 exit 1 622 ) 623 shift 2 624 ;; 625 --use-clang) useClang=1; shift 1;; 626 --use-gcc-pipe) HAIKU_USE_GCC_PIPE=1; shift 1;; 627 --use-gcc-graphite) useGccGraphiteDefault=1; shift 1;; 628 --use-32bit) HAIKU_HOST_USE_32BIT=1; shift 1;; 629 --use-xattr) HAIKU_HOST_USE_XATTR=1; shift 1;; 630 --use-xattr-ref) HAIKU_HOST_USE_XATTR_REF=1; shift 1;; 631 *) echo Invalid argument: \`$1\'; exit 1;; 632 esac 633done 634 635# detect the build platform 636case "${platform}" in 637 Darwin) HOST_PLATFORM=darwin ;; 638 FreeBSD) HOST_PLATFORM=freebsd 639 if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then 640 echo Unsupported platform: FreeBSD ${platformMachine} 641 exit 1 642 fi ;; 643 Haiku) HOST_PLATFORM=haiku_host ;; 644 Linux) HOST_PLATFORM=linux ;; 645 OpenBSD) HOST_PLATFORM=openbsd ;; 646 SunOS) HOST_PLATFORM=sunos ;; 647 CYGWIN_NT-*) HOST_PLATFORM=cygwin ;; 648 *) echo Unsupported platform: ${platform} 649 exit 1 ;; 650esac 651 652# check for case-sensitive filesystem 653mkdir haikuCaseTest 2>/dev/null 654mkdir haikucasetest 2>/dev/null 655caseInsensitive=$? 656rmdir haikuCaseTest haikucasetest 2>/dev/null 657if [ $caseInsensitive != 0 ]; then 658 echo "You need a case-sensitive file-system to build Haiku." 659 if [ $HOST_PLATFORM = "darwin" ]; then 660 echo "You can create a case-sensitive disk image using Disk Utility and use" 661 echo "it to store the Haiku sources on." 662 fi 663 exit 1 664fi 665 666# determine how to invoke sed with extended regexp support for non-GNU sed 667if [ $HOST_PLATFORM = "darwin" ]; then 668 HOST_EXTENDED_REGEX_SED="sed -E" 669fi 670 671# check if nasm can actually output ELF files 672# (the stock version in OSX can't) 673# XXX: should probably only test for x86* arch 674if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then 675 echo "$HAIKU_NASM cannot generate ELF files. Please install a working version." 676 if [ $HOST_PLATFORM = "darwin" ]; then 677 echo "You can install it from Mac Ports." 678 echo "Mac Ports is available at: http://www.macports.org/" 679 fi 680 exit 1 681fi 682 683# create output directory 684mkdir -p "$buildOutputDir" || exit 1 685 686if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then 687 invalidCommand=$sourceDir/build/scripts/host_build_only 688 HAIKU_AR=$invalidCommand 689 HAIKU_CC=$invalidCommand 690 HAIKU_LD=$invalidCommand 691 HAIKU_OBJCOPY=$invalidCommand 692 HAIKU_RANLIB=$invalidCommand 693 HAIKU_ELFEDIT=$invalidCommand 694 HAIKU_NASM=$invalidCommand 695 HAIKU_STRIP=$invalidCommand 696else 697 if [ -n "$HAIKU_PACKAGING_ARCHS" ]; then 698 targetArchs="$HAIKU_PACKAGING_ARCHS" 699 fi 700 HAIKU_PACKAGING_ARCHS= 701 702 # On Haiku determine target architectures and tools automatically. 703 if [ -z "$targetArchs" ]; then 704 if [ $HOST_PLATFORM != haiku_host ]; then 705 echo "Please specify the build tools to use or build (via" \ 706 "--cross-tools-prefix or --build-cross-tools) or specify a" \ 707 "host-only build (--host-only)." >&2 708 echo "For more info, invoke $0 --help" 709 exit 1 710 fi 711 712 # determine primary architecture 713 targetArch=`package list -i /system/packages/haiku-*.hpkg \ 714 | sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'` 715 is_in_list "$targetArch" "$supportedTargetArchs" || ( 716 echo "Unsupported target architecture: \"$targetArch\"" >&2 717 exit 1 718 ) 719 targetArchs=$targetArch 720 721 set_default_value HAIKU_AR_$targetArch ar 722 set_default_value HAIKU_CC_$targetArch gcc 723 set_default_value HAIKU_LD_$targetArch ld 724 set_default_value HAIKU_OBJCOPY_$targetArch objcopy 725 set_default_value HAIKU_RANLIB_$targetArch ranlib 726 set_default_value HAIKU_ELFEDIT_$targetArch elfedit 727 set_default_value HAIKU_STRIP_$targetArch strip 728 729 # determine secondary architectures 730 for targetArch in $supportedTargetArchs; do 731 if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then 732 targetArchs="$targetArchs $targetArch" 733 set_default_value HAIKU_AR_$targetArch ar-$targetArch 734 set_default_value HAIKU_CC_$targetArch gcc-$targetArch 735 set_default_value HAIKU_LD_$targetArch ld-$targetArch 736 set_default_value HAIKU_OBJCOPY_$targetArch objcopy-$targetArch 737 set_default_value HAIKU_RANLIB_$targetArch ranlib-$targetArch 738 set_default_value HAIKU_ELFEDIT_$targetArch elfedit-$targetArch 739 set_default_value HAIKU_STRIP_$targetArch strip-$targetArch 740 fi 741 done 742 743 # The target architectures might have been specified explicitly. 744 if [ -n "$haikuTargetArchs" ]; then 745 for targetArch in $haikuTargetArchs; do 746 is_in_list "$targetArch" "$targetArchs" || ( 747 echo "Unsupported target architecture: \"$targetArch\"." \ 748 "Only native architectures of the host platform can" \ 749 "be specified." >&2 750 exit 1 751 ) 752 done 753 targetArchs="$haikuTargetArchs" 754 fi 755 fi 756 757 isPrimaryArch=1 758 for targetArch in $targetArchs; do 759 # Note: targetArch is "unknown<n>" at this point, if a cross-tools 760 # prefix was specified. The standard_gcc_settings call below will get 761 # the actual architecture. 762 763 crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch` 764 765 # build cross tools from sources 766 if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then 767 crossToolsDir="$outputDir/cross-tools-$targetArch" 768 targetMachine=`get_variable buildCrossToolsMachine_$targetArch` 769 script="$buildCrossToolsScript" 770 scriptArgs= 771 if [ $targetArch != x86_gcc2 ]; then 772 script="${script}_gcc4" 773 scriptArgs="$targetMachine" 774 set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch \ 775 $useGccGraphiteDefault 776 fi 777 secondaryArch= 778 if [ -z "$isPrimaryArch" ]; then 779 secondaryArch=$targetArch 780 fi 781 782 case $HOST_PLATFORM in 783 freebsd|openbsd) MAKE=gmake;; 784 *) MAKE=make;; 785 esac 786 787 MAKE=$MAKE \ 788 SECONDARY_ARCH=$secondaryArch \ 789 HAIKU_USE_GCC_GRAPHITE=`get_variable \ 790 HAIKU_USE_GCC_GRAPHITE_$targetArch` \ 791 HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \ 792 "$script" $scriptArgs "$sourceDir" "$buildCrossTools" \ 793 "$crossToolsDir" $buildCrossToolsJobs || exit 1 794 crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-" 795 fi 796 797 # prepare gcc settings and get the actual target architecture 798 gcc="${crossToolsPrefix}gcc" 799 if [ -z "${crossToolsPrefix}" ]; then 800 gcc=`get_variable HAIKU_CC_$targetArch` 801 fi 802 standard_gcc_settings "$gcc" 803 targetArch=$standard_gcc_settings_targetArch 804 805 # set default values for flags 806 set_default_value HAIKU_CPPFLAGS_$targetArch "" 807 set_default_value HAIKU_CCFLAGS_$targetArch "" 808 set_default_value HAIKU_CXXFLAGS_$targetArch "" 809 set_default_value HAIKU_LDFLAGS_$targetArch "" 810 set_default_value HAIKU_ARFLAGS_$targetArch cru 811 set_default_value HAIKU_UNARFLAGS_$targetArch x 812 813 # Override the cross tools variables, if the tools were built or a 814 # prefix was specified. 815 if [ -n "$crossToolsPrefix" ]; then 816 get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar 817 get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld 818 get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy 819 get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib 820 get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip 821 822 case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in 823 4.*) 824 get_build_tool_path ELFEDIT_$targetArch \ 825 ${crossToolsPrefix}elfedit 826 ;; 827 esac 828 fi 829 830 # check whether the Haiku compiler really targets Haiku 831 targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch` 832 case "$targetMachine" in 833 *-*-haiku) ;; 834 *) 835 echo The compiler specified as Haiku target compiler is not a \ 836 valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2 837 echo compiler: $HAIKU_CC 838 echo compiler is configured for target: $targetMachine 839 exit 1 ;; 840 esac 841 842 HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch" 843 isPrimaryArch= 844 done 845fi 846 847# Generate BuildConfig 848cat << EOF > "$buildConfigFile" 849# BuildConfig 850# Note: This file has been automatically generated by configure with the 851# following arguments: 852# ${configureArgs} 853 854TARGET_PLATFORM ?= "${TARGET_PLATFORM}" ; 855HOST_PLATFORM ?= "${HOST_PLATFORM}" ; 856 857HAIKU_INCLUDE_GPL_ADDONS ?= "${HAIKU_INCLUDE_GPL_ADDONS}" ; 858HAIKU_INCLUDE_PATENTED_CODE ?= "${HAIKU_INCLUDE_PATENTED_CODE}" ; 859HAIKU_INCLUDE_SOURCES ?= "${HAIKU_INCLUDE_SOURCES}" ; 860HAIKU_INCLUDE_3RDPARTY ?= "${HAIKU_INCLUDE_3RDPARTY}" ; 861HAIKU_ENABLE_MULTIUSER ?= "${HAIKU_ENABLE_MULTIUSER}" ; 862HAIKU_DISTRO_COMPATIBILITY ?= "${HAIKU_DISTRO_COMPATIBILITY}" ; 863HAIKU_USE_GCC_PIPE ?= "${HAIKU_USE_GCC_PIPE}" ; 864HAIKU_HOST_USE_32BIT ?= "${HAIKU_HOST_USE_32BIT}" ; 865HAIKU_HOST_USE_XATTR ?= "${HAIKU_HOST_USE_XATTR}" ; 866HAIKU_HOST_USE_XATTR_REF ?= "${HAIKU_HOST_USE_XATTR_REF}" ; 867HAIKU_HOST_BUILD_ONLY ?= "${HAIKU_HOST_BUILD_ONLY}" ; 868 869HAIKU_PACKAGING_ARCHS ?= ${HAIKU_PACKAGING_ARCHS} ; 870 871HAIKU_NO_DOWNLOADS ?= "${HAIKU_NO_DOWNLOADS}" ; 872 873HAIKU_BUILD_ATTRIBUTES_DIR ?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ; 874 875HAIKU_NASM ?= ${HAIKU_NASM} ; 876HAIKU_BOOT_BOARD ?= ${HAIKU_BOOT_BOARD} ; 877 878HOST_EXTENDED_REGEX_SED ?= ${HOST_EXTENDED_REGEX_SED} ; 879HOST_GCC_RAW_VERSION ?= ${HOST_GCC_RAW_VERSION} ; 880HOST_GCC_MACHINE ?= ${HOST_GCC_MACHINE} ; 881HOST_LD ?= ${HOST_GCC_LD} ; 882HOST_OBJCOPY ?= ${HOST_GCC_OBJCOPY} ; 883HOST_SHA256 ?= ${HOST_SHA256} ; 884 885HOST_HAIKU_PORTER ?= ${HOST_HAIKU_PORTER} ; 886HAIKU_PORTS ?= ${HAIKU_PORTS} ; 887HAIKU_PORTS_CROSS ?= ${HAIKU_PORTS_CROSS} ; 888HAIKU_IS_BOOTSTRAP ?= ${HAIKU_IS_BOOTSTRAP} ; 889 890EOF 891 892for targetArch in $HAIKU_PACKAGING_ARCHS; do 893 variables=" 894 HAIKU_GCC_RAW_VERSION HAIKU_GCC_RAW_VERSION 895 HAIKU_GCC_MACHINE HAIKU_GCC_MACHINE 896 HAIKU_GCC_LIB_DIR HAIKU_GCC_LIB_DIR 897 HAIKU_CPU HAIKU_CPU 898 HAIKU_BOOT_LIBGCC HAIKU_BOOT_LIBGCC 899 HAIKU_BOOT_LIBSUPC++ HAIKU_BOOT_LIBSUPCXX 900 HAIKU_AR HAIKU_AR 901 HAIKU_CC HAIKU_CC 902 HAIKU_CC_IS_CLANG HAIKU_CC_IS_CLANG 903 HAIKU_LD HAIKU_LD 904 HAIKU_OBJCOPY HAIKU_OBJCOPY 905 HAIKU_RANLIB HAIKU_RANLIB 906 HAIKU_ELFEDIT HAIKU_ELFEDIT 907 HAIKU_STRIP HAIKU_STRIP 908 HAIKU_CPPFLAGS HAIKU_CPPFLAGS 909 HAIKU_CCFLAGS HAIKU_CCFLAGS 910 HAIKU_C++FLAGS HAIKU_CXXFLAGS 911 HAIKU_LDFLAGS HAIKU_LDFLAGS 912 HAIKU_ARFLAGS HAIKU_ARFLAGS 913 HAIKU_UNARFLAGS HAIKU_UNARFLAGS 914 HAIKU_USE_GCC_GRAPHITE HAIKU_USE_GCC_GRAPHITE 915 " 916 set -- $variables 917 while [ $# -ge 2 ]; do 918 value=`get_variable ${2}_$targetArch` 919 echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile" 920 shift 2 921 done 922 923 # For variables that may have long values, distribute them over multiple 924 # lines so that jam doesn't hit the maximum line length. 925 variables=" 926 HAIKU_BOOT_C++_HEADERS_DIR HAIKU_BOOT_CXX_HEADERS_DIR 927 " 928 set -- $variables 929 while [ $# -ge 2 ]; do 930 echo "${1}_${targetArch} ?= " >> "$buildConfigFile" 931 get_variable ${2}_$targetArch | xargs -n 1 echo " " \ 932 >> "$buildConfigFile" 933 echo " ;" >> "$buildConfigFile" 934 shift 2 935 done 936done 937 938 939# Generate a boot strap Jamfile in the output directory. 940 941cat << EOF > $outputDir/Jamfile 942# automatically generated Jamfile 943 944HAIKU_TOP = ${sourceDir} ; 945HAIKU_OUTPUT_DIR = ${outputDir} ; 946 947include [ FDirName \$(HAIKU_TOP) Jamfile ] ; 948 949EOF 950