Add `-fPIE -pie` to the default executable link flags when
`CMAKE_POSITION_INDEPENDENT_CODE` is enabled.  This is required by
Android 16 and above for executables to run on the device.

Closes: #16382

If the toolchain file or cache does not set this, enable it
automatically based on the Android API version.  Versions 16
and above expect position independent code.

Use the main `CMAKE_POSITION_INDEPENDENT_CODE` setting in favor of
hard-coding `-fpic` or `-fPIC` in the compiler flags for each ABI.
This allows CMake to use `-fpie` or `-fPIE` as needed when sources
are meant for executables, and `-fpic` or `-fPIC` for other sources.

See `${ndk}/build/core/default-build-commands.mk` for link flags the NDK
uses for executables.  Add them to our default executable link flags.
Suppress `nocopyreloc` on `arm64-v8a` because it does not work with
some STL types.

Closes: #16380

Add missing "unwind" and "atomic" libraries needed for this combination.
See `${ndk}/sources/cxx-stl/llvm-libc++/libs/armeabi/libc++.a` for the
libraries the NDK uses.

Issue: #16380

The guard added by commit v3.7.0-rc1~229^2~17 (Android: Suppress new
functionality with Nsight Tegra in VS IDE builds, 2016-06-02) to
`Modules/Platform/Android-Determine.cmake` does not work in that
location because `CMAKE_VS_PLATFORM_NAME` is not set until after the
module is loaded.  Change this particular guard to test for the Visual
Studio generator instead.  If in the future we add support for using
Visual Studio for Android without Nsight Tegra then something more will
be needed, but this is good enough for now.

Closes: #16371

Gregor Jasny authored 8 years ago and Brad King committed 8 years ago

The change in commit v3.4.0-rc2~6^2 (Xcode: Adjust deployment target SDK
version to host version, 2015-10-11) does not make sense when
cross-compiling.  Make it conditional to fix this regression in some
cross-compiling cases.

Closes: #16355

Additional include directories are needed for this on some STL types.

Closes: #16350

The Android NDK r13 moved the libc++ include directories.

Closes: #16346

Roman authored 8 years ago and Brad King committed 8 years ago

Update the toolset name matching added by commit v3.6.0-rc1~279^2~10
(VS: in Clang/C2 toolset, setup correct compiler settings, 2016-02-18)
to match VS/LLVM toolset names too.

Per-source copyright/license notice headers that spell out copyright holder
names and years are hard to maintain and often out-of-date or plain wrong.
Precise contributor information is already maintained automatically by the
version control tool.  Ultimately it is the receiver of a file who is
responsible for determining its licensing status, and per-source notices are
merely a convenience.  Therefore it is simpler and more accurate for
each source to have a generic notice of the license name and references to
more detailed information on copyright holders and full license terms.

Our `Copyright.txt` file now contains a list of Contributors whose names
appeared source-level copyright notices.  It also references version control
history for more precise information.  Therefore we no longer need to spell
out the list of Contributors in each source file notice.

Replace CMake per-source copyright/license notice headers with a short
description of the license and links to `Copyright.txt` and online information
available from "https://cmake.org/licensing".  The online URL also handles
cases of modules being copied out of our source into other projects, so we
can drop our notices about replacing links with full license text.

Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority
of the replacements mechanically.  Manually fix up shebang lines and trailing
newlines in a few files.  Manually update the notices in a few files that the
script does not handle.

Starting with Xcode 8 the SDK folder also contains an unversioned
entry:

$ ls -l /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs

drwxr-xr-x  5 root  wheel  170 Mar  4  2018 MacOSX.sdk
lrwxr-xr-x  1 root  wheel   10 Sep 16 20:49 MacOSX10.12.sdk -> MacOSX.sdk

If this unversioned path is used CMake cannot detect the SDK
version. To work around the problem we always invoke the code path
that translates short SDK names like "macosx10.12" into a path.
That way we always end up with a versioned SDK path in
_CMAKE_OSX_SYSROOT_PATH which is later used to determine the version.

Closes: #16323

Use of `-fvisibility=hidden` warns:

  warning: visibility attribute not supported in this configuration; ignored

Allow projects to use `if(ANDROID)` to condition their Android-specific
code paths.

