At some point in the future, we may consider using LTO on the runtime/standard
library, but right now is not that time. We are just trying to use LTO to
improve the compile time performance of the compiler itself.
rdar://24717107
*NOTE* We are still passing this variable into LLVM. Just not into Swift anymore.
I originally passed in the variable -DLLVM_ENABLE_LTO=YES to Swift's cmake to
ensure that the Swift unittests were compiled with lto. That was the wrong
fix.
The reason why is that if -DLLVM_ENABLE_LTO is set to YES then HandleLLVMOptions
in llvm will append -flto to both CMAKE_C_FLAGS and CMAKE_CXX_FLAGS implying
that -flto can not be disabled selectively. This ability to disable flto
selectively is something that we need in order to lto host libraries, but not
lto target libraries.
Thus in this commit, we no longer pass in -DLLVM_ENABLE_LTO=YES to swift's cmake
invocation. Instead we apply the lto flag to the unittest target ourselves in
add_swift_unittest.
rdar://24717107
This adds support for running tests for the stdlib built
for Android, both on the host machine and on an Android device.
The Android variant of Swift may be built and tested using
the following `build-script` invocation:
```
$ utils/build-script \
-R \ # Build in ReleaseAssert mode.
-T \ # Run all tests.
--android \ # Build for Android.
--android-deploy-device-path /data/local/tmp \ # Temporary directory on the device where Android tests are run.
--android-ndk ~/android-ndk-r10e \ # Path to an Android NDK.
--android-ndk-version 21 \
--android-icu-uc ~/libicu-android/armeabi-v7a/libicuuc.so \
--android-icu-uc-include ~/libicu-android/armeabi-v7a/icu/source/common \
--android-icu-i18n ~/libicu-android/armeabi-v7a/libicui18n.so \
--android-icu-i18n-include ~/libicu-android/armeabi-v7a/icu/source/i18n/
```
See docs/Testing.rst for more details.
- Introduces a new `HostSpecificConfiguration` which holds the computed
information for each host we need to use.
- This relies on the functionality to pass host-specific variables to the
script via environment variables.
- The computation itself has been cleaned up a tiny bit (mostly via using
the factored out platform/target properties), but is otherwise a straight
port of the logic from `build-script-impl`.
- This commit does not yet remove that code from `build-script-impl`; instead
it validates that the two implementations are computing the same result.
This is useful right now for testing the validity of the port.
- This isn't yet used, but we need an easy way for `build-script` to
pass host-specific variables down to `build-script-impl`.
- I don't think it is worth complicating the main argument parsing
logic with a syntax for passing associative arrays on the command
line, so this just passes them via environment variables.
- Part of SR-237.
Use the clang that is part of the toolchain being built
when building libdispatch to ensure getting the appropriate
version of clang.
Also pass through SWIFTC_BIN to the configure command to
prepare for a cleanup of the libdispatch side of the build process.
The reason to do this is the same reason that we already pass in
-DLLVM_ENABLE_LTO=YES to swift, to ensure that parts of our codebase that use
the llvm build machinery (e.g. the unittests) do not use too many linker jobs
given the memory constraints of a given machine.
rdar://24717107
- This adds a new argument `--only-execute <name>` which can be used by
`build-script` to invoke the `build-script-impl` to perform each different
action, while moving the high-level operation loop into the `build-script`
itself. This should make incremental refactoring of the individual actions
into `build-script` easier.
- This is part of SR-237.
- It turns out that just this function by itself has a significant impact on
the runtime of the `build-script-impl` when it is being invoked many times by
the `build-script` (as I intend to do as part of SR-237).
- The current behavior of mapping via `tr` was very slow when called over and
over for each option. This matters for SR-237 where I would like
`build-script` to take over the top-level build process control loop, which
involves executing `build-script-impl` multiple times.
- This patch optimizes the lookup in two ways:
1. It does the setting to variable conversion in a single pass, for all
options at once.
2. It builds a cache of the setting to variable name conversion (as an
exploded associate array), and uses that when doing variable assignment.
- This patch speeds up `build-script-impl --dry-run` by 2x on one test case.
If -n or --dry-run is specified in command line arguments, print the commands
that would be executed to stdout, but do not execute them.
Supported in build-script and build-toolchain.
utils/build-script -n -Rt
utils/build-script -n --preset=buildbot_incremental,tools=RA,stdlib=RA
utils/build-toolchain -n local.swift
- Use consistent terminology for target platforms, disambiguate uses of
'deployment_target' in to 'host' and 'stdlib_targets'
- Changed parameters to build script:
- install-prefix no longer has to include toolchain-prefix on OSX
- swift-sdks has been replaced by stdlib-deployment-targets
- built-stdlib-deployment-targets lets you restrict which of the
stdlib-deployment targets are built
- Calculate stdlib_targets per host, to facilitate future cross-compiling
- Only use executables from LOCAL_HOST
- Only execute testable targets of the LOCAL_HOST
- Remove some cases of switching on 'uname' to facilitate future
cross-compiling
- This should fix possible issues with the test outputs being in a shared
directory on CI machines running concurrent builds.
- https://bugs.swift.org/browse/SR-1628
When we are building LLVM create symlinks to the c++ headers. We need to do this
before building LLVM since compiler-rt depends on being built with the just
built clang compiler. These are normally put into place during the cmake step of
LLVM's build when libcxx is in tree... but we are not building llvm with libcxx
in tree when we build swift. So we need to do cmake's work here.
rdar://26284108
It seems that distcc --randomize is causing cmake to invoke configuration
commands on remote machines. This is slow. Instead, just use the localhost host
when running cmake.
The rest of the build is distributed as normal.
A script checks if the output object file is written only once even if the compiler is invoked multiple times.
The main purpose of this check is to ensure that the compiler is deterministic (until IRGen).
Otherwise, we run into an issue with certain clangs and linking in libc++. libc++
in certain clangs require a minimum deployment target of at least 10.7.
I have not investigated further since I am trying to make progress on the
branching scheme.
rdar://26081474
(cherry picked from commit 2a27443f3ee63cc55e952e4cfb43c24661c4b7ca)
