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,rpi1,rpi2,cubieboard4,verdex,overo. 93 --update re-runs last configure invocation [cubieboard4must 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 rpi1 487 rpi2 488 cubieboard4 489 verdex 490 overo 491 " 492 493# determine output directory 494if [ "$currentDir" = "$sourceDir" ]; then 495 outputDir=$currentDir/generated 496else 497 outputDir=$currentDir 498fi 499buildOutputDir="$outputDir/build" 500HAIKU_BUILD_ATTRIBUTES_DIR="$outputDir/attributes" 501buildConfigFile="$buildOutputDir/BuildConfig" 502 503# check for update request 504if [ "$1" = "--update" ]; then 505 if ! [ -e "$buildConfigFile" ]; then 506 echo $0 --update: \'$buildConfigFile\' not found - updating not possible. 507 exit 1 508 fi 509 if ! type perl >/dev/null 2>&1; then 510 echo $0 --update: \'perl\' not found - updating not possible. 511 exit 1 512 fi 513 # convert BuildConfig from jam format to shell format and evaluate it 514 shellConfigFile="${buildConfigFile}.shell" 515 perl "$sourceDir/build/scripts/convert_build_config_to_shell_format.pl" \ 516 <"$buildConfigFile" >"$shellConfigFile" 517 . "$shellConfigFile" 518 rm "$shellConfigFile" 519 shift 520fi 521 522# parse parameters 523# 524while [ $# -gt 0 ] ; do 525 case "$1" in 526 --bootstrap) 527 assertparams "$1" 3 $# 528 HOST_HAIKU_PORTER="`absolute_path $2`" 529 HAIKU_PORTS_CROSS="`absolute_path $3`" 530 HAIKU_PORTS="`absolute_path $4`" 531 HAIKU_IS_BOOTSTRAP=1 532 HAIKU_NO_DOWNLOADS=1 533 check_file_exists "$HOST_HAIKU_PORTER" || ( 534 echo "Invalid path to haikuporter: $HOST_HAIKU_PORTER" >&2 535 exit 1 536 ) 537 check_dir_exists "$HAIKU_PORTS" || ( 538 echo "Non-existent directory $HAIKU_PORTS" >&2 539 exit 1 540 ) 541 check_dir_exists "$HAIKU_PORTS_CROSS" || ( 542 echo "Non-existent directory $HAIKU_PORTS_CROSS" >&2 543 exit 1 544 ) 545 shift 4 546 ;; 547 --build-cross-tools) 548 if [ -z "$buildCrossTools" ]; then 549 assertparams "$1" 2 $# 550 targetArch=$2 551 buildCrossTools=$3 552 shift 3 553 else 554 assertparam "$1" $# 555 targetArch=$2 556 shift 2 557 fi 558 case "$targetArch" in 559 x86_gcc2) targetMachine=i586-pc-haiku;; 560 x86) targetMachine=i586-pc-haiku;; 561 x86_64) targetMachine=x86_64-unknown-haiku;; 562 ppc) targetMachine=powerpc-apple-haiku;; 563 m68k) targetMachine=m68k-unknown-haiku;; 564 arm) targetMachine=arm-unknown-haiku;; 565 *) 566 echo "Unsupported target architecture: $2" >&2 567 exit 1 568 ;; 569 esac 570 set_variable buildCrossToolsMachine_$targetArch $targetMachine 571 targetArchs="$targetArchs $targetArch" 572 HAIKU_PACKAGING_ARCHS= 573 ;; 574 --cross-tools-prefix) 575 assertparam "$1" $# 576 targetArch=unknown${unknownArchIndex} 577 set_variable crossToolsPrefix_$targetArch "$2" 578 targetArchs="$targetArchs $targetArch" 579 HAIKU_PACKAGING_ARCHS= 580 unknownArchIndex=$(($unknownArchIndex + 1)) 581 shift 2 582 ;; 583 --distro-compatibility) 584 assertparam "$1" $# 585 HAIKU_DISTRO_COMPATIBILITY=$2 586 case "$HAIKU_DISTRO_COMPATIBILITY" in 587 official) ;; 588 compatible) ;; 589 default) ;; 590 *) echo "Invalid distro compatibility" \ 591 "level: $HAIKU_DISTRO_COMPATIBILITY" 592 exit 1;; 593 esac 594 shift 2 595 ;; 596 --enable-multiuser) HAIKU_ENABLE_MULTIUSER=1; shift 1;; 597 --host-only) HAIKU_HOST_BUILD_ONLY=1; shift 1;; 598 --include-gpl-addons) HAIKU_INCLUDE_GPL_ADDONS=1; shift 1;; 599 --include-patented-code) HAIKU_INCLUDE_PATENTED_CODE=1; shift 1;; 600 --include-sources) HAIKU_INCLUDE_SOURCES=1; shift 1;; 601 --include-3rdparty) HAIKU_INCLUDE_3RDPARTY=1; shift 1;; 602 -j*) buildCrossToolsJobs="$1"; shift 1;; 603 --no-downloads) HAIKU_NO_DOWNLOADS=1; shift 1;; 604 --target=*) TARGET_PLATFORM=`echo $1 | cut -d'=' -f2-`; shift 1;; 605 --target-arch) 606 assertparam "$1" $# 607 targetArch=$2 608 shift 2 609 if [ ! "$platform" = Haiku ]; then 610 echo "--target-arch can only be specified on Haiku." >&2 611 exit 1 612 fi 613 is_in_list "$targetArch" "$supportedTargetArchs" || ( 614 echo "Unsupported target architecture: \"$targetArch\"" >&2 615 exit 1 616 ) 617 haikuTargetArchs="$haikuTargetArchs $targetArch" 618 ;; 619 --target-board) 620 assertparam "$1" $# 621 HAIKU_BOOT_BOARD=$2 622 is_in_list "$HAIKU_BOOT_BOARD" "$supportedTargetBoards" || ( 623 echo "Unsupported target board: \"$HAIKU_BOOT_BOARD\"" >&2 624 exit 1 625 ) 626 shift 2 627 ;; 628 --use-clang) useClang=1; shift 1;; 629 --use-gcc-pipe) HAIKU_USE_GCC_PIPE=1; shift 1;; 630 --use-gcc-graphite) useGccGraphiteDefault=1; shift 1;; 631 --use-32bit) HAIKU_HOST_USE_32BIT=1; shift 1;; 632 --use-xattr) HAIKU_HOST_USE_XATTR=1; shift 1;; 633 --use-xattr-ref) HAIKU_HOST_USE_XATTR_REF=1; shift 1;; 634 *) echo Invalid argument: \`$1\'; exit 1;; 635 esac 636done 637 638# detect the build platform 639case "${platform}" in 640 Darwin) HOST_PLATFORM=darwin ;; 641 FreeBSD) HOST_PLATFORM=freebsd 642 if [ "$HAIKU_HOST_USE_32BIT" = 1 ] ; then 643 echo Unsupported platform: FreeBSD ${platformMachine} 644 exit 1 645 fi ;; 646 Haiku) HOST_PLATFORM=haiku_host ;; 647 Linux) HOST_PLATFORM=linux ;; 648 OpenBSD) HOST_PLATFORM=openbsd ;; 649 SunOS) HOST_PLATFORM=sunos ;; 650 CYGWIN_NT-*) HOST_PLATFORM=cygwin ;; 651 *) echo Unsupported platform: ${platform} 652 exit 1 ;; 653esac 654 655# check for case-sensitive filesystem 656mkdir haikuCaseTest 2>/dev/null 657mkdir haikucasetest 2>/dev/null 658caseInsensitive=$? 659rmdir haikuCaseTest haikucasetest 2>/dev/null 660if [ $caseInsensitive != 0 ]; then 661 echo "You need a case-sensitive file-system to build Haiku." 662 if [ $HOST_PLATFORM = "darwin" ]; then 663 echo "You can create a case-sensitive disk image using Disk Utility and use" 664 echo "it to store the Haiku sources on." 665 fi 666 exit 1 667fi 668 669# determine how to invoke sed with extended regexp support for non-GNU sed 670if [ $HOST_PLATFORM = "darwin" ]; then 671 HOST_EXTENDED_REGEX_SED="sed -E" 672fi 673 674# check if nasm can actually output ELF files 675# (the stock version in OSX can't) 676# XXX: should probably only test for x86* arch 677if [ "$("$HAIKU_NASM" -hf | grep -c elf'[36][24] ')" -ne "2" ]; then 678 echo "$HAIKU_NASM cannot generate ELF files. Please install a working version." 679 if [ $HOST_PLATFORM = "darwin" ]; then 680 echo "You can install it from Mac Ports." 681 echo "Mac Ports is available at: http://www.macports.org/" 682 fi 683 exit 1 684fi 685 686# create output directory 687mkdir -p "$buildOutputDir" || exit 1 688 689if [ "$HAIKU_HOST_BUILD_ONLY" = 1 ]; then 690 invalidCommand=$sourceDir/build/scripts/host_build_only 691 HAIKU_AR=$invalidCommand 692 HAIKU_CC=$invalidCommand 693 HAIKU_LD=$invalidCommand 694 HAIKU_OBJCOPY=$invalidCommand 695 HAIKU_RANLIB=$invalidCommand 696 HAIKU_ELFEDIT=$invalidCommand 697 HAIKU_NASM=$invalidCommand 698 HAIKU_STRIP=$invalidCommand 699else 700 if [ -n "$HAIKU_PACKAGING_ARCHS" ]; then 701 targetArchs="$HAIKU_PACKAGING_ARCHS" 702 fi 703 HAIKU_PACKAGING_ARCHS= 704 705 # On Haiku determine target architectures and tools automatically. 706 if [ -z "$targetArchs" ]; then 707 if [ $HOST_PLATFORM != haiku_host ]; then 708 echo "Please specify the build tools to use or build (via" \ 709 "--cross-tools-prefix or --build-cross-tools) or specify a" \ 710 "host-only build (--host-only)." >&2 711 echo "For more info, invoke $0 --help" 712 exit 1 713 fi 714 715 # determine primary architecture 716 targetArch=`package list -i /system/packages/haiku-*.hpkg \ 717 | sed '/^\s*architecture:/!d; s,^\s*architecture:\s*,,'` 718 is_in_list "$targetArch" "$supportedTargetArchs" || ( 719 echo "Unsupported target architecture: \"$targetArch\"" >&2 720 exit 1 721 ) 722 targetArchs=$targetArch 723 724 set_default_value HAIKU_AR_$targetArch ar 725 set_default_value HAIKU_CC_$targetArch gcc 726 set_default_value HAIKU_LD_$targetArch ld 727 set_default_value HAIKU_OBJCOPY_$targetArch objcopy 728 set_default_value HAIKU_RANLIB_$targetArch ranlib 729 set_default_value HAIKU_ELFEDIT_$targetArch elfedit 730 set_default_value HAIKU_STRIP_$targetArch strip 731 732 # determine secondary architectures 733 for targetArch in $supportedTargetArchs; do 734 if [ -e /system/packages/haiku_$targetArch-*.hpkg ]; then 735 targetArchs="$targetArchs $targetArch" 736 set_default_value HAIKU_AR_$targetArch ar-$targetArch 737 set_default_value HAIKU_CC_$targetArch gcc-$targetArch 738 set_default_value HAIKU_LD_$targetArch ld-$targetArch 739 set_default_value HAIKU_OBJCOPY_$targetArch objcopy-$targetArch 740 set_default_value HAIKU_RANLIB_$targetArch ranlib-$targetArch 741 set_default_value HAIKU_ELFEDIT_$targetArch elfedit-$targetArch 742 set_default_value HAIKU_STRIP_$targetArch strip-$targetArch 743 fi 744 done 745 746 # The target architectures might have been specified explicitly. 747 if [ -n "$haikuTargetArchs" ]; then 748 for targetArch in $haikuTargetArchs; do 749 is_in_list "$targetArch" "$targetArchs" || ( 750 echo "Unsupported target architecture: \"$targetArch\"." \ 751 "Only native architectures of the host platform can" \ 752 "be specified." >&2 753 exit 1 754 ) 755 done 756 targetArchs="$haikuTargetArchs" 757 fi 758 fi 759 760 isPrimaryArch=1 761 for targetArch in $targetArchs; do 762 # Note: targetArch is "unknown<n>" at this point, if a cross-tools 763 # prefix was specified. The standard_gcc_settings call below will get 764 # the actual architecture. 765 766 crossToolsPrefix=`get_variable crossToolsPrefix_$targetArch` 767 768 # build cross tools from sources 769 if [ -n "$buildCrossTools" -a -z "$crossToolsPrefix" ]; then 770 crossToolsDir="$outputDir/cross-tools-$targetArch" 771 targetMachine=`get_variable buildCrossToolsMachine_$targetArch` 772 script="$buildCrossToolsScript" 773 scriptArgs= 774 if [ $targetArch != x86_gcc2 ]; then 775 script="${script}_gcc4" 776 scriptArgs="$targetMachine" 777 set_default_value HAIKU_USE_GCC_GRAPHITE_$targetArch \ 778 $useGccGraphiteDefault 779 fi 780 secondaryArch= 781 if [ -z "$isPrimaryArch" ]; then 782 secondaryArch=$targetArch 783 fi 784 785 case $HOST_PLATFORM in 786 freebsd|openbsd) MAKE=gmake;; 787 *) MAKE=make;; 788 esac 789 790 MAKE=$MAKE \ 791 SECONDARY_ARCH=$secondaryArch \ 792 HAIKU_USE_GCC_GRAPHITE=`get_variable \ 793 HAIKU_USE_GCC_GRAPHITE_$targetArch` \ 794 HAIKU_USE_GCC_PIPE=$HAIKU_USE_GCC_PIPE \ 795 "$script" $scriptArgs "$sourceDir" "$buildCrossTools" \ 796 "$crossToolsDir" $buildCrossToolsJobs || exit 1 797 crossToolsPrefix="$crossToolsDir/bin/${targetMachine}-" 798 fi 799 800 # prepare gcc settings and get the actual target architecture 801 gcc="${crossToolsPrefix}gcc" 802 if [ -z "${crossToolsPrefix}" ]; then 803 gcc=`get_variable HAIKU_CC_$targetArch` 804 fi 805 standard_gcc_settings "$gcc" 806 targetArch=$standard_gcc_settings_targetArch 807 808 # set default values for flags 809 set_default_value HAIKU_CPPFLAGS_$targetArch "" 810 set_default_value HAIKU_CCFLAGS_$targetArch "" 811 set_default_value HAIKU_CXXFLAGS_$targetArch "" 812 set_default_value HAIKU_LDFLAGS_$targetArch "" 813 set_default_value HAIKU_ARFLAGS_$targetArch cru 814 set_default_value HAIKU_UNARFLAGS_$targetArch x 815 816 # Override the cross tools variables, if the tools were built or a 817 # prefix was specified. 818 if [ -n "$crossToolsPrefix" ]; then 819 get_build_tool_path AR_$targetArch ${crossToolsPrefix}ar 820 get_build_tool_path LD_$targetArch ${crossToolsPrefix}ld 821 get_build_tool_path OBJCOPY_$targetArch ${crossToolsPrefix}objcopy 822 get_build_tool_path RANLIB_$targetArch ${crossToolsPrefix}ranlib 823 get_build_tool_path STRIP_$targetArch ${crossToolsPrefix}strip 824 825 case `get_variable HAIKU_GCC_RAW_VERSION_$targetArch` in 826 4.*) 827 get_build_tool_path ELFEDIT_$targetArch \ 828 ${crossToolsPrefix}elfedit 829 ;; 830 esac 831 fi 832 833 # check whether the Haiku compiler really targets Haiku 834 targetMachine=`get_variable HAIKU_GCC_MACHINE_$targetArch` 835 case "$targetMachine" in 836 *-*-haiku) ;; 837 *) 838 echo The compiler specified as Haiku target compiler is not a \ 839 valid Haiku cross-compiler. Please see ReadMe.cross-compile. >&2 840 echo compiler: $HAIKU_CC 841 echo compiler is configured for target: $targetMachine 842 exit 1 ;; 843 esac 844 845 HAIKU_PACKAGING_ARCHS="$HAIKU_PACKAGING_ARCHS $targetArch" 846 isPrimaryArch= 847 done 848fi 849 850# Generate BuildConfig 851cat << EOF > "$buildConfigFile" 852# BuildConfig 853# Note: This file has been automatically generated by configure with the 854# following arguments: 855# ${configureArgs} 856 857TARGET_PLATFORM ?= "${TARGET_PLATFORM}" ; 858HOST_PLATFORM ?= "${HOST_PLATFORM}" ; 859 860HAIKU_INCLUDE_GPL_ADDONS ?= "${HAIKU_INCLUDE_GPL_ADDONS}" ; 861HAIKU_INCLUDE_PATENTED_CODE ?= "${HAIKU_INCLUDE_PATENTED_CODE}" ; 862HAIKU_INCLUDE_SOURCES ?= "${HAIKU_INCLUDE_SOURCES}" ; 863HAIKU_INCLUDE_3RDPARTY ?= "${HAIKU_INCLUDE_3RDPARTY}" ; 864HAIKU_ENABLE_MULTIUSER ?= "${HAIKU_ENABLE_MULTIUSER}" ; 865HAIKU_DISTRO_COMPATIBILITY ?= "${HAIKU_DISTRO_COMPATIBILITY}" ; 866HAIKU_USE_GCC_PIPE ?= "${HAIKU_USE_GCC_PIPE}" ; 867HAIKU_HOST_USE_32BIT ?= "${HAIKU_HOST_USE_32BIT}" ; 868HAIKU_HOST_USE_XATTR ?= "${HAIKU_HOST_USE_XATTR}" ; 869HAIKU_HOST_USE_XATTR_REF ?= "${HAIKU_HOST_USE_XATTR_REF}" ; 870HAIKU_HOST_BUILD_ONLY ?= "${HAIKU_HOST_BUILD_ONLY}" ; 871 872HAIKU_PACKAGING_ARCHS ?= ${HAIKU_PACKAGING_ARCHS} ; 873 874HAIKU_NO_DOWNLOADS ?= "${HAIKU_NO_DOWNLOADS}" ; 875 876HAIKU_BUILD_ATTRIBUTES_DIR ?= ${HAIKU_BUILD_ATTRIBUTES_DIR} ; 877 878HAIKU_NASM ?= ${HAIKU_NASM} ; 879HAIKU_BOOT_BOARD ?= ${HAIKU_BOOT_BOARD} ; 880 881HOST_EXTENDED_REGEX_SED ?= ${HOST_EXTENDED_REGEX_SED} ; 882HOST_GCC_RAW_VERSION ?= ${HOST_GCC_RAW_VERSION} ; 883HOST_GCC_MACHINE ?= ${HOST_GCC_MACHINE} ; 884HOST_LD ?= ${HOST_GCC_LD} ; 885HOST_OBJCOPY ?= ${HOST_GCC_OBJCOPY} ; 886HOST_SHA256 ?= ${HOST_SHA256} ; 887 888HOST_HAIKU_PORTER ?= ${HOST_HAIKU_PORTER} ; 889HAIKU_PORTS ?= ${HAIKU_PORTS} ; 890HAIKU_PORTS_CROSS ?= ${HAIKU_PORTS_CROSS} ; 891HAIKU_IS_BOOTSTRAP ?= ${HAIKU_IS_BOOTSTRAP} ; 892 893EOF 894 895for targetArch in $HAIKU_PACKAGING_ARCHS; do 896 variables=" 897 HAIKU_GCC_RAW_VERSION HAIKU_GCC_RAW_VERSION 898 HAIKU_GCC_MACHINE HAIKU_GCC_MACHINE 899 HAIKU_GCC_LIB_DIR HAIKU_GCC_LIB_DIR 900 HAIKU_CPU HAIKU_CPU 901 HAIKU_BOOT_LIBGCC HAIKU_BOOT_LIBGCC 902 HAIKU_BOOT_LIBSUPC++ HAIKU_BOOT_LIBSUPCXX 903 HAIKU_AR HAIKU_AR 904 HAIKU_CC HAIKU_CC 905 HAIKU_CC_IS_CLANG HAIKU_CC_IS_CLANG 906 HAIKU_LD HAIKU_LD 907 HAIKU_OBJCOPY HAIKU_OBJCOPY 908 HAIKU_RANLIB HAIKU_RANLIB 909 HAIKU_ELFEDIT HAIKU_ELFEDIT 910 HAIKU_STRIP HAIKU_STRIP 911 HAIKU_CPPFLAGS HAIKU_CPPFLAGS 912 HAIKU_CCFLAGS HAIKU_CCFLAGS 913 HAIKU_C++FLAGS HAIKU_CXXFLAGS 914 HAIKU_LDFLAGS HAIKU_LDFLAGS 915 HAIKU_ARFLAGS HAIKU_ARFLAGS 916 HAIKU_UNARFLAGS HAIKU_UNARFLAGS 917 HAIKU_USE_GCC_GRAPHITE HAIKU_USE_GCC_GRAPHITE 918 " 919 set -- $variables 920 while [ $# -ge 2 ]; do 921 value=`get_variable ${2}_$targetArch` 922 echo "${1}_${targetArch} ?= $value ;" >> "$buildConfigFile" 923 shift 2 924 done 925 926 # For variables that may have long values, distribute them over multiple 927 # lines so that jam doesn't hit the maximum line length. 928 variables=" 929 HAIKU_BOOT_C++_HEADERS_DIR HAIKU_BOOT_CXX_HEADERS_DIR 930 " 931 set -- $variables 932 while [ $# -ge 2 ]; do 933 echo "${1}_${targetArch} ?= " >> "$buildConfigFile" 934 get_variable ${2}_$targetArch | xargs -n 1 echo " " \ 935 >> "$buildConfigFile" 936 echo " ;" >> "$buildConfigFile" 937 shift 2 938 done 939done 940 941 942# Generate a boot strap Jamfile in the output directory. 943 944cat << EOF > $outputDir/Jamfile 945# automatically generated Jamfile 946 947HAIKU_TOP = ${sourceDir} ; 948HAIKU_OUTPUT_DIR = ${outputDir} ; 949 950include [ FDirName \$(HAIKU_TOP) Jamfile ] ; 951 952EOF 953