Populate standard include directories and link libraries for the
platform.  Select the STL corresponding to CMAKE_ANDROID_STL_TYPE and
matching the current ABI and toolchain to be used.  Refer to the NDK
sources/cxx-stl/*/Android.mk files for the needed file locations.

Initialize the CMAKE_{C,CXX}_FLAGS{,_<CONFIG>} cache entries with
flags for each ABI as specified by NDK toolchain `setup.mk` files.

Android NDK builds are always `debug` or `release`.  We may populate
flags for these configurations that are needed to produce compatible
binaries.  Ensure they are used by default.

The Android NDK source repository at

  https://android.googlesource.com/platform/ndk.git

has `<ndk>/build/core/toolchains/*/setup.mk` files that store tables of
information for their build system.  Add an equivalent file for each
compiler/abi combination.

Commonly used Android toolchain files that pre-date CMake upstream
support may need to be updated to work with our new functionality.
They typically set CMAKE_SYSTEM_VERSION to 1, so detect that and
skip our upstream Android settings.  When such toolchain files are
updated to account for our upstream support, they can then set
CMAKE_SYSTEM_VERSION to a valid Android API and get new behavior.

Commonly used Android toolchain files that pre-date CMake upstream
support use a few environment and CMake variables as search locations.
Use them too to aid transition.

Compute CMAKE_SYSROOT automatically for the current API and architecture
selection.  This causes the --sysroot option to be passed to GNU and
Clang compilers.

Add new CMakeSystem.cmake entries for the architecture and ABI.
Store the processor in CMAKE_SYSTEM_PROCESSOR.

Store the Android API level in CMAKE_SYSTEM_VERSION.  If it is not
provided by the user, initialize it from CMAKE_ANDROID_API or fall back
to finding the latest available in the NDK.

Add a new CMakeSystem.cmake entry for the NDK location.

Support for NVIDIA Nsight Tegra Visual Studio Edition was previously
implemented in the CMake VS IDE generators.  Avoid interfering with
that functionality for now.  Later we may try to integrate this.

Add infrastructure modules to be loaded when initializing builds
targeting Android platforms.

Add infrastructure modules to be loaded for determining a compiler
selection when targeting Android platforms.

Add infrastructure modules to be loaded for Clang and GNU compilers
when targeting Android platforms.

Closes: #16229

Patrick authored 8 years ago and Brad King committed 8 years ago

Take changes used by pkgsrc [1]:

* so filename versioning requires CMAKE_SHARED_LIBRARY_SONAME_C_FLAG.

[1] http://cdn.netbsd.org/pub/pkgsrc/current/pkgsrc/devel/cmake/patches/

Automate with:

find Modules -type f -print0 | xargs -0 perl -i -0pe \
's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'

Document these variables.

Change our convention for setting these variables from:

    set(CMAKE_EXE_LINKER_FLAGS_INIT "...")

to

    string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " ...")

so that any value previously set by a toolchain file will be used.

Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.

Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.

Document these variables.

Change our convention for setting these variables from:

    set(CMAKE_C_FLAGS_INIT "...")

to

    string(APPEND CMAKE_C_FLAGS_INIT " ...")

so that any value previously set by a toolchain file will be used.

Automate the conversion with:

    sed -i 's/set *(\(CMAKE_\(C\|CXX\|Fortran\|RC\|ASM\|${[^}]\+}\)_FLAGS\(_[^_]\+\)\?_INIT \+"\)/string(APPEND \1 /' \
      Modules/Compiler/*.cmake Modules/Platform/*.cmake

and follow up with some manual fixes (e.g. to cases that already
meant to append).  Also revert the automated changes to contexts
that are not protected from running multiple times.

Migrate from the old `<os>-<cc>.cmake` layout to the modern
`<os>-<id>-<lang>.cmake` layout.  Keep settings common to C and C++ in a
`Windows-OpenWatcom.cmake` helper module with an include blocker.
For now just add both C and CXX settings in the helper module.

Teach `Modules/Platform/Windows-MSVC.cmake` not to use MSVC options
for Fortran.  We use the `__windows_compiler_msvc` for the Intel
Fortran compiler on Windows for other settings, but we do not want
the flags.

Previously this worked only because the options were later overridden
by `Modules/Platform/Windows-Intel*.cmake`, but it is cleaner to not
set the options in the first place.