Build_Release:
_BuildConfig: Release
_BuildArch: x64
- _PublishArtifacts: bin/Linux.x64.Release
+ _PublishArtifacts: bin/linux.x64.Release
${{ if in(variables['Build.Reason'], 'PullRequest') }}:
Build_Debug:
_BuildConfig: Debug
_BuildArch: x64
- _PublishArtifacts: bin/Linux.x64.Debug
+ _PublishArtifacts: bin/linux.x64.Debug
- template: /eng/pipelines/build.yml
parameters:
Build_Release:
_BuildConfig: Release
_BuildArch: x64
- _PublishArtifacts: bin/Linux.x64.Release
- _ArtifactsTargetPath: bin/Linux-musl.x64.Release
+ _PublishArtifacts: bin/linux.x64.Release
+ _ArtifactsTargetPath: bin/linux-musl.x64.Release
${{ if in(variables['Build.Reason'], 'PullRequest') }}:
Build_Debug:
_BuildConfig: Debug
_BuildArch: x64
- _PublishArtifacts: bin/Linux.x64.Debug
- _ArtifactsTargetPath: bin/Linux-musl.x64.Debug
+ _PublishArtifacts: bin/linux.x64.Debug
+ _ArtifactsTargetPath: bin/linux-musl.x64.Debug
- template: /eng/pipelines/build.yml
parameters:
Build_Release:
_BuildConfig: Release
_BuildArch: x64
- _PublishArtifacts: bin/OSX.x64.Release
+ _PublishArtifacts: bin/osx.x64.Release
${{ if in(variables['Build.Reason'], 'PullRequest') }}:
Build_Debug:
_BuildConfig: Debug
Build_Release:
_BuildConfig: Release
_BuildArch: arm64
- _PublishArtifacts: bin/OSX.arm64.Release
+ _PublishArtifacts: bin/osx.arm64.Release
${{ if in(variables['Build.Reason'], 'PullRequest') }}:
Build_Debug:
_BuildConfig: Debug
Build_Release:
_BuildConfig: Release
_BuildArch: arm
- _PublishArtifacts: bin/Linux.arm.Release
+ _PublishArtifacts: bin/linux.arm.Release
- template: /eng/pipelines/build.yml
parameters:
Build_Release:
_BuildConfig: Release
_BuildArch: arm64
- _PublishArtifacts: bin/Linux.arm64.Release
+ _PublishArtifacts: bin/linux.arm64.Release
- template: /eng/pipelines/build.yml
parameters:
Build_Release:
_BuildConfig: Release
_BuildArch: arm
- _PublishArtifacts: bin/Linux.arm.Release
- _ArtifactsTargetPath: bin/Linux-musl.arm.Release
+ _PublishArtifacts: bin/linux.arm.Release
+ _ArtifactsTargetPath: bin/linux-musl.arm.Release
- template: /eng/pipelines/build.yml
parameters:
Build_Release:
_BuildConfig: Release
_BuildArch: arm64
- _PublishArtifacts: bin/Linux.arm64.Release
- _ArtifactsTargetPath: bin/Linux-musl.arm64.Release
+ _PublishArtifacts: bin/linux.arm64.Release
+ _ArtifactsTargetPath: bin/linux-musl.arm64.Release
############################
# #
# Obtain the location of the bash script to figure out where the root of the repo is.
__RepoRootDir="$(cd "$(dirname "$0")"/..; pwd -P)"
-__BuildArch=x64
__BuildType=Debug
__CMakeArgs=
__CommonMSBuildArgs=
__DotnetRuntimeDownloadVersion="default"
__DotnetRuntimeVersion="default"
__ExtraCmakeArgs=
-__HostArch=x64
-__HostOS=Linux
__IsMSBuildOnNETCoreSupported=0
__ManagedBuild=1
__ManagedBuildArgs=
__RuntimeSourceFeedKey=
__SkipConfigure=0
__SkipGenerateVersion=0
-__TargetOS=Linux
__Test=0
__UnprocessedBuildArgs=
lowerI="$(echo "${1/--/-}" | tr "[:upper:]" "[:lower:]")"
case "$lowerI" in
architecture|-architecture|-a)
- __BuildArch="$(echo "$2" | tr "[:upper:]" "[:lower:]")"
+ __TargetArch="$(echo "$2" | tr "[:upper:]" "[:lower:]")"
__ShiftArgs=1
;;
source "$__RepoRootDir"/eng/native/build-commons.sh
__LogsDir="$__RootBinDir/log/$__BuildType"
-__ConfigTriplet="$__TargetOS.$__BuildArch.$__BuildType"
+__ConfigTriplet="$__TargetOS.$__TargetArch.$__BuildType"
__BinDir="$__RootBinDir/bin/$__ConfigTriplet"
__ArtifactsIntermediatesDir="$__RootBinDir/obj"
__IntermediatesDir="$__ArtifactsIntermediatesDir/$__ConfigTriplet"
export __CMakeBinDir="$__BinDir"
-if [[ "$__BuildArch" == "armel" ]]; then
+if [[ "$__TargetArch" == "armel" ]]; then
# Armel cross build is Tizen specific and does not support Portable RID build
__PortableBuild=0
fi
/p:GenerateVersionSourceFile=true \
/p:NativeVersionSourceFile="$__ArtifactsIntermediatesDir/_version.c" \
/p:Configuration="$__BuildType" \
- /p:Platform="$__BuildArch" \
+ /p:Platform="$__TargetArch" \
$__UnprocessedBuildArgs
if [ $? != 0 ]; then
fi
fi
-#
-# Initialize the target distro name
-#
-
-initTargetDistroRid
-
-echo "RID: $__DistroRid"
-
#
# Setup LLDB paths for native build
#
-if [ "$__HostOS" == "OSX" ]; then
+if [ "$__HostOS" == "osx" ]; then
export LLDB_H="$__RepoRootDir"/src/SOS/lldbplugin/swift-4.0
export LLDB_LIB=$(xcode-select -p)/../SharedFrameworks/LLDB.framework/LLDB
export LLDB_PATH=$(xcode-select -p)/usr/bin/lldb
which python
python --version
- if [[ "$__BuildArch" == x64 ]]; then
+ if [[ "$__TargetArch" == x64 ]]; then
__ExtraCmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"x86_64\" $__ExtraCmakeArgs"
- elif [[ "$__BuildArch" == arm64 ]]; then
+ elif [[ "$__TargetArch" == arm64 ]]; then
__ExtraCmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $__ExtraCmakeArgs"
else
- echo "Error: Unknown OSX architecture $__BuildArch."
+ echo "Error: Unknown OSX architecture $__TargetArch."
exit 1
fi
fi
# Build native components
#
if [[ "$__NativeBuild" == 1 ]]; then
- build_native "$__TargetOS" "$__BuildArch" "$__RepoRootDir" "$__IntermediatesDir" "install" "$__ExtraCmakeArgs" "diagnostic component" | tee "$__LogsDir"/make.log
+ build_native "$__TargetOS" "$__TargetArch" "$__RepoRootDir" "$__IntermediatesDir" "install" "$__ExtraCmakeArgs" "diagnostic component" | tee "$__LogsDir"/make.log
if [ "$?" != 0 ]; then
echo "Native build FAILED"
if [[ "$__NativeBuild" == 1 || "$__Test" == 1 ]]; then
__targetRid=net6.0
- __dotnet_sos=$__RootBinDir/bin/dotnet-sos/$__BuildType/$__targetRid/publish/$__DistroRid
- __dotnet_dump=$__RootBinDir/bin/dotnet-dump/$__BuildType/$__targetRid/publish/$__DistroRid
+ __dotnet_sos=$__RootBinDir/bin/dotnet-sos/$__BuildType/$__targetRid/publish/$__OutputRid
+ __dotnet_dump=$__RootBinDir/bin/dotnet-dump/$__BuildType/$__targetRid/publish/$__OutputRid
mkdir -p "$__dotnet_sos"
mkdir -p "$__dotnet_dump"
--test \
--configuration "$__BuildType" \
/bl:"$__LogsDir"/Test.binlog \
- /p:BuildArch="$__BuildArch" \
+ /p:BuildArch="$__TargetArch" \
/p:PrivateBuildPath="$__PrivateBuildPath" \
/p:DotnetRuntimeVersion="$__DotnetRuntimeVersion" \
/p:DotnetRuntimeDownloadVersion="$__DotnetRuntimeDownloadVersion" \
initTargetDistroRid()
{
- source "$__RepoRootDir/eng/native/init-distro-rid.sh"
+ source "$__RepoRootDir/eng/common/native/init-distro-rid.sh"
local passedRootfsDir=""
# Only pass ROOTFS_DIR if cross is specified and the target platform is not Darwin that doesn't use rootfs
- if [[ "$__CrossBuild" == 1 && "$platform" != "Darwin" ]]; then
+ if [[ "$__CrossBuild" == 1 && "$platform" != "darwin" ]]; then
passedRootfsDir="$ROOTFS_DIR"
fi
- initDistroRidGlobal "$__TargetOS" "$__TargetArch" "$__PortableBuild" "$passedRootfsDir"
+ initDistroRidGlobal "$__TargetOS" "$__TargetArch" "$passedRootfsDir"
}
setup_dirs()
{
echo "Checking prerequisites..."
- if [[ "$__HostOS" == "OSX" ]]; then
+ if [[ "$__HostOS" == "osx" ]]; then
# Check presence of pkg-config on the path
command -v pkg-config 2>/dev/null || { echo >&2 "Please install pkg-config before running this script, see https://github.com/dotnet/runtime/blob/main/docs/workflow/requirements/macos-requirements.md"; exit 1; }
# All set to commence the build
echo "Commencing build of \"$target\" target in \"$message\" for $__TargetOS.$__TargetArch.$__BuildType in $intermediatesDir"
- if [[ "$targetOS" == OSX || "$targetOS" == MacCatalyst ]]; then
+ if [[ "$targetOS" == osx || "$targetOS" == maccatalyst ]]; then
if [[ "$hostArch" == x64 ]]; then
cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"x86_64\" $cmakeArgs"
elif [[ "$hostArch" == arm64 ]]; then
fi
fi
- if [[ "$targetOS" == MacCatalyst ]]; then
- cmakeArgs="-DCMAKE_SYSTEM_VARIANT=MacCatalyst $cmakeArgs"
+ if [[ "$targetOS" == maccatalyst ]]; then
+ cmakeArgs="-DCMAKE_SYSTEM_VARIANT=maccatalyst $cmakeArgs"
fi
- if [[ ( "$targetOS" == Android || "$targetOS" == linux-bionic ) && -z "$ROOTFS_DIR" ]]; then
+ if [[ "$targetOS" == android || "$targetOS" == linux-bionic ]]; then
if [[ -z "$ANDROID_NDK_ROOT" ]]; then
echo "Error: You need to set the ANDROID_NDK_ROOT environment variable pointing to the Android NDK root."
exit 1
fi
- # keep ANDROID_PLATFORM in sync with src/mono/Directory.Build.props
+ cmakeArgs="-C $__RepoRootDir/eng/native/tryrun.cmake $cmakeArgs"
+
+ # keep ANDROID_PLATFORM in sync with SetOSTargetMinVersions in the root Directory.Build.props
cmakeArgs="-DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=android-21 $cmakeArgs"
# Don't try to set CC/CXX in init-compiler.sh - it's handled in android.toolchain.cmake already
echo "Error: Unknown Android architecture $hostArch."
exit 1
fi
+ elif [[ "$targetOS" == iossimulator ]]; then
+ cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+
+ # set default iOS simulator deployment target
+ # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
+ cmakeArgs="-DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphonesimulator -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 $cmakeArgs"
+ if [[ "$__TargetArch" == x64 ]]; then
+ cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"x86_64\" $cmakeArgs"
+ elif [[ "$__TargetArch" == arm64 ]]; then
+ cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+ else
+ echo "Error: Unknown iOS Simulator architecture $__TargetArch."
+ exit 1
+ fi
+ elif [[ "$targetOS" == ios ]]; then
+ cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+
+ # set default iOS device deployment target
+ # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
+ cmakeArgs="-DCMAKE_SYSTEM_NAME=iOS -DCMAKE_OSX_SYSROOT=iphoneos -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 $cmakeArgs"
+ if [[ "$__TargetArch" == arm64 ]]; then
+ cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+ else
+ echo "Error: Unknown iOS architecture $__TargetArch."
+ exit 1
+ fi
+ elif [[ "$targetOS" == tvossimulator ]]; then
+ cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+
+ # set default tvOS simulator deployment target
+ # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
+ cmakeArgs="-DCMAKE_SYSTEM_NAME=tvOS -DCMAKE_OSX_SYSROOT=appletvsimulator -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 $cmakeArgs"
+ if [[ "$__TargetArch" == x64 ]]; then
+ cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"x86_64\" $cmakeArgs"
+ elif [[ "$__TargetArch" == arm64 ]]; then
+ cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+ else
+ echo "Error: Unknown tvOS Simulator architecture $__TargetArch."
+ exit 1
+ fi
+ elif [[ "$targetOS" == tvos ]]; then
+ cmakeArgs="-C $__RepoRootDir/eng/native/tryrun_ios_tvos.cmake $cmakeArgs"
+
+ # set default tvOS device deployment target
+ # keep in sync with SetOSTargetMinVersions in the root Directory.Build.props
+ cmakeArgs="-DCMAKE_SYSTEM_NAME=tvOS -DCMAKE_OSX_SYSROOT=appletvos -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 $cmakeArgs"
+ if [[ "$__TargetArch" == arm64 ]]; then
+ cmakeArgs="-DCMAKE_OSX_ARCHITECTURES=\"arm64\" $cmakeArgs"
+ else
+ echo "Error: Unknown tvOS architecture $__TargetArch."
+ exit 1
+ fi
fi
if [[ "$__UseNinja" == 1 ]]; then
popd
else
cmake_command=cmake
- if [[ "$build_arch" == "wasm" && "$__TargetOS" == "Browser" ]]; then
+ if [[ "$build_arch" == "wasm" && "$__TargetOS" == "browser" ]]; then
cmake_command="emcmake cmake"
echo "Executing $cmake_command --build \"$intermediatesDir\" --target $target -- -j $__NumProc"
$cmake_command --build "$intermediatesDir" --target $target -- -j "$__NumProc"
echo "-portablebuild: pass -portablebuild=false to force a non-portable build."
echo "-skipconfigure: skip build configuration."
echo "-keepnativesymbols: keep native/unmanaged debug symbols."
+ echo "-fsanitize: Enable native sanitizers"
echo "-verbose: optional argument to enable verbose build output."
echo ""
echo "Additional Options:"
__TargetArch=$arch
__TargetOS=$os
-__HostOS=$os
-__BuildOS=$os
__OutputRid=''
# Get the number of processors available to the scheduler
-platform="$(uname)"
-if [[ "$platform" == "FreeBSD" ]]; then
+platform="$(uname -s | tr '[:upper:]' '[:lower:]')"
+if [[ "$platform" == "freebsd" ]]; then
__NumProc="$(($(sysctl -n hw.ncpu)+1))"
-elif [[ "$platform" == "NetBSD" || "$platform" == "SunOS" ]]; then
+elif [[ "$platform" == "netbsd" || "$platform" == "sunos" ]]; then
__NumProc="$(($(getconf NPROCESSORS_ONLN)+1))"
-elif [[ "$platform" == "Darwin" ]]; then
+elif [[ "$platform" == "darwin" ]]; then
__NumProc="$(($(getconf _NPROCESSORS_ONLN)+1))"
elif command -v nproc > /dev/null 2>&1; then
__NumProc="$(nproc)"
__CMakeArgs="$__CMakeArgs -DCLR_CMAKE_KEEP_NATIVE_SYMBOLS=true"
;;
+ -fsanitize)
+ __CMakeArgs="$__CMakeArgs -DCLR_CMAKE_ENABLE_SANITIZERS=$2"
+ EnableNativeSanitizers=$2
+ shift
+ ;;
+ -fsanitize=*)
+ sanitizers="${lowerI/#-fsanitize=/}" # -fsanitize=address => address
+ __CMakeArgs="$__CMakeArgs -DCLR_CMAKE_ENABLE_SANITIZERS=$sanitizers"
+ EnableNativeSanitizers=$sanitizers
+ ;;
+
ninja|-ninja)
__UseNinja=1
;;
os|-os)
if [[ -n "$2" ]]; then
- __TargetOS="$2"
+ __TargetOS=$(echo "$2" | tr '[:upper:]' '[:lower:]')
shift
else
echo "ERROR: 'os' requires a non-empty option argument"
hostarch|-hostarch)
if [[ -n "$2" ]]; then
__HostArch="$2"
+ __ExplicitHostArch=1
shift
else
echo "ERROR: 'hostarch' requires a non-empty option argument"
fi
;;
+ hostos|-hostos)
+ if [[ -n "$2" ]]; then
+ __HostOS="$2"
+ shift
+ else
+ echo "ERROR: 'hostos' requires a non-empty option argument"
+ exit 1
+ fi
+ ;;
+
*)
handle_arguments "$1" "$2"
if [[ "$__ShiftArgs" == 1 ]]; then
__HostArch=$__TargetArch
fi
+if [[ -z "$__HostOS" ]]; then
+ __HostOS=$__TargetOS
+fi
+
__CommonMSBuildArgs="/p:TargetArchitecture=$__TargetArch /p:Configuration=$__BuildType /p:TargetOS=$__TargetOS /nodeReuse:false $__OfficialBuildIdArg $__SignTypeArg $__SkipRestoreArg"
# Configure environment if we are doing a verbose build
if [[ "$__TargetArch" == wasm ]]; then
# nothing to do here
true
-elif [[ "$__TargetOS" == iOS || "$__TargetOS" == iOSSimulator ]]; then
+elif [[ "$__TargetOS" == ios || "$__TargetOS" == iossimulator ]]; then
# nothing to do here
true
-elif [[ "$__TargetOS" == tvOS || "$__TargetOS" == tvOSSimulator ]]; then
+elif [[ "$__TargetOS" == tvos || "$__TargetOS" == tvossimulator ]]; then
# nothing to do here
true
-elif [[ "$__TargetOS" == Android ]]; then
+elif [[ "$__TargetOS" == android ]]; then
# nothing to do here
true
else
CROSSCOMPILE=1
export CROSSCOMPILE
# Darwin that doesn't use rootfs
- if [[ -z "$ROOTFS_DIR" && "$platform" != "Darwin" ]]; then
+ if [[ -z "$ROOTFS_DIR" && "$platform" != "darwin" ]]; then
ROOTFS_DIR="$__RepoRootDir/.tools/rootfs/$__TargetArch"
export ROOTFS_DIR
fi
fi
-# init the target distro name
+# init the target distro name (__DistroRid) and target portable os (__PortableTargetOS).
initTargetDistroRid
-
if [ -z "$__OutputRid" ]; then
- __OutputRid="$(echo $__DistroRid | tr '[:upper:]' '[:lower:]')"
+ if [[ "$__PortableBuild" == 0 ]]; then
+ __OutputRid="$__DistroRid"
+ else
+ __OutputRid="$__PortableTargetOS-$__TargetArch"
+ fi
fi
+export __OutputRid
+echo "__OutputRid: ${__OutputRid}"
+
+# When the host runs on an unknown rid, it falls back to the output rid
+__HostFallbackOS="${__OutputRid%-*}" # Strip architecture
+# Due to how we build the libraries native build as part of the CoreCLR build as well as standalone,
+# we can end up coming to this file twice. Only run it once to simplify our build.
+include_guard()
+
include(${CMAKE_CURRENT_LIST_DIR}/configuretools.cmake)
# Set initial flags for each configuration
#-----------------------------------------------------
if (CLR_CMAKE_HOST_UNIX)
- add_compile_options(-g)
add_compile_options(-Wall)
if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
add_compile_options(-Wno-null-conversion)
+ add_compile_options(-glldb)
else()
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Werror=conversion-null>)
+ add_compile_options(-g)
endif()
endif()
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /PDBCOMPRESS")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG")
+ set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUGTYPE:CV,FIXUP")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /IGNORE:4197,4013,4254,4070,4221")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SUBSYSTEM:WINDOWS,${WINDOWS_SUBSYSTEM_VERSION}")
set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /IGNORE:4221")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG")
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUGTYPE:CV,FIXUP")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /PDBCOMPRESS")
- set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:1572864")
+ # For sanitized builds, we bump up the stack size to 8MB to match behavior on Unix platforms.
+ # Sanitized builds can use significantly more stack space than non-sanitized builds due to instrumentation.
+ # We don't want to change the default stack size for all builds, as that will likely cause confusion and will
+ # increase memory usage.
+ if (CLR_CMAKE_ENABLE_SANITIZERS)
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:0x800000")
+ else()
+ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:0x180000")
+ endif()
if(EXISTS ${CLR_SOURCELINK_FILE_PATH})
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /sourcelink:${CLR_SOURCELINK_FILE_PATH}")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /sourcelink:${CLR_SOURCELINK_FILE_PATH}")
endif(EXISTS ${CLR_SOURCELINK_FILE_PATH})
+ if (CMAKE_GENERATOR MATCHES "^Visual Studio.*$")
+ # Debug build specific flags
+ # The Ninja generator doesn't appear to have the default `/INCREMENTAL:ON` that
+ # the Visual Studio generator has. Therefore we will override the default for Visual Studio only.
+ add_linker_flag(/INCREMENTAL:NO DEBUG)
+ add_linker_flag(/OPT:REF DEBUG)
+ add_linker_flag(/OPT:NOICF DEBUG)
+ endif (CMAKE_GENERATOR MATCHES "^Visual Studio.*$")
+
# Checked build specific flags
add_linker_flag(/INCREMENTAL:NO CHECKED) # prevent "warning LNK4075: ignoring '/INCREMENTAL' due to '/OPT:REF' specification"
add_linker_flag(/OPT:REF CHECKED)
add_linker_flag(/OPT:ICF RELWITHDEBINFO)
set(CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
- # Force uCRT to be dynamically linked for Release build
- add_linker_flag(/NODEFAULTLIB:libucrt.lib RELEASE)
- add_linker_flag(/DEFAULTLIB:ucrt.lib RELEASE)
-
elseif (CLR_CMAKE_HOST_UNIX)
# Set the values to display when interactively configuring CMAKE_BUILD_TYPE
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "DEBUG;CHECKED;RELEASE;RELWITHDEBINFO")
# Use uppercase CMAKE_BUILD_TYPE for the string comparisons below
string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_CMAKE_BUILD_TYPE)
- set(CLR_SANITIZE_CXX_OPTIONS "")
- set(CLR_SANITIZE_LINK_OPTIONS "")
-
- # set the CLANG sanitizer flags for debug build
- if(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
- # obtain settings from running enablesanitizers.sh
- string(FIND "$ENV{DEBUG_SANITIZERS}" "asan" __ASAN_POS)
- string(FIND "$ENV{DEBUG_SANITIZERS}" "ubsan" __UBSAN_POS)
- if ((${__ASAN_POS} GREATER -1) OR (${__UBSAN_POS} GREATER -1))
- list(APPEND CLR_SANITIZE_CXX_OPTIONS -fsanitize-blacklist=${CMAKE_CURRENT_SOURCE_DIR}/sanitizerblacklist.txt)
- set (CLR_CXX_SANITIZERS "")
- set (CLR_LINK_SANITIZERS "")
- if (${__ASAN_POS} GREATER -1)
- list(APPEND CLR_CXX_SANITIZERS address)
- list(APPEND CLR_LINK_SANITIZERS address)
- set(CLR_SANITIZE_CXX_FLAGS "${CLR_SANITIZE_CXX_FLAGS}address,")
- set(CLR_SANITIZE_LINK_FLAGS "${CLR_SANITIZE_LINK_FLAGS}address,")
- add_definitions(-DHAS_ASAN)
- message("Address Sanitizer (asan) enabled")
- endif ()
- if (${__UBSAN_POS} GREATER -1)
- # all sanitizer flags are enabled except alignment (due to heavy use of __unaligned modifier)
- list(APPEND CLR_CXX_SANITIZERS
- "bool"
- bounds
- enum
- float-cast-overflow
- float-divide-by-zero
- "function"
- integer
- nonnull-attribute
- null
- object-size
- "return"
- returns-nonnull-attribute
- shift
- unreachable
- vla-bound
- vptr)
- list(APPEND CLR_LINK_SANITIZERS
- undefined)
- message("Undefined Behavior Sanitizer (ubsan) enabled")
- endif ()
- list(JOIN CLR_CXX_SANITIZERS "," CLR_CXX_SANITIZERS_OPTIONS)
- list(APPEND CLR_SANITIZE_CXX_OPTIONS "-fsanitize=${CLR_CXX_SANITIZERS_OPTIONS}")
- list(JOIN CLR_LINK_SANITIZERS "," CLR_LINK_SANITIZERS_OPTIONS)
- list(APPEND CLR_SANITIZE_LINK_OPTIONS "-fsanitize=${CLR_LINK_SANITIZERS_OPTIONS}")
-
- # -O1: optimization level used instead of -O0 to avoid compile error "invalid operand for inline asm constraint"
- add_compile_options("$<$<OR:$<CONFIG:DEBUG>,$<CONFIG:CHECKED>>:${CLR_SANITIZE_CXX_OPTIONS};-fdata-sections;-O1>")
- add_linker_flag("${CLR_SANITIZE_LINK_OPTIONS}" DEBUG CHECKED)
- # -Wl and --gc-sections: drop unused sections\functions (similar to Windows /Gy function-level-linking)
- add_linker_flag("-Wl,--gc-sections" DEBUG CHECKED)
- endif ()
- endif(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
-
- if(CLR_CMAKE_HOST_BROWSER)
+ if(CLR_CMAKE_HOST_BROWSER OR CLR_CMAKE_HOST_WASI)
# The emscripten build has additional warnings so -Werror breaks
add_compile_options(-Wno-unused-parameter)
add_compile_options(-Wno-alloca)
endif()
endif(MSVC)
+if (CLR_CMAKE_ENABLE_SANITIZERS)
+ set (CLR_CMAKE_BUILD_SANITIZERS "")
+ set (CLR_CMAKE_SANITIZER_RUNTIMES "")
+ string(FIND "${CLR_CMAKE_ENABLE_SANITIZERS}" "address" __ASAN_POS)
+ if(${__ASAN_POS} GREATER -1)
+ # Set up build flags for AddressSanitizer
+ set (CLR_CMAKE_ENABLE_ASAN ON)
+ if (MSVC)
+ # /RTC1 is added by default by CMake and incompatible with ASAN, so remove it.
+ string(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+ string(REPLACE "/RTC1" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+ string(REPLACE "/RTC1" "" CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
+ string(REPLACE "/RTC1" "" CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
+ endif()
+ # For Mac and Windows platforms, we install the ASAN runtime next to the rest of our outputs to ensure that it's present when we execute our tests on Helix machines
+ # The rest of our platforms use statically-linked ASAN so this isn't a concern for those platforms.
+ if (CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_MACCATALYST)
+ function(getSanitizerRuntimeDirectory output)
+ enable_language(C)
+ execute_process(
+ COMMAND ${CMAKE_C_COMPILER} -print-resource-dir
+ OUTPUT_VARIABLE compilerResourceDir
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+ set(${output} "${compilerResourceDir}/lib/darwin/" PARENT_SCOPE)
+ endfunction()
+ getSanitizerRuntimeDirectory(sanitizerRuntimeDirectory)
+ find_library(ASAN_RUNTIME clang_rt.asan_osx_dynamic PATHS ${sanitizerRuntimeDirectory})
+ add_compile_definitions(SANITIZER_SHARED_RUNTIME)
+ elseif (CLR_CMAKE_TARGET_WIN32)
+ function(getSanitizerRuntimeDirectory output archSuffixOutput)
+ get_filename_component(compiler_directory "${CMAKE_C_COMPILER}" DIRECTORY)
+ set(${output} "${compiler_directory}" PARENT_SCOPE)
+ if (CLR_CMAKE_TARGET_ARCH_I386)
+ set(${archSuffixOutput} "i386" PARENT_SCOPE)
+ elseif (CLR_CMAKE_TARGET_ARCH_AMD64)
+ set(${archSuffixOutput} "x86_64" PARENT_SCOPE)
+ elseif (CLR_CMAKE_TARGET_ARCH_ARM)
+ set(${archSuffixOutput} "armhf" PARENT_SCOPE)
+ elseif (CLR_CMAKE_TARGET_ARCH_ARM64)
+ set(${archSuffixOutput} "aarch64" PARENT_SCOPE)
+ endif()
+ endfunction()
+ getSanitizerRuntimeDirectory(sanitizerRuntimeDirectory archSuffix)
+ set(ASAN_RUNTIME "${sanitizerRuntimeDirectory}/clang_rt.asan_dynamic-${archSuffix}.dll")
+ add_compile_definitions(SANITIZER_SHARED_RUNTIME)
+ endif()
+ if (CLR_CMAKE_ENABLE_ASAN)
+ message("-- Address Sanitizer (asan) enabled")
+ list(APPEND CLR_CMAKE_BUILD_SANITIZERS
+ address)
+ list(APPEND CLR_CMAKE_SANITIZER_RUNTIMES
+ address)
+ # We can't use preprocessor defines to determine if we're building with ASAN in assembly, so we'll
+ # define the preprocessor define ourselves.
+ add_compile_definitions($<$<COMPILE_LANGUAGE:ASM,ASM_MASM>:HAS_ADDRESS_SANITIZER>)
+
+ # Disable the use-after-return check for ASAN on Clang. This is because we have a lot of code that
+ # depends on the fact that our locals are not saved in a parallel stack, so we can't enable this today.
+ # If we ever have a way to detect a parallel stack and track its bounds, we can re-enable this check.
+ add_compile_options($<$<COMPILE_LANG_AND_ID:C,Clang>:-fsanitize-address-use-after-return=never>)
+ add_compile_options($<$<COMPILE_LANG_AND_ID:CXX,Clang>:-fsanitize-address-use-after-return=never>)
+ endif()
+ endif()
+
+ # Set up build flags for UBSanitizer
+ if (CLR_CMAKE_HOST_UNIX)
+
+ set (CLR_CMAKE_ENABLE_UBSAN OFF)
+ # COMPAT: Allow enabling UBSAN in Debug/Checked builds via an environment variable.
+ if(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
+ # obtain settings from running enablesanitizers.sh
+ string(FIND "$ENV{DEBUG_SANITIZERS}" "ubsan" __UBSAN_ENV_POS)
+ if (${__UBSAN_ENV_POS} GREATER -1)
+ set(CLR_CMAKE_ENABLE_UBSAN ON)
+ endif()
+ endif()
+ string(FIND "${CLR_CMAKE_ENABLE_SANITIZERS}" "undefined" __UBSAN_POS)
+ if (${__UBSAN_POS} GREATER -1)
+ set(CLR_CMAKE_ENABLE_UBSAN ON)
+ endif()
+
+ # set the CLANG sanitizer flags for debug build
+ if(CLR_CMAKE_ENABLE_UBSAN)
+ list(APPEND CLR_CMAKE_BUILD_SANITIZE_OPTIONS -fsanitize-ignorelist=${CMAKE_CURRENT_SOURCE_DIR}/sanitizer-ignorelist.txt)
+ # all sanitizer flags are enabled except alignment (due to heavy use of __unaligned modifier)
+ list(APPEND CLR_CMAKE_BUILD_SANITIZERS
+ "bool"
+ bounds
+ enum
+ float-cast-overflow
+ float-divide-by-zero
+ "function"
+ integer
+ nonnull-attribute
+ null
+ object-size
+ "return"
+ returns-nonnull-attribute
+ shift
+ unreachable
+ vla-bound
+ vptr)
+ list(APPEND CLR_CMAKE_SANITIZER_RUNTIMES
+ undefined)
+ message("-- Undefined Behavior Sanitizer (ubsan) enabled")
+ endif ()
+ endif()
+ list(JOIN CLR_CMAKE_BUILD_SANITIZERS "," CLR_CMAKE_BUILD_SANITIZERS)
+ list(JOIN CLR_CMAKE_SANITIZER_RUNTIMES "," CLR_LINK_SANITIZERS_OPTIONS)
+ if (CLR_CMAKE_BUILD_SANITIZERS)
+ list(APPEND CLR_CMAKE_BUILD_SANITIZE_OPTIONS "-fsanitize=${CLR_CMAKE_BUILD_SANITIZERS}")
+ endif()
+ if (CLR_CMAKE_SANITIZER_RUNTIMES)
+ list(APPEND CLR_CMAKE_LINK_SANITIZE_OPTIONS "-fsanitize=${CLR_CMAKE_SANITIZER_RUNTIMES}")
+ endif()
+ if (MSVC)
+ add_compile_options("$<$<COMPILE_LANGUAGE:C,CXX>:${CLR_CMAKE_BUILD_SANITIZE_OPTIONS}>")
+ else()
+ add_compile_options("$<$<COMPILE_LANGUAGE:C,CXX>:${CLR_CMAKE_BUILD_SANITIZE_OPTIONS}>")
+ add_linker_flag("${CLR_CMAKE_LINK_SANITIZE_OPTIONS}")
+ endif()
+endif()
+
# CLR_ADDITIONAL_LINKER_FLAGS - used for passing additional arguments to linker
# CLR_ADDITIONAL_COMPILER_OPTIONS - used for passing additional arguments to compiler
#
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector")
add_definitions(-D__EXTENSIONS__ -D_XPG4_2 -D_POSIX_PTHREAD_SEMANTICS)
-elseif(CLR_CMAKE_HOST_OSX AND NOT CLR_CMAKE_HOST_IOS AND NOT CLR_CMAKE_HOST_TVOS)
+elseif(CLR_CMAKE_HOST_OSX AND NOT CLR_CMAKE_HOST_MACCATALYST AND NOT CLR_CMAKE_HOST_IOS AND NOT CLR_CMAKE_HOST_TVOS)
add_definitions(-D_XOPEN_SOURCE)
add_linker_flag("-Wl,-bind_at_load")
+elseif(CLR_CMAKE_HOST_HAIKU)
+ add_compile_options($<$<COMPILE_LANGUAGE:ASM>:-Wa,--noexecstack>)
+ add_linker_flag("-Wl,--no-undefined")
endif()
#------------------------------------
add_definitions(-DHOST_UNIX)
if(CLR_CMAKE_HOST_OSX OR CLR_CMAKE_HOST_MACCATALYST)
- add_definitions(-DHOST_OSX)
+ add_definitions(-DHOST_APPLE)
+ if(CLR_CMAKE_HOST_MACCATALYST)
+ add_definitions(-DHOST_MACCATALYST)
+ else()
+ add_definitions(-DHOST_OSX)
+ endif()
if(CLR_CMAKE_HOST_UNIX_AMD64)
message("Detected OSX x86_64")
elseif(CLR_CMAKE_HOST_UNIX_ARM64)
else()
clr_unknown_arch()
endif()
+ elseif (CLR_CMAKE_HOST_IOS)
+ add_definitions(-DHOST_APPLE)
+ add_definitions(-DHOST_IOS)
+ if(CLR_CMAKE_HOST_UNIX_AMD64)
+ message("Detected iOS x86_64")
+ elseif(CLR_CMAKE_HOST_UNIX_ARM64)
+ message("Detected iOS ARM64")
+ else()
+ clr_unknown_arch()
+ endif()
+ elseif (CLR_CMAKE_HOST_TVOS)
+ add_definitions(-DHOST_APPLE)
+ add_definitions(-DHOST_TVOS)
+ if(CLR_CMAKE_HOST_UNIX_AMD64)
+ message("Detected tvOS x86_64")
+ elseif(CLR_CMAKE_HOST_UNIX_ARM64)
+ message("Detected tvOS ARM64")
+ else()
+ clr_unknown_arch()
+ endif()
elseif(CLR_CMAKE_HOST_FREEBSD)
- message("Detected FreeBSD amd64")
+ if(CLR_CMAKE_HOST_UNIX_ARM64)
+ message("Detected FreeBSD aarch64")
+ elseif(CLR_CMAKE_HOST_UNIX_AMD64)
+ message("Detected FreeBSD amd64")
+ else()
+ message(FATAL_ERROR "Unsupported FreeBSD architecture")
+ endif()
elseif(CLR_CMAKE_HOST_NETBSD)
message("Detected NetBSD amd64")
elseif(CLR_CMAKE_HOST_SUNOS)
message("Detected SunOS amd64")
+ elseif(CLR_CMAKE_HOST_HAIKU)
+ message("Detected Haiku x86_64")
endif(CLR_CMAKE_HOST_OSX OR CLR_CMAKE_HOST_MACCATALYST)
endif(CLR_CMAKE_HOST_UNIX)
# using twos-complement representation (this is normally undefined according to the C++ spec).
add_compile_options(-fwrapv)
+ if(CLR_CMAKE_HOST_APPLE)
+ # Clang will by default emit objc_msgSend stubs in Xcode 14, which ld from earlier Xcodes doesn't understand.
+ # We disable this by passing -fno-objc-msgsend-selector-stubs to clang.
+ # We can probably remove this flag once we require developers to use Xcode 14.
+ # Ref: https://github.com/xamarin/xamarin-macios/issues/16223
+ check_c_compiler_flag(-fno-objc-msgsend-selector-stubs COMPILER_SUPPORTS_FNO_OBJC_MSGSEND_SELECTOR_STUBS)
+ if(COMPILER_SUPPORTS_FNO_OBJC_MSGSEND_SELECTOR_STUBS)
+ set(CLR_CMAKE_COMMON_OBJC_FLAGS "${CLR_CMAKE_COMMON_OBJC_FLAGS} -fno-objc-msgsend-selector-stubs")
+ endif()
+ endif()
+
if(CLR_CMAKE_HOST_OSX OR CLR_CMAKE_HOST_MACCATALYST)
# We cannot enable "stack-protector-strong" on OS X due to a bug in clang compiler (current version 7.0.2)
add_compile_options(-fstack-protector)
add_definitions(-DLSE_INSTRUCTIONS_ENABLED_BY_DEFAULT)
add_compile_options(-mcpu=apple-m1)
endif(CLR_CMAKE_HOST_UNIX_ARM64)
- elseif(NOT CLR_CMAKE_HOST_BROWSER)
+ elseif(NOT CLR_CMAKE_HOST_BROWSER AND NOT CLR_CMAKE_HOST_WASI)
check_c_compiler_flag(-fstack-protector-strong COMPILER_SUPPORTS_F_STACK_PROTECTOR_STRONG)
if (COMPILER_SUPPORTS_F_STACK_PROTECTOR_STRONG)
add_compile_options(-fstack-protector-strong)
# optimization in the IEEE 754 specification and is therefore considered unsafe.
add_compile_options(-ffp-contract=off)
+ add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-fno-rtti>)
+
if (CMAKE_C_COMPILER_ID MATCHES "Clang")
add_compile_options(-Wno-unknown-warning-option)
add_compile_options(-Wno-incompatible-ms-struct)
add_compile_options(-Wno-reserved-identifier)
+
+ # clang 16.0 introduced buffer hardening https://discourse.llvm.org/t/rfc-c-buffer-hardening/65734
+ # which we are not conforming to yet.
+ add_compile_options(-Wno-unsafe-buffer-usage)
+
+ # other clang 16.0 suppressions
+ add_compile_options(-Wno-single-bit-bitfield-constant-conversion)
+ add_compile_options(-Wno-cast-function-type-strict)
else()
add_compile_options(-Wno-uninitialized)
add_compile_options(-Wno-strict-aliasing)
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-misleading-indentation>)
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-stringop-overflow>)
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-restrict>)
- add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-stringop-truncation>)
+ add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-Wno-stringop-truncation>)
+ add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-class-memaccess>)
if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
# this warning is only reported by g++ 11 in debug mode when building
# src/coreclr/vm/stackingallocator.h. It is a false-positive, fixed in g++ 12.
# see: https://github.com/dotnet/runtime/pull/69188#issuecomment-1136764770
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-placement-new>)
-
- add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wno-class-memaccess>)
endif()
if (CMAKE_CXX_COMPILER_ID)
# We mark the function which needs exporting with DLLEXPORT
add_compile_options(-fvisibility=hidden)
-
+
# Separate functions so linker can remove them.
add_compile_options(-ffunction-sections)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MACOS_VERSION_MIN_FLAGS} ${DISABLE_OVERRIDING_MIN_VERSION_ERROR}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${MACOS_VERSION_MIN_FLAGS} ${DISABLE_OVERRIDING_MIN_VERSION_ERROR}")
set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${MACOS_VERSION_MIN_FLAGS} ${DISABLE_OVERRIDING_MIN_VERSION_ERROR}")
+ set(CMAKE_OBJC_FLAGS "${CMAKE_OBJC_FLAGS} ${MACOS_VERSION_MIN_FLAGS} ${DISABLE_OVERRIDING_MIN_VERSION_ERROR}")
+ set(CMAKE_OBJCXX_FLAGS "${CMAKE_OBJCXX_FLAGS} ${MACOS_VERSION_MIN_FLAGS} ${DISABLE_OVERRIDING_MIN_VERSION_ERROR}")
elseif(CLR_CMAKE_HOST_OSX)
if(CLR_CMAKE_HOST_ARCH_ARM64)
set(CMAKE_OSX_DEPLOYMENT_TARGET "11.0")
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_UNIX>)
# Contracts are disabled on UNIX.
add_definitions(-DDISABLE_CONTRACTS)
- if(CLR_CMAKE_TARGET_OSX AND NOT CLR_CMAKE_TARGET_IOS AND NOT CLR_CMAKE_TARGET_TVOS)
+ if(CLR_CMAKE_TARGET_APPLE)
+ add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_APPLE>)
+ endif()
+ if(CLR_CMAKE_TARGET_OSX)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_OSX>)
+ elseif(CLR_CMAKE_TARGET_MACCATALYST)
+ add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_MACCATALYST>)
+ elseif(CLR_CMAKE_TARGET_IOS)
+ add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_IOS>)
+ elseif(CLR_CMAKE_TARGET_TVOS)
+ add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_TVOS>)
elseif(CLR_CMAKE_TARGET_FREEBSD)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_FREEBSD>)
elseif(CLR_CMAKE_TARGET_ANDROID)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_ANDROID>)
elseif(CLR_CMAKE_TARGET_LINUX)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_LINUX>)
+ if(CLR_CMAKE_TARGET_BROWSER)
+ add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_BROWSER>)
+ endif()
if(CLR_CMAKE_TARGET_LINUX_MUSL)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_LINUX_MUSL>)
endif()
if(CLR_CMAKE_TARGET_OS_ILLUMOS)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_ILLUMOS>)
endif()
+ elseif(CLR_CMAKE_TARGET_HAIKU)
+ add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_HAIKU>)
endif()
elseif(CLR_CMAKE_TARGET_WASI)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_WASI>)
-elseif(CLR_CMAKE_TARGET_BROWSER)
- add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_BROWSER>)
else(CLR_CMAKE_TARGET_UNIX)
add_compile_definitions($<$<NOT:$<BOOL:$<TARGET_PROPERTY:IGNORE_DEFAULT_TARGET_OS>>>:TARGET_WINDOWS>)
endif(CLR_CMAKE_TARGET_UNIX)
# Set Warning Level 4:
add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/w44177>) # Pragma data_seg s/b at global scope.
- add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/Zi>) # enable debugging information
+ add_compile_options($<$<COMPILE_LANGUAGE:C,CXX,ASM_MASM>:/Zi>) # enable debugging information
add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/ZH:SHA_256>) # use SHA256 for generating hashes of compiler processed source files.
add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:/source-charset:utf-8>) # Force MSVC to compile source as UTF-8.
# production-time scenarios.
set(CMAKE_MSVC_RUNTIME_LIBRARY MultiThreaded$<$<AND:$<OR:$<CONFIG:Debug>,$<CONFIG:Checked>>,$<NOT:$<BOOL:$<TARGET_PROPERTY:DAC_COMPONENT>>>>:Debug>)
+ if (NOT CLR_CMAKE_ENABLE_SANITIZERS)
+ # Force uCRT to be dynamically linked for Release build
+ # We won't do this for sanitized builds as the dynamic CRT is not compatible with the static sanitizer runtime and
+ # the dynamic sanitizer runtime is not redistributable. Sanitized runtime builds are not production-time scenarios
+ # so we don't get the benefits of a dynamic CRT for sanitized runtime builds.
+ add_linker_flag(/NODEFAULTLIB:libucrt.lib RELEASE)
+ add_linker_flag(/DEFAULTLIB:ucrt.lib RELEASE)
+ endif()
+
add_compile_options($<$<COMPILE_LANGUAGE:ASM_MASM>:/ZH:SHA_256>)
if (CLR_CMAKE_TARGET_ARCH_ARM OR CLR_CMAKE_TARGET_ARCH_ARM64)
add_compile_options($<$<COMPILE_LANGUAGE:RC>:/nologo>)
endif (MSVC)
+# Configure non-MSVC compiler flags that apply to all platforms (unix-like or otherwise)
+if (NOT MSVC)
+ # Check for sometimes suppressed warnings
+ check_c_compiler_flag(-Wreserved-identifier COMPILER_SUPPORTS_W_RESERVED_IDENTIFIER)
+ if(COMPILER_SUPPORTS_W_RESERVED_IDENTIFIER)
+ add_compile_definitions(COMPILER_SUPPORTS_W_RESERVED_IDENTIFIER)
+ endif()
+endif()
+
if(CLR_CMAKE_ENABLE_CODE_COVERAGE)
if(CLR_CMAKE_HOST_UNIX)
message(FATAL_ERROR "MC not found")
endif()
-elseif (NOT CLR_CMAKE_HOST_BROWSER)
+elseif (NOT CLR_CMAKE_HOST_BROWSER AND NOT CLR_CMAKE_HOST_WASI)
# This is a workaround for upstream issue: https://gitlab.kitware.com/cmake/cmake/-/issues/22995.
#
# In Clang.cmake, the decision to use single or double hyphen for target and gcc-toolchain
# - for windows we use the passed in parameter to CMAKE to determine build arch
#----------------------------------------
set(CLR_CMAKE_HOST_OS ${CMAKE_SYSTEM_NAME})
-if(CLR_CMAKE_HOST_OS STREQUAL Linux)
+string(TOLOWER ${CLR_CMAKE_HOST_OS} CLR_CMAKE_HOST_OS)
+if(CLR_CMAKE_HOST_OS STREQUAL linux)
set(CLR_CMAKE_HOST_UNIX 1)
if(CLR_CROSS_COMPONENTS_BUILD)
# CMAKE_HOST_SYSTEM_PROCESSOR returns the value of `uname -p` on host.
COMMAND bash -c "source ${LINUX_ID_FILE} && echo \$ID"
OUTPUT_VARIABLE CLR_CMAKE_LINUX_ID
OUTPUT_STRIP_TRAILING_WHITESPACE)
-
- execute_process(
- COMMAND bash -c "if strings \"${CMAKE_SYSROOT}/usr/bin/ldd\" 2>&1 | grep -q musl; then echo musl; fi"
- OUTPUT_VARIABLE CLR_CMAKE_LINUX_MUSL
- OUTPUT_STRIP_TRAILING_WHITESPACE)
endif()
if(DEFINED CLR_CMAKE_LINUX_ID)
set(CLR_CMAKE_TARGET_TIZEN_LINUX 1)
set(CLR_CMAKE_HOST_OS ${CLR_CMAKE_LINUX_ID})
elseif(CLR_CMAKE_LINUX_ID STREQUAL alpine)
- set(CLR_CMAKE_HOST_ALPINE_LINUX 1)
- set(CLR_CMAKE_HOST_OS ${CLR_CMAKE_LINUX_ID})
- endif()
-
- if(CLR_CMAKE_LINUX_MUSL STREQUAL musl)
set(CLR_CMAKE_HOST_LINUX_MUSL 1)
+ set(CLR_CMAKE_HOST_OS ${CLR_CMAKE_LINUX_ID})
endif()
endif(DEFINED CLR_CMAKE_LINUX_ID)
-endif(CLR_CMAKE_HOST_OS STREQUAL Linux)
+endif(CLR_CMAKE_HOST_OS STREQUAL linux)
-if(CLR_CMAKE_HOST_OS STREQUAL Darwin)
+if(CLR_CMAKE_HOST_OS STREQUAL darwin)
set(CLR_CMAKE_HOST_UNIX 1)
+ set(CLR_CMAKE_HOST_APPLE 1)
- if(CMAKE_SYSTEM_VARIANT STREQUAL MacCatalyst)
+ if(CMAKE_SYSTEM_VARIANT STREQUAL maccatalyst)
set(CLR_CMAKE_HOST_MACCATALYST 1)
else()
set(CLR_CMAKE_HOST_OSX 1)
- endif(CMAKE_SYSTEM_VARIANT STREQUAL MacCatalyst)
+ endif(CMAKE_SYSTEM_VARIANT STREQUAL maccatalyst)
if(CMAKE_OSX_ARCHITECTURES STREQUAL x86_64)
set(CLR_CMAKE_HOST_UNIX_AMD64 1)
clr_unknown_arch()
endif()
set(CMAKE_ASM_COMPILE_OBJECT "${CMAKE_C_COMPILER} <FLAGS> <DEFINES> <INCLUDES> -o <OBJECT> -c <SOURCE>")
-endif(CLR_CMAKE_HOST_OS STREQUAL Darwin)
+endif(CLR_CMAKE_HOST_OS STREQUAL darwin)
-if(CLR_CMAKE_HOST_OS STREQUAL iOS OR CLR_CMAKE_HOST_OS STREQUAL iOSSimulator)
+if(CLR_CMAKE_HOST_OS STREQUAL ios OR CLR_CMAKE_HOST_OS STREQUAL iossimulator)
set(CLR_CMAKE_HOST_UNIX 1)
+ set(CLR_CMAKE_HOST_APPLE 1)
set(CLR_CMAKE_HOST_IOS 1)
if(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
set(CLR_CMAKE_HOST_UNIX_AMD64 1)
else()
clr_unknown_arch()
endif()
-endif(CLR_CMAKE_HOST_OS STREQUAL iOS OR CLR_CMAKE_HOST_OS STREQUAL iOSSimulator)
+endif(CLR_CMAKE_HOST_OS STREQUAL ios OR CLR_CMAKE_HOST_OS STREQUAL iossimulator)
-if(CLR_CMAKE_HOST_OS STREQUAL tvOS OR CLR_CMAKE_HOST_OS STREQUAL tvOSSimulator)
+if(CLR_CMAKE_HOST_OS STREQUAL tvos OR CLR_CMAKE_HOST_OS STREQUAL tvossimulator)
set(CLR_CMAKE_HOST_UNIX 1)
+ set(CLR_CMAKE_HOST_APPLE 1)
set(CLR_CMAKE_HOST_TVOS 1)
if(CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
set(CLR_CMAKE_HOST_UNIX_AMD64 1)
else()
clr_unknown_arch()
endif()
-endif(CLR_CMAKE_HOST_OS STREQUAL tvOS OR CLR_CMAKE_HOST_OS STREQUAL tvOSSimulator)
+endif(CLR_CMAKE_HOST_OS STREQUAL tvos OR CLR_CMAKE_HOST_OS STREQUAL tvossimulator)
-if(CLR_CMAKE_HOST_OS STREQUAL Android)
+if(CLR_CMAKE_HOST_OS STREQUAL android)
set(CLR_CMAKE_HOST_UNIX 1)
set(CLR_CMAKE_HOST_LINUX 1)
set(CLR_CMAKE_HOST_ANDROID 1)
else()
clr_unknown_arch()
endif()
-endif(CLR_CMAKE_HOST_OS STREQUAL Android)
+endif(CLR_CMAKE_HOST_OS STREQUAL android)
-if(CLR_CMAKE_HOST_OS STREQUAL FreeBSD)
+if(CLR_CMAKE_HOST_OS STREQUAL freebsd)
set(CLR_CMAKE_HOST_UNIX 1)
- set(CLR_CMAKE_HOST_UNIX_AMD64 1)
+ if (CMAKE_SYSTEM_PROCESSOR STREQUAL amd64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64)
+ set(CLR_CMAKE_HOST_UNIX_AMD64 1)
+ elseif (CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL arm64)
+ set(CLR_CMAKE_HOST_UNIX_ARM64 1)
+ else()
+ clr_unknown_arch()
+ endif()
set(CLR_CMAKE_HOST_FREEBSD 1)
-endif(CLR_CMAKE_HOST_OS STREQUAL FreeBSD)
+endif(CLR_CMAKE_HOST_OS STREQUAL freebsd)
-if(CLR_CMAKE_HOST_OS STREQUAL OpenBSD)
+if(CLR_CMAKE_HOST_OS STREQUAL openbsd)
set(CLR_CMAKE_HOST_UNIX 1)
set(CLR_CMAKE_HOST_UNIX_AMD64 1)
set(CLR_CMAKE_HOST_OPENBSD 1)
-endif(CLR_CMAKE_HOST_OS STREQUAL OpenBSD)
+endif(CLR_CMAKE_HOST_OS STREQUAL openbsd)
-if(CLR_CMAKE_HOST_OS STREQUAL NetBSD)
+if(CLR_CMAKE_HOST_OS STREQUAL netbsd)
set(CLR_CMAKE_HOST_UNIX 1)
set(CLR_CMAKE_HOST_UNIX_AMD64 1)
set(CLR_CMAKE_HOST_NETBSD 1)
-endif(CLR_CMAKE_HOST_OS STREQUAL NetBSD)
+endif(CLR_CMAKE_HOST_OS STREQUAL netbsd)
-if(CLR_CMAKE_HOST_OS STREQUAL SunOS)
+if(CLR_CMAKE_HOST_OS STREQUAL sunos)
set(CLR_CMAKE_HOST_UNIX 1)
EXECUTE_PROCESS(
COMMAND isainfo -n
else(SUNOS_KERNEL_KIND STREQUAL illumos OR CMAKE_CROSSCOMPILING)
set(CLR_CMAKE_HOST_OS_SOLARIS 1)
endif(SUNOS_KERNEL_KIND STREQUAL illumos OR CMAKE_CROSSCOMPILING)
-endif(CLR_CMAKE_HOST_OS STREQUAL SunOS)
+endif(CLR_CMAKE_HOST_OS STREQUAL sunos)
-if(CLR_CMAKE_HOST_OS STREQUAL Windows)
- set(CLR_CMAKE_HOST_OS windows)
+if(CLR_CMAKE_HOST_OS STREQUAL haiku)
+ set(CLR_CMAKE_HOST_UNIX 1)
+ set(CLR_CMAKE_HOST_UNIX_AMD64 1)
+ set(CLR_CMAKE_HOST_HAIKU 1)
+endif(CLR_CMAKE_HOST_OS STREQUAL haiku)
+
+if(CLR_CMAKE_HOST_OS STREQUAL windows)
set(CLR_CMAKE_HOST_WIN32 1)
-endif(CLR_CMAKE_HOST_OS STREQUAL Windows)
+endif(CLR_CMAKE_HOST_OS STREQUAL windows)
-if(CLR_CMAKE_HOST_OS STREQUAL Emscripten)
+if(CLR_CMAKE_HOST_OS STREQUAL emscripten)
set(CLR_CMAKE_HOST_UNIX 1)
set(CLR_CMAKE_HOST_BROWSER 1)
-endif(CLR_CMAKE_HOST_OS STREQUAL Emscripten)
+endif(CLR_CMAKE_HOST_OS STREQUAL emscripten)
-if(CLR_CMAKE_TARGET_OS STREQUAL Wasi)
+if(CLR_CMAKE_TARGET_OS STREQUAL wasi)
set(CLR_CMAKE_HOST_WASI 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL Wasi)
+endif(CLR_CMAKE_TARGET_OS STREQUAL wasi)
#--------------------------------------------
# This repo builds two set of binaries
set(CLR_CMAKE_TARGET_OS ${CLR_CMAKE_HOST_OS})
endif()
-if(CLR_CMAKE_TARGET_OS STREQUAL Linux)
+if(CLR_CMAKE_TARGET_OS STREQUAL linux)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_LINUX 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL Linux)
-
-if(CLR_CMAKE_HOST_LINUX_MUSL)
- set(CLR_CMAKE_TARGET_LINUX_MUSL 1)
-endif(CLR_CMAKE_HOST_LINUX_MUSL)
+endif(CLR_CMAKE_TARGET_OS STREQUAL linux)
if(CLR_CMAKE_TARGET_OS STREQUAL tizen)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_TIZEN_LINUX 1)
endif(CLR_CMAKE_TARGET_OS STREQUAL tizen)
-if(CLR_CMAKE_TARGET_OS STREQUAL alpine)
+if(CLR_CMAKE_HOST_LINUX_MUSL OR CLR_CMAKE_TARGET_OS STREQUAL alpine)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_LINUX 1)
- set(CLR_CMAKE_TARGET_ALPINE_LINUX 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL alpine)
+ set(CLR_CMAKE_TARGET_LINUX_MUSL 1)
+endif(CLR_CMAKE_HOST_LINUX_MUSL OR CLR_CMAKE_TARGET_OS STREQUAL alpine)
-if(CLR_CMAKE_TARGET_OS STREQUAL Android)
+if(CLR_CMAKE_TARGET_OS STREQUAL android)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_LINUX 1)
set(CLR_CMAKE_TARGET_ANDROID 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL Android)
+endif(CLR_CMAKE_TARGET_OS STREQUAL android)
-if(CLR_CMAKE_TARGET_OS STREQUAL Darwin)
+if(CLR_CMAKE_TARGET_OS STREQUAL darwin)
set(CLR_CMAKE_TARGET_UNIX 1)
+ set(CLR_CMAKE_TARGET_APPLE 1)
- if(CMAKE_SYSTEM_VARIANT STREQUAL MacCatalyst)
+ if(CMAKE_SYSTEM_VARIANT STREQUAL maccatalyst)
set(CLR_CMAKE_TARGET_MACCATALYST 1)
else()
set(CLR_CMAKE_TARGET_OSX 1)
- endif(CMAKE_SYSTEM_VARIANT STREQUAL MacCatalyst)
-endif(CLR_CMAKE_TARGET_OS STREQUAL Darwin)
+ endif(CMAKE_SYSTEM_VARIANT STREQUAL maccatalyst)
+endif(CLR_CMAKE_TARGET_OS STREQUAL darwin)
-if(CLR_CMAKE_TARGET_OS STREQUAL iOS OR CLR_CMAKE_TARGET_OS STREQUAL iOSSimulator)
+if(CLR_CMAKE_TARGET_OS STREQUAL ios OR CLR_CMAKE_TARGET_OS STREQUAL iossimulator)
set(CLR_CMAKE_TARGET_UNIX 1)
+ set(CLR_CMAKE_TARGET_APPLE 1)
set(CLR_CMAKE_TARGET_IOS 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL iOS OR CLR_CMAKE_TARGET_OS STREQUAL iOSSimulator)
+endif(CLR_CMAKE_TARGET_OS STREQUAL ios OR CLR_CMAKE_TARGET_OS STREQUAL iossimulator)
-if(CLR_CMAKE_TARGET_OS STREQUAL tvOS OR CLR_CMAKE_TARGET_OS STREQUAL tvOSSimulator)
+if(CLR_CMAKE_TARGET_OS STREQUAL tvos OR CLR_CMAKE_TARGET_OS STREQUAL tvossimulator)
set(CLR_CMAKE_TARGET_UNIX 1)
+ set(CLR_CMAKE_TARGET_APPLE 1)
set(CLR_CMAKE_TARGET_TVOS 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL tvOS OR CLR_CMAKE_TARGET_OS STREQUAL tvOSSimulator)
+endif(CLR_CMAKE_TARGET_OS STREQUAL tvos OR CLR_CMAKE_TARGET_OS STREQUAL tvossimulator)
-if(CLR_CMAKE_TARGET_OS STREQUAL FreeBSD)
+if(CLR_CMAKE_TARGET_OS STREQUAL freebsd)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_FREEBSD 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL FreeBSD)
+endif(CLR_CMAKE_TARGET_OS STREQUAL freebsd)
-if(CLR_CMAKE_TARGET_OS STREQUAL OpenBSD)
+if(CLR_CMAKE_TARGET_OS STREQUAL openbsd)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_OPENBSD 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL OpenBSD)
+endif(CLR_CMAKE_TARGET_OS STREQUAL openbsd)
-if(CLR_CMAKE_TARGET_OS STREQUAL NetBSD)
+if(CLR_CMAKE_TARGET_OS STREQUAL netbsd)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_NETBSD 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL NetBSD)
+endif(CLR_CMAKE_TARGET_OS STREQUAL netbsd)
-if(CLR_CMAKE_TARGET_OS STREQUAL SunOS)
+if(CLR_CMAKE_TARGET_OS STREQUAL sunos)
set(CLR_CMAKE_TARGET_UNIX 1)
if(CLR_CMAKE_HOST_OS_ILLUMOS)
set(CLR_CMAKE_TARGET_OS_ILLUMOS 1)
set(CLR_CMAKE_TARGET_OS_SOLARIS 1)
endif(CLR_CMAKE_HOST_OS_ILLUMOS)
set(CLR_CMAKE_TARGET_SUNOS 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL SunOS)
+endif(CLR_CMAKE_TARGET_OS STREQUAL sunos)
-if(CLR_CMAKE_TARGET_OS STREQUAL Emscripten)
+if(CLR_CMAKE_TARGET_OS STREQUAL haiku)
+ set(CLR_CMAKE_TARGET_UNIX 1)
+ set(CLR_CMAKE_TARGET_HAIKU 1)
+endif(CLR_CMAKE_TARGET_OS STREQUAL haiku)
+
+if(CLR_CMAKE_TARGET_OS STREQUAL emscripten)
set(CLR_CMAKE_TARGET_UNIX 1)
set(CLR_CMAKE_TARGET_LINUX 1)
set(CLR_CMAKE_TARGET_BROWSER 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL Emscripten)
+endif(CLR_CMAKE_TARGET_OS STREQUAL emscripten)
-if(CLR_CMAKE_TARGET_OS STREQUAL Wasi)
+if(CLR_CMAKE_TARGET_OS STREQUAL wasi)
set(CLR_CMAKE_TARGET_WASI 1)
-endif(CLR_CMAKE_TARGET_OS STREQUAL Wasi)
+endif(CLR_CMAKE_TARGET_OS STREQUAL wasi)
if(CLR_CMAKE_TARGET_UNIX)
if(CLR_CMAKE_TARGET_ARCH STREQUAL x64)
else()
clr_unknown_arch()
endif()
-else()
- set(CLR_CMAKE_TARGET_WIN32 1)
endif(CLR_CMAKE_TARGET_UNIX)
+if(CLR_CMAKE_TARGET_OS STREQUAL windows)
+ set(CLR_CMAKE_TARGET_WIN32 1)
+endif()
+
# check if host & target os/arch combination are valid
-if (NOT (CLR_CMAKE_TARGET_OS STREQUAL CLR_CMAKE_HOST_OS))
+if (NOT (CLR_CMAKE_TARGET_OS STREQUAL CLR_CMAKE_HOST_OS) AND NOT CLR_CMAKE_TARGET_WASI)
if(NOT (CLR_CMAKE_HOST_OS STREQUAL windows))
message(FATAL_ERROR "Invalid host and target os/arch combination. Host OS: ${CLR_CMAKE_HOST_OS}")
endif()
- if(NOT (CLR_CMAKE_TARGET_LINUX OR CLR_CMAKE_TARGET_ALPINE_LINUX))
+ if(NOT (CLR_CMAKE_TARGET_LINUX OR CLR_CMAKE_TARGET_LINUX_MUSL))
message(FATAL_ERROR "Invalid host and target os/arch combination. Target OS: ${CLR_CMAKE_TARGET_OS}")
endif()
if(NOT ((CLR_CMAKE_HOST_ARCH_AMD64 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_ARM64)) OR (CLR_CMAKE_HOST_ARCH_I386 AND CLR_CMAKE_TARGET_ARCH_ARM)))
endif()
endif()
-if(NOT CLR_CMAKE_TARGET_BROWSER)
+if(NOT CLR_CMAKE_TARGET_BROWSER AND NOT CLR_CMAKE_TARGET_WASI)
# The default linker on Solaris also does not support PIE.
- if(NOT CLR_CMAKE_TARGET_ANDROID AND NOT CLR_CMAKE_TARGET_SUNOS AND NOT CLR_CMAKE_TARGET_OSX AND NOT CLR_CMAKE_TARGET_MACCATALYST AND NOT CLR_CMAKE_HOST_TVOS AND NOT CLR_CMAKE_HOST_IOS AND NOT MSVC)
+ if(NOT CLR_CMAKE_TARGET_ANDROID AND NOT CLR_CMAKE_TARGET_SUNOS AND NOT CLR_CMAKE_TARGET_APPLE AND NOT MSVC)
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
add_compile_options($<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:-fPIE>)
add_compile_options($<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:-fPIC>)
set(CLR_CMAKE_COMPILER_FILE_NAME_VERSION "${CMAKE_MATCH_0}")
endif()
-if(NOT WIN32 AND NOT CLR_CMAKE_TARGET_BROWSER)
+if(NOT WIN32 AND NOT CLR_CMAKE_TARGET_BROWSER AND NOT CLR_CMAKE_TARGET_WASI)
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
if(APPLE)
set(TOOLSET_PREFIX "")
locate_toolchain_exec(ar CMAKE_AR YES)
locate_toolchain_exec(nm CMAKE_NM YES)
locate_toolchain_exec(ranlib CMAKE_RANLIB YES)
+ locate_toolchain_exec(strings CMAKE_STRINGS YES)
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
locate_toolchain_exec(link CMAKE_LINKER YES)
endif()
- if(NOT CLR_CMAKE_TARGET_OSX AND NOT CLR_CMAKE_TARGET_MACCATALYST AND NOT CLR_CMAKE_TARGET_IOS AND NOT CLR_CMAKE_TARGET_TVOS AND (NOT CLR_CMAKE_TARGET_ANDROID OR CROSS_ROOTFS))
+ if(NOT CLR_CMAKE_TARGET_APPLE AND (NOT CLR_CMAKE_TARGET_ANDROID OR CROSS_ROOTFS))
locate_toolchain_exec(objdump CMAKE_OBJDUMP YES)
+ locate_toolchain_exec(readelf CMAKE_READELF YES)
unset(CMAKE_OBJCOPY CACHE)
locate_toolchain_exec(objcopy CMAKE_OBJCOPY NO)
set(LD_OSX 1)
endif()
endif()
+
+# This introspection depends on CMAKE_STRINGS, which is why it's in this file instead of configureplatform
+if (CLR_CMAKE_HOST_LINUX)
+ execute_process(
+ COMMAND bash -c "if ${CMAKE_STRINGS} \"${CMAKE_SYSROOT}/usr/bin/ldd\" 2>&1 | grep -q musl; then echo musl; fi"
+ OUTPUT_VARIABLE CLR_CMAKE_LINUX_MUSL
+ OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+ if(CLR_CMAKE_LINUX_MUSL STREQUAL musl)
+ set(CLR_CMAKE_HOST_LINUX_MUSL 1)
+ set(CLR_CMAKE_TARGET_UNIX 1)
+ set(CLR_CMAKE_TARGET_LINUX 1)
+ set(CLR_CMAKE_TARGET_LINUX_MUSL 1)
+ endif()
+endif()
set(LastGeneratorExpression "")
foreach(DEFINITION IN LISTS COMPILE_DEFINITIONS_LIST)
# If there is a definition that uses the $<TARGET_PROPERTY:prop> generator expression
+ # or the $<COMPILE_LANGUAGE:lang> generator expression,
# we need to remove it since that generator expression is only valid on binary targets.
# Assume that the value is 0.
string(REGEX REPLACE "\\$<TARGET_PROPERTY:[^,>]+>" "0" DEFINITION "${DEFINITION}")
+ string(REGEX REPLACE "\\$<COMPILE_LANGUAGE:[^>]+(,[^>]+)*>" "0" DEFINITION "${DEFINITION}")
if (${DEFINITION} MATCHES "^\\$<(.+):([^>]+)(>?)$")
if("${CMAKE_MATCH_3}" STREQUAL "")
list(GET INPUT_LIST -1 outputFilename)
list(REMOVE_AT INPUT_LIST -1)
- if(CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+ if(CLR_CMAKE_TARGET_APPLE)
set(SCRIPT_NAME generateexportedsymbols.sh)
else()
set(SCRIPT_NAME generateversionscript.sh)
function (get_symbol_file_name targetName outputSymbolFilename)
if (CLR_CMAKE_HOST_UNIX)
- if (CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+ if (CLR_CMAKE_TARGET_APPLE)
set(strip_destination_file $<TARGET_FILE:${targetName}>.dwarf)
else ()
set(strip_destination_file $<TARGET_FILE:${targetName}>.dbg)
endif ()
set(${outputSymbolFilename} ${strip_destination_file} PARENT_SCOPE)
- else(CLR_CMAKE_HOST_UNIX)
+ elseif(CLR_CMAKE_HOST_WIN32)
# We can't use the $<TARGET_PDB_FILE> generator expression here since
# the generator expression isn't supported on resource DLLs.
set(${outputSymbolFilename} $<TARGET_FILE_DIR:${targetName}>/$<TARGET_FILE_PREFIX:${targetName}>$<TARGET_FILE_BASE_NAME:${targetName}>.pdb PARENT_SCOPE)
- endif(CLR_CMAKE_HOST_UNIX)
+ endif()
endfunction()
function(strip_symbols targetName outputFilename)
if (CLR_CMAKE_HOST_UNIX)
set(strip_source_file $<TARGET_FILE:${targetName}>)
- if (CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+ if (CLR_CMAKE_TARGET_APPLE)
# Ensure that dsymutil and strip are present
find_program(DSYMUTIL dsymutil)
set(strip_command ${STRIP} -no_code_signature_warning -S ${strip_source_file})
- # codesign release build
- string(TOLOWER "${CMAKE_BUILD_TYPE}" LOWERCASE_CMAKE_BUILD_TYPE)
- if (LOWERCASE_CMAKE_BUILD_TYPE STREQUAL release)
- set(strip_command ${strip_command} && codesign -f -s - ${strip_source_file})
+ if (CLR_CMAKE_TARGET_OSX)
+ # codesign release build
+ string(TOLOWER "${CMAKE_BUILD_TYPE}" LOWERCASE_CMAKE_BUILD_TYPE)
+ if (LOWERCASE_CMAKE_BUILD_TYPE STREQUAL release)
+ set(strip_command ${strip_command} && codesign -f -s - ${strip_source_file})
+ endif ()
endif ()
execute_process(
TARGET ${targetName}
POST_BUILD
VERBATIM
+ COMMAND sh -c "echo Stripping symbols from $(basename '${strip_source_file}') into $(basename '${strip_destination_file}')"
COMMAND ${DSYMUTIL} ${DSYMUTIL_OPTS} ${strip_source_file}
COMMAND ${strip_command}
- COMMENT "Stripping symbols from ${strip_source_file} into file ${strip_destination_file}"
)
- else (CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+ else (CLR_CMAKE_TARGET_APPLE)
add_custom_command(
TARGET ${targetName}
POST_BUILD
VERBATIM
+ COMMAND sh -c "echo Stripping symbols from $(basename '${strip_source_file}') into $(basename '${strip_destination_file}')"
COMMAND ${CMAKE_OBJCOPY} --only-keep-debug ${strip_source_file} ${strip_destination_file}
COMMAND ${CMAKE_OBJCOPY} --strip-debug --strip-unneeded ${strip_source_file}
COMMAND ${CMAKE_OBJCOPY} --add-gnu-debuglink=${strip_destination_file} ${strip_source_file}
- COMMENT "Stripping symbols from ${strip_source_file} into file ${strip_destination_file}"
)
- endif (CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS)
+ endif (CLR_CMAKE_TARGET_APPLE)
endif(CLR_CMAKE_HOST_UNIX)
endfunction()
function(install_with_stripped_symbols targetName kind destination)
+ get_property(target_is_framework TARGET ${targetName} PROPERTY "FRAMEWORK")
if(NOT CLR_CMAKE_KEEP_NATIVE_SYMBOLS)
strip_symbols(${targetName} symbol_file)
- install_symbol_file(${symbol_file} ${destination} ${ARGN})
- endif()
-
- if ((CLR_CMAKE_TARGET_OSX OR CLR_CMAKE_TARGET_MACCATALYST OR CLR_CMAKE_TARGET_IOS OR CLR_CMAKE_TARGET_TVOS) AND ("${kind}" STREQUAL "TARGETS"))
- # We want to avoid the kind=TARGET install behaviors which corrupt code signatures on osx-arm64
- set(kind PROGRAMS)
+ if (NOT "${symbol_file}" STREQUAL "" AND NOT target_is_framework)
+ install_symbol_file(${symbol_file} ${destination} ${ARGN})
+ endif()
endif()
- if ("${kind}" STREQUAL "TARGETS")
- set(install_source ${targetName})
- elseif("${kind}" STREQUAL "PROGRAMS")
- set(install_source $<TARGET_FILE:${targetName}>)
+ if (target_is_framework)
+ install(TARGETS ${targetName} FRAMEWORK DESTINATION ${destination} ${ARGN})
else()
- message(FATAL_ERROR "The `kind` argument has to be either TARGETS or PROGRAMS, ${kind} was provided instead")
+ if (CLR_CMAKE_TARGET_APPLE AND ("${kind}" STREQUAL "TARGETS"))
+ # We want to avoid the kind=TARGET install behaviors which corrupt code signatures on osx-arm64
+ set(kind PROGRAMS)
+ endif()
+
+ if ("${kind}" STREQUAL "TARGETS")
+ set(install_source ${targetName})
+ elseif("${kind}" STREQUAL "PROGRAMS")
+ set(install_source $<TARGET_FILE:${targetName}>)
+ else()
+ message(FATAL_ERROR "The `kind` argument has to be either TARGETS or PROGRAMS, ${kind} was provided instead")
+ endif()
+ install(${kind} ${install_source} DESTINATION ${destination} ${ARGN})
endif()
- install(${kind} ${install_source} DESTINATION ${destination} ${ARGN})
endfunction()
function(install_symbol_file symbol_file destination_path)
endif()
get_filename_component(extension "${source}" EXT)
if ("${extension}" STREQUAL ".natvis")
- message("Embedding natvis ${source}")
# Since natvis embedding is only supported on Windows
# we can use target_link_options since our minimum version is high enough
target_link_options(${targetName} "${linkKind}" "-NATVIS:${source}")
endforeach()
endfunction()
+# Add sanitizer runtime support code to the target.
+function(add_sanitizer_runtime_support targetName)
+ # Add sanitizer support functions.
+ if (CLR_CMAKE_ENABLE_ASAN)
+ target_sources(${targetName} PRIVATE "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:${CLR_SRC_NATIVE_DIR}/minipal/asansupport.cpp>")
+ endif()
+endfunction()
+
function(add_executable_clr targetName)
- if(NOT WIN32)
- add_executable(${ARGV} ${VERSION_FILE_PATH})
- disable_pax_mprotect(${ARGV})
- else()
- add_executable(${ARGV})
- endif(NOT WIN32)
- if(NOT CLR_CMAKE_KEEP_NATIVE_SYMBOLS)
- strip_symbols(${ARGV0} symbolFile)
- endif()
+ if(NOT WIN32)
+ add_executable(${ARGV} ${VERSION_FILE_PATH})
+ disable_pax_mprotect(${ARGV})
+ else()
+ add_executable(${ARGV})
+ endif(NOT WIN32)
+ add_sanitizer_runtime_support(${targetName})
+ if(NOT CLR_CMAKE_KEEP_NATIVE_SYMBOLS)
+ strip_symbols(${ARGV0} symbolFile)
+ endif()
endfunction()
function(add_library_clr targetName kind)
- if(NOT WIN32 AND "${kind}" STREQUAL "SHARED")
- add_library(${ARGV} ${VERSION_FILE_PATH})
- else()
- add_library(${ARGV})
- endif()
- if("${kind}" STREQUAL "SHARED" AND NOT CLR_CMAKE_KEEP_NATIVE_SYMBOLS)
- strip_symbols(${ARGV0} symbolFile)
- endif()
+ if(NOT WIN32 AND "${kind}" STREQUAL "SHARED")
+ add_library(${ARGV} ${VERSION_FILE_PATH})
+ else()
+ add_library(${ARGV})
+ endif()
+ if("${kind}" STREQUAL "SHARED" AND NOT CLR_CMAKE_KEEP_NATIVE_SYMBOLS)
+ strip_symbols(${ARGV0} symbolFile)
+ endif()
endfunction()
if %1=="/?" GOTO :USAGE
setlocal enabledelayedexpansion
-set basePath=%~dp0
-set __repoRoot=%~dp0..\..\
-:: remove quotes
-set "basePath=%basePath:"=%"
-:: remove trailing slash
-if %basePath:~-1%==\ set "basePath=%basePath:~0,-1%"
+set "__repoRoot=%~dp0..\.."
+:: normalize
+for %%i in ("%__repoRoot%") do set "__repoRoot=%%~fi"
set __SourceDir=%1
set __IntermediatesDir=%2
echo Error: Please add target OS parameter
exit /B 1
)
- if /i "%__Os%" == "Browser" (
+ if /i "%__Os%" == "browser" (
if "%EMSDK_PATH%" == "" (
- if not exist "%__repoRoot%src\mono\wasm\emsdk" (
+ if not exist "%__repoRoot%\src\mono\wasm\emsdk" (
echo Error: Should set EMSDK_PATH environment variable pointing to emsdk root.
exit /B 1
)
- set EMSDK_PATH=%__repoRoot%src\mono\wasm\emsdk
- set EMSDK_PATH=!EMSDK_PATH:\=/!
+ set "EMSDK_PATH=%__repoRoot%\src\mono\wasm\emsdk"
)
+ :: replace backslash with forward slash and append last slash
+ set "EMSDK_PATH=!EMSDK_PATH:\=/!"
+ if not "!EMSDK_PATH:~-1!" == "/" set "EMSDK_PATH=!EMSDK_PATH!/"
set __ExtraCmakeParams=%__ExtraCmakeParams% "-DCMAKE_TOOLCHAIN_FILE=!EMSDK_PATH!/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake"
set __UseEmcmake=1
)
if /i "%__Os%" == "wasi" (
- echo Error: WASI build not implemented on Windows yet
- exit /B 1
+ if "%WASI_SDK_PATH%" == "" (
+ if not exist "%__repoRoot%\src\mono\wasi\wasi-sdk" (
+ echo Error: Should set WASI_SDK_PATH environment variable pointing to emsdk root.
+ exit /B 1
+ )
+
+ set "WASI_SDK_PATH=%__repoRoot%\src\mono\wasi\wasi-sdk"
+ )
+ :: replace backslash with forward slash and append last slash
+ set "WASI_SDK_PATH=!WASI_SDK_PATH:\=/!"
+ if not "!WASI_SDK_PATH:~-1!" == "/" set "WASI_SDK_PATH=!WASI_SDK_PATH!/"
+ set __CmakeGenerator=Ninja
+ set __ExtraCmakeParams=%__ExtraCmakeParams% -DCLR_CMAKE_TARGET_OS=wasi -DCLR_CMAKE_TARGET_ARCH=wasm "-DWASI_SDK_PREFIX=!WASI_SDK_PATH!" "-DCMAKE_TOOLCHAIN_FILE=!WASI_SDK_PATH!/share/cmake/wasi-sdk.cmake" "-DCMAKE_SYSROOT=!WASI_SDK_PATH!/share/wasi-sysroot"
)
) else (
set __ExtraCmakeParams=%__ExtraCmakeParams% "-DCMAKE_SYSTEM_VERSION=10.0"
cmake_extra_defines=
if [[ "$CROSSCOMPILE" == "1" ]]; then
- platform="$(uname)"
+ platform="$(uname -s | tr '[:upper:]' '[:lower:]')"
# OSX doesn't use rootfs
- if ! [[ -n "$ROOTFS_DIR" || "$platform" == "Darwin" ]]; then
+ if ! [[ -n "$ROOTFS_DIR" || "$platform" == "darwin" ]]; then
echo "ROOTFS_DIR not set for crosscompile"
exit 1
fi
cmake_extra_defines="$cmake_extra_defines -C $scriptroot/tryrun.cmake"
- if [[ "$platform" == "Darwin" ]]; then
+ if [[ "$platform" == "darwin" ]]; then
cmake_extra_defines="$cmake_extra_defines -DCMAKE_SYSTEM_NAME=Darwin"
else
cmake_extra_defines="$cmake_extra_defines -DCMAKE_TOOLCHAIN_FILE=$scriptroot/../common/cross/toolchain.cmake"
fi
if [[ "$host_arch" == "wasm" ]]; then
- if [[ "$target_os" == "Browser" ]]; then
+ if [[ "$target_os" == "browser" ]]; then
cmake_command="emcmake $cmake_command"
elif [[ "$target_os" == "wasi" ]]; then
true
set -euo pipefail
if [[ "$#" -lt 2 ]]; then
- echo "Usage: genmoduleindex.sh ModuleBinaryFile IndexHeaderFile"
+ echo "Usage: genmoduleindex.sh ModuleBinaryFile IndexHeaderFile readelfBinaryPath"
exit 1
fi
case "$(uname -s)" in
Darwin)
- cmd="dwarfdump -u $1"
+ cmd="dwarfdump"
+ arg="-u"
pattern='^UUID: ([0-9A-Fa-f\-]+)';;
*)
- cmd="readelf -n $1"
+ cmd="$3"
+ arg="-n"
pattern='^[[:space:]]*Build ID: ([0-9A-Fa-f\-]+)';;
esac
-while read -r line; do
+"$cmd" "$arg" "$1" | while read -r line; do
if [[ "$line" =~ $pattern ]]; then
printIdAsBinary "${BASH_REMATCH[1]//-/}"
break
fi
-done < <(eval "$cmd") > "$2"
+done > "$2"
if (CLR_CMAKE_HOST_WIN32)
function(remove_ijw_incompatible_options options updatedOptions)
-
- # IJW isn't compatible with Ehsc, which CMake enables by default,
+ # IJW isn't compatible with Ehsc, which CMake enables by default
if(options MATCHES "/EHsc")
string(REPLACE "/EHsc" "" options "${options}")
endif()
string(REPLACE "/GR-" "" options "${options}")
endif()
+ # Disable native sanitizers for IJW since we don't want to have to locate
+ # and copy the sanitizer runtimes and IJW must be built with a dynamic CRT.
+ if (options MATCHES "-fsanitize=")
+ string(REGEX REPLACE "-fsanitize=[a-zA-z,]+" "" options "${options}")
+ endif()
+
SET(${updatedOptions} "${options}" PARENT_SCOPE)
endfunction()
set_target_properties(${targetName} PROPERTIES COMPILE_OPTIONS "${compileOptions}")
endfunction()
+ function(add_ijw_msbuild_project_properties targetName ijwhost_target)
+ # When we're building with MSBuild, we need to set some project properties
+ # in case CMake has decided to use the SDK support.
+ # We're dogfooding things, so we need to set settings in ways that the product doesn't quite support.
+ # We don't actually need an installed/available target framework version here
+ # since we are disabling implicit framework references. We just need a valid value, and net8.0 is valid.
+ set_target_properties(${targetName} PROPERTIES
+ DOTNET_TARGET_FRAMEWORK net8.0
+ VS_GLOBAL_DisableImplicitFrameworkReferences true
+ VS_GLOBAL_GenerateRuntimeConfigurationFiles false
+ VS_PROJECT_IMPORT "${CMAKE_CURRENT_FUNCTION_LIST_DIR}/SetIJWProperties.props")
+ endfunction()
+
# 4365 - signed/unsigned mismatch
# 4679 - Could not import member. This is an issue with IJW and static abstract methods in interfaces.
add_compile_options(/wd4365 /wd4679)
remove_ijw_incompatible_options("${CMAKE_CXX_FLAGS}" CMAKE_CXX_FLAGS)
+ get_directory_property(dirCompileOptions COMPILE_OPTIONS)
+ remove_ijw_incompatible_options("${dirCompileOptions}" dirCompileOptions)
+ set_directory_properties(PROPERTIES COMPILE_OPTIONS "${dirCompileOptions}")
+
set(CLR_SDK_REF_PACK_OUTPUT "")
set(CLR_SDK_REF_PACK_DISCOVERY_ERROR "")
set(CLR_SDK_REF_PACK_DISCOVERY_RESULT 0)
--- /dev/null
+<Project>
+ <PropertyGroup>
+ <!-- The C++/CLI targets don't let us set this in the project file where CMake lets us set project properties, so we set it in an imported project file where it will work. -->
+ <UseIJWHost>false</UseIJWHost>
+ </PropertyGroup>
+</Project>
\ No newline at end of file
if (-not (Test-Path $refPackPath))
{
- Write-Error "Reference assemblies not found in the artifacts folder at '$refPackPath'. Did you invoke 'build.cmd libs.sfx+libs.oob /p:RefOnly=true' to make sure that refs are built? Did the repo layout change?"
+ Write-Error "Reference assemblies not found in the artifacts folder at '$refPackPath'. Did you invoke 'build.cmd libs' to make sure that refs are built? Did the repo layout change?"
exit 1
}
+++ /dev/null
-#!/usr/bin/env bash
-
-# initNonPortableDistroRid
-#
-# Input:
-# targetOs: (str)
-# buildArch: (str)
-# isPortable: (int)
-# rootfsDir: (str)
-#
-# Return:
-# None
-#
-# Notes:
-#
-# initNonPortableDistroRid will attempt to initialize a non portable rid. These
-# rids are specific to distros need to build the product/package and consume
-# them on the same platform.
-#
-# If -portablebuild=false is passed a non-portable rid will be created for any
-# distro.
-#
-# It is important to note that the function does not return anything, but it
-# exports __DistroRid, if there is a non-portable distro rid to be used.
-#
-initNonPortableDistroRid()
-{
- # Make sure out parameter is cleared.
- __DistroRid=
-
- local targetOs="$1"
- local buildArch="$2"
- local isPortable="$3"
- local rootfsDir="$4"
- local nonPortableBuildID=""
-
- if [ "$targetOs" = "Linux" ]; then
- if [ -e "${rootfsDir}/etc/os-release" ]; then
- source "${rootfsDir}/etc/os-release"
-
- # We have forced __PortableBuild=0. This is because -portablebuld
- # has been passed as false.
- if (( isPortable == 0 )); then
- if [[ "${ID}" == "rhel" || "${ID}" == "rocky" || "${ID}" == "alpine" ]]; then
- # remove the last version digit
- VERSION_ID="${VERSION_ID%.*}"
- fi
-
- if [ -z "${VERSION_ID+x}" ]; then
- # Rolling release distros do not set VERSION_ID, so omit
- # it here to be consistent with everything else.
- nonPortableBuildID="${ID}-${buildArch}"
- else
- nonPortableBuildID="${ID}.${VERSION_ID}-${buildArch}"
- fi
- fi
-
- elif [ -e "${rootfsDir}/android_platform" ]; then
- source "$rootfsDir"/android_platform
- nonPortableBuildID="$RID"
- fi
- fi
-
- if [ "$targetOs" = "FreeBSD" ]; then
- if (( isPortable == 0 )); then
- # $rootfsDir can be empty. freebsd-version is shell script and it should always work.
- __freebsd_major_version=$($rootfsDir/bin/freebsd-version | { read v; echo "${v%%.*}"; })
- nonPortableBuildID="freebsd.$__freebsd_major_version-${buildArch}"
- fi
- elif command -v getprop && getprop ro.product.system.model 2>&1 | grep -qi android; then
- __android_sdk_version=$(getprop ro.build.version.sdk)
- nonPortableBuildID="android.$__android_sdk_version-${buildArch}"
- elif [ "$targetOs" = "illumos" ]; then
- __uname_version=$(uname -v)
- case "$__uname_version" in
- omnios-*)
- __omnios_major_version=$(echo "${__uname_version:8:2}")
- nonPortableBuildID=omnios."$__omnios_major_version"-"$buildArch"
- ;;
- joyent_*)
- __smartos_major_version=$(echo "${__uname_version:7:4}")
- nonPortableBuildID=smartos."$__smartos_major_version"-"$buildArch"
- ;;
- illumos_*)
- nonPortableBuildID=openindiana-"$buildArch"
- ;;
- esac
- elif [ "$targetOs" = "Solaris" ]; then
- __uname_version=$(uname -v)
- __solaris_major_version=$(echo "${__uname_version%.*}")
- nonPortableBuildID=solaris."$__solaris_major_version"-"$buildArch"
- fi
-
- if [ -n "${nonPortableBuildID}" ]; then
- __DistroRid="${nonPortableBuildID}"
-
- # We are using a non-portable build rid. Force __PortableBuild to false.
- __PortableBuild=0
-
- export __DistroRid __PortableBuild
- fi
-}
-
-# initDistroRidGlobal
-#
-# Input:
-# os: (str)
-# arch: (str)
-# isPortable: (int)
-# rootfsDir?: (nullable:string)
-#
-# Return:
-# None
-#
-# Notes:
-#
-# It is important to note that the function does not return anything, but it
-# exports the following variables on success:
-#
-# __DistroRid
-# __PortableBuild
-#
-initDistroRidGlobal()
-{
- # __DistroRid must be set at the end of the function.
- # Previously we would create a variable __HostDistroRid and/or __DistroRid.
- #
- # __HostDistroRid was used in the case of a non-portable build, it has been
- # deprecated. Now only __DistroRid is supported. It will be used for both
- # portable and non-portable rids and will be used in build-packages.sh
-
- local targetOs="$1"
- local buildArch="$2"
- local isPortable="$3"
- local rootfsDir=""
- if [ "$#" -ge 4 ]; then
- rootfsDir="$4"
- fi
-
- if [ -n "${rootfsDir}" ]; then
- # We may have a cross build. Check for the existence of the rootfsDir
- if [ ! -e "${rootfsDir}" ]; then
- echo "Error rootfsDir has been passed, but the location is not valid."
- exit 1
- fi
- fi
-
- initNonPortableDistroRid "${targetOs}" "${buildArch}" "${isPortable}" "${rootfsDir}"
-
- if [ "$buildArch" = "wasm" ]; then
- if [ "$targetOs" = "Browser" ]; then
- __DistroRid=browser-wasm
- export __DistroRid
- elif [ "$targetOs" = "wasi" ]; then
- __DistroRid=wasi-wasm
- export __DistroRid
- fi
- fi
-
- if [ -z "${__DistroRid}" ]; then
- # The non-portable build rid was not set. Set the portable rid.
-
- __PortableBuild=1
- export __PortableBuild
- local distroRid=""
-
- # Check for musl-based distros (e.g Alpine Linux, Void Linux).
- if "${rootfsDir}/usr/bin/ldd" --version 2>&1 | grep -q musl ||
- strings "${rootfsDir}/usr/bin/ldd" 2>&1 | grep -q musl; then
- distroRid="linux-musl-${buildArch}"
- fi
-
- if [ -z "${distroRid}" ]; then
- if [ "$targetOs" = "Linux" ]; then
- distroRid="linux-$buildArch"
- elif [ "$targetOs" = "linux-bionic" ]; then
- distroRid="linux-bionic-$buildArch"
- elif [ "$targetOs" = "OSX" ]; then
- distroRid="osx-$buildArch"
- elif [ "$targetOs" = "MacCatalyst" ]; then
- distroRid="maccatalyst-$buildArch"
- elif [ "$targetOs" = "tvOS" ]; then
- distroRid="tvos-$buildArch"
- elif [ "$targetOs" = "tvOSSimulator" ]; then
- distroRid="tvossimulator-$buildArch"
- elif [ "$targetOs" = "iOS" ]; then
- distroRid="ios-$buildArch"
- elif [ "$targetOs" = "iOSSimulator" ]; then
- distroRid="iossimulator-$buildArch"
- elif [ "$targetOs" = "Android" ]; then
- distroRid="android-$buildArch"
- elif [ "$targetOs" = "Browser" ]; then
- distroRid="browser-$buildArch"
- elif [ "$targetOs" = "wasi" ]; then
- distroRid="wasi-$buildArch"
- elif [ "$targetOs" = "FreeBSD" ]; then
- distroRid="freebsd-$buildArch"
- elif [ "$targetOs" = "illumos" ]; then
- distroRid="illumos-$buildArch"
- elif [ "$targetOs" = "Solaris" ]; then
- distroRid="solaris-$buildArch"
- fi
- fi
-
- __DistroRid="${distroRid}"
- export __DistroRid
- fi
-
- if [ -z "$__DistroRid" ]; then
- echo "DistroRid is not set. This is almost certainly an error"
- exit 1
- fi
-
- echo "__DistroRid: ${__DistroRid}"
-}
#!/usr/bin/env bash
# Use uname to determine what the OS is.
-OSName=$(uname -s)
+OSName=$(uname -s | tr '[:upper:]' '[:lower:]')
if command -v getprop && getprop ro.product.system.model 2>&1 | grep -qi android; then
- OSName="Android"
+ OSName="android"
fi
case "$OSName" in
-FreeBSD|Linux|NetBSD|OpenBSD|SunOS|Android)
+freebsd|linux|netbsd|openbsd|sunos|android|haiku)
os="$OSName" ;;
-Darwin)
- os=OSX ;;
+darwin)
+ os=osx ;;
*)
echo "Unsupported OS $OSName detected!"
exit 1 ;;
# On Solaris, `uname -m` is discouraged, see https://docs.oracle.com/cd/E36784_01/html/E36870/uname-1.html
# and `uname -p` returns processor type (e.g. i386 on amd64).
# The appropriate tool to determine CPU is isainfo(1) https://docs.oracle.com/cd/E36784_01/html/E36870/isainfo-1.html.
-if [ "$os" = "SunOS" ]; then
+if [ "$os" = "sunos" ]; then
if uname -o 2>&1 | grep -q illumos; then
os="illumos"
else
- os="Solaris"
+ os="solaris"
fi
CPUName=$(isainfo -n)
else
if /i "%~1" == "x64" (set __VCBuildArch=x86_amd64)
if /i "%~1" == "arm" (set __VCBuildArch=x86_arm)
if /i "%~1" == "arm64" (set __VCBuildArch=x86_arm64)
-if /i "%~1" == "wasm" (set __VCBuildArch=x86_amd64)
+if /i "%~1" == "wasm" (if /i "%PROCESSOR_ARCHITECTURE%" == "ARM64" (set __VCBuildArch=x86_arm64) else (set __VCBuildArch=x86_amd64))
:: Default to highest Visual Studio version available that has Visual C++ tools.
::
if "%__VCBuildArch%"=="" exit /b 0
:: Set the environment for the native build
-call "%VCINSTALLDIR%Auxiliary\Build\vcvarsall.bat" %__VCBuildArch%
-if not "%ErrorLevel%"=="0" exit /b 1
+:: We can set SkipVCEnvInit to skip setting up the MSVC environment from VS and instead assume that the current environment is set up correctly.
+:: This is very useful for testing with new MSVC versions that aren't in a VS build yet.
+if not defined SkipVCEnvInit (
+ if not exist "%VCINSTALLDIR%Auxiliary\Build\vcvarsall.bat" goto :VSMissing
+ call "%VCINSTALLDIR%Auxiliary\Build\vcvarsall.bat" %__VCBuildArch%
+ if not "%ErrorLevel%"=="0" exit /b 1
+)
set "__VCBuildArch="
--- /dev/null
+# This file has exclusions to the Clang address sanitizer to suppress error reports
+# When Clang 3.8 is available, convert these to suppression list instead as that is preferred for internal code
+
+# CMiniMdBase::UsesAllocatedMemory - suppress stack-buffer-underflow (code backs up pointer by -1 to check allocation ownership)
+fun:_ZN11CMiniMdBase19UsesAllocatedMemoryEP11CMiniColDef
+
+# JIT_InitPInvokeFrame - suppress unknown sanitizer issue causing SEGV on unknown address 0x000000000000
+# 0 0x4e8a0c in __ubsan::checkDynamicType(void*, void*, unsigned long)
+# 1 0x4e807f in HandleDynamicTypeCacheMiss(__ubsan::DynamicTypeCacheMissData*, unsigned long, unsigned long, __ubsan::ReportOptions)
+# 2 0x4e8051 in __ubsan_handle_dynamic_type_cache_miss
+# 3 0x7f02ce676cd8 in JIT_InitPInvokeFrame(InlinedCallFrame*, void*) /home/steveharter/git/dotnet_coreclr/vm/jithelpers.cpp:6491:9
+# 4 0x7f0252bbceb2 (<unknown module>)
+fun:_Z20JIT_InitPInvokeFrameP16InlinedCallFramePv
+
+++ /dev/null
-# This file has exclusions to the Clang address sanitizer to suppress error reports
-# When Clang 3.8 is available, convert these to suppression list instead as that is preferred for internal code
-
-# CMiniMdBase::UsesAllocatedMemory - suppress stack-buffer-underflow (code backs up pointer by -1 to check allocation ownership)
-fun:_ZN11CMiniMdBase19UsesAllocatedMemoryEP11CMiniColDef
-
-# JIT_InitPInvokeFrame - suppress unknown sanitizer issue causing SEGV on unknown address 0x000000000000
-# 0 0x4e8a0c in __ubsan::checkDynamicType(void*, void*, unsigned long)
-# 1 0x4e807f in HandleDynamicTypeCacheMiss(__ubsan::DynamicTypeCacheMissData*, unsigned long, unsigned long, __ubsan::ReportOptions)
-# 2 0x4e8051 in __ubsan_handle_dynamic_type_cache_miss
-# 3 0x7f02ce676cd8 in JIT_InitPInvokeFrame(InlinedCallFrame*, void*) /home/steveharter/git/dotnet_coreclr/vm/jithelpers.cpp:6491:9
-# 4 0x7f0252bbceb2 (<unknown module>)
-fun:_Z20JIT_InitPInvokeFrameP16InlinedCallFramePv
-
set(CROSS_ROOTFS $ENV{ROOTFS_DIR})
set(TARGET_ARCH_NAME $ENV{TARGET_BUILD_ARCH})
+# Also allow building as Android without specifying `-cross`.
+if(NOT DEFINED TARGET_ARCH_NAME AND DEFINED ANDROID_PLATFORM)
+ if(ANDROID_ABI STREQUAL "arm64-v8a")
+ set(TARGET_ARCH_NAME "arm64")
+ elseif(ANDROID_ABI STREQUAL "x86_64")
+ set(TARGET_ARCH_NAME "x64")
+ elseif(ANDROID_ABI STREQUAL "armeabi-v7a")
+ set(TARGET_ARCH_NAME "arm")
+ elseif(ANDROID_ABI STREQUAL "x86")
+ set(TARGET_ARCH_NAME "x86")
+ else()
+ message(FATAL_ERROR "ANDROID_ABI ${ANDROID_ABI} not recognized!")
+ endif()
+endif()
+
macro(set_cache_value)
set(${ARGV0} ${ARGV1} CACHE STRING "Result from TRY_RUN" FORCE)
set(${ARGV0}__TRYRUN_OUTPUT "dummy output" CACHE STRING "Output from TRY_RUN" FORCE)
if(EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/armv7-alpine-linux-musleabihf OR
EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/armv6-alpine-linux-musleabihf OR
- EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/aarch64-alpine-linux-musl)
+ EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/aarch64-alpine-linux-musl OR
+ EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/s390x-alpine-linux-musl OR
+ EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/ppc64le-alpine-linux-musl OR
+ EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/i586-alpine-linux-musl OR
+ EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/x86_64-alpine-linux-musl OR
+ EXISTS ${CROSS_ROOTFS}/usr/lib/gcc/riscv64-alpine-linux-musl)
set(ALPINE_LINUX 1)
elseif(EXISTS ${CROSS_ROOTFS}/bin/freebsd-version)
set(FREEBSD 1)
set(CMAKE_SYSTEM_NAME FreeBSD)
- set(CLR_CMAKE_TARGET_OS FreeBSD)
+ set(CLR_CMAKE_TARGET_OS freebsd)
elseif(EXISTS ${CROSS_ROOTFS}/usr/platform/i86pc)
set(ILLUMOS 1)
- set(CLR_CMAKE_TARGET_OS SunOS)
+ set(CLR_CMAKE_TARGET_OS sunos)
elseif(EXISTS /System/Library/CoreServices)
set(DARWIN 1)
elseif(EXISTS ${CROSS_ROOTFS}/etc/tizen-release)
set(TIZEN 1)
+elseif(EXISTS ${CROSS_ROOTFS}/boot/system/develop/headers/config/HaikuConfig.h)
+ set(HAIKU 1)
+ set(CLR_CMAKE_TARGET_OS haiku)
endif()
if(DARWIN)
if(TARGET_ARCH_NAME MATCHES "^(arm64|x64)$")
set_cache_value(FILE_OPS_CHECK_FERROR_OF_PREVIOUS_CALL_EXITCODE 1)
- set_cache_value(GETPWUID_R_SETS_ERRNO_EXITCODE 1)
set_cache_value(HAS_POSIX_SEMAPHORES_EXITCODE 1)
set_cache_value(HAVE_BROKEN_FIFO_KEVENT_EXITCODE 1)
set_cache_value(HAVE_BROKEN_FIFO_SELECT_EXITCODE 1)
set_cache_value(PTHREAD_CREATE_MODIFIES_ERRNO_EXITCODE 1)
set_cache_value(REALPATH_SUPPORTS_NONEXISTENT_FILES_EXITCODE 1)
set_cache_value(SEM_INIT_MODIFIES_ERRNO_EXITCODE 1)
- set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 1)
set_cache_value(SSCANF_SUPPORT_ll_EXITCODE 0)
set_cache_value(UNGETC_NOT_RETURN_EOF_EXITCODE 1)
set_cache_value(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP_EXITCODE 1)
+ set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 1)
else()
message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only arm64 or x64 is supported for OSX cross build!")
endif()
-elseif(TARGET_ARCH_NAME MATCHES "^(armel|arm|armv6|arm64|loongarch64|riscv64|s390x|ppc64le|x86)$" OR FREEBSD OR ILLUMOS OR TIZEN)
+elseif(TARGET_ARCH_NAME MATCHES "^(armel|arm|armv6|arm64|loongarch64|riscv64|s390x|ppc64le|x86|x64)$" OR FREEBSD OR ILLUMOS OR TIZEN OR HAIKU)
set_cache_value(FILE_OPS_CHECK_FERROR_OF_PREVIOUS_CALL_EXITCODE 1)
- set_cache_value(GETPWUID_R_SETS_ERRNO_EXITCODE 0)
set_cache_value(HAS_POSIX_SEMAPHORES_EXITCODE 0)
set_cache_value(HAVE_CLOCK_MONOTONIC_COARSE_EXITCODE 0)
set_cache_value(HAVE_CLOCK_MONOTONIC_EXITCODE 0)
set_cache_value(HAVE_LARGE_SNPRINTF_SUPPORT_EXITCODE 0)
set_cache_value(HAVE_MMAP_DEV_ZERO_EXITCODE 0)
set_cache_value(HAVE_PROCFS_CTL_EXITCODE 1)
- set_cache_value(HAVE_PROCFS_MAPS_EXITCODE 0)
- set_cache_value(HAVE_PROCFS_STATUS_EXITCODE 0)
set_cache_value(HAVE_PROCFS_STAT_EXITCODE 0)
set_cache_value(HAVE_SCHED_GETCPU_EXITCODE 0)
set_cache_value(HAVE_SCHED_GET_PRIORITY_EXITCODE 0)
set_cache_value(PTHREAD_CREATE_MODIFIES_ERRNO_EXITCODE 1)
set_cache_value(REALPATH_SUPPORTS_NONEXISTENT_FILES_EXITCODE 1)
set_cache_value(SEM_INIT_MODIFIES_ERRNO_EXITCODE 1)
-
+ set_cache_value(HAVE_TERMIOS2_EXITCODE 0)
+ set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 0)
+ set_cache_value(HAVE_PROCFS_MAPS_EXITCODE 0)
+ set_cache_value(HAVE_PROCFS_STATUS_EXITCODE 0)
if(ALPINE_LINUX)
set_cache_value(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP_EXITCODE 1)
- set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 0)
set_cache_value(SSCANF_SUPPORT_ll_EXITCODE 1)
set_cache_value(UNGETC_NOT_RETURN_EOF_EXITCODE 1)
+ set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 0)
else()
set_cache_value(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP_EXITCODE 0)
- set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 1)
set_cache_value(SSCANF_SUPPORT_ll_EXITCODE 0)
set_cache_value(UNGETC_NOT_RETURN_EOF_EXITCODE 0)
+ set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 1)
endif()
if (FREEBSD)
set_cache_value(HAVE_PROCFS_MAPS 0)
set_cache_value(HAVE_PROCFS_STAT 0)
set_cache_value(HAVE_PROCFS_STATUS_EXITCODE 1)
- set_cache_value(GETPWUID_R_SETS_ERRNO 0)
set_cache_value(UNGETC_NOT_RETURN_EOF 0)
set_cache_value(HAVE_COMPATIBLE_ILOGBNAN 1)
set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 0)
+ set_cache_value(HAVE_TERMIOS2_EXITCODE 1)
elseif(ILLUMOS)
- set_cache_value(GETPWUID_R_SETS_ERRNO_EXITCODE 1)
set_cache_value(HAVE_COMPATIBLE_ACOS_EXITCODE 1)
set_cache_value(HAVE_COMPATIBLE_ASIN_EXITCODE 1)
set_cache_value(HAVE_COMPATIBLE_ATAN2_EXITCODE 1)
set_cache_value(HAVE_COMPATIBLE_LOG_EXITCODE 1)
set_cache_value(HAVE_LARGE_SNPRINTF_SUPPORT_EXITCODE 1)
set_cache_value(HAVE_PROCFS_CTL_EXITCODE 0)
- set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 1)
set_cache_value(SSCANF_SUPPORT_ll_EXITCODE 1)
set_cache_value(UNGETC_NOT_RETURN_EOF_EXITCODE 0)
set_cache_value(COMPILER_SUPPORTS_W_CLASS_MEMACCESS 1)
set_cache_value(HAVE_SET_MAX_VARIABLE 1)
set_cache_value(HAVE_FULLY_FEATURED_PTHREAD_MUTEXES 1)
set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 0)
+ set_cache_value(HAVE_TERMIOS2_EXITCODE 1)
+ set_cache_value(SSCANF_CANNOT_HANDLE_MISSING_EXPONENT_EXITCODE 1)
elseif (TIZEN)
set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 0)
+ elseif(HAIKU)
+ set_cache_value(HAVE_CLOCK_MONOTONIC_COARSE_EXITCODE 1)
+ set_cache_value(HAVE_COMPATIBLE_EXP_EXITCODE 0)
+ set_cache_value(HAVE_COMPATIBLE_ILOGBNAN_EXITCODE 0)
+ set_cache_value(HAVE_PROCFS_STAT_EXITCODE 1)
endif()
else()
- message(FATAL_ERROR "Arch is ${TARGET_ARCH_NAME}. Only armel, arm, armv6, arm64, loongarch64, s390x, ppc64le and x86 are supported!")
+ message(FATAL_ERROR "Unsupported platform. OS: ${CMAKE_SYSTEM_NAME}, arch: ${TARGET_ARCH_NAME}")
endif()
-if(TARGET_ARCH_NAME MATCHES "^(x86|s390x|armv6|loongarch64|riscv64|ppc64le)$")
+if(TARGET_ARCH_NAME MATCHES "^(x86|x64|s390x|armv6|loongarch64|ppc64le)$")
set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 0)
+elseif (TARGET_ARCH_NAME STREQUAL "riscv64")
+ set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 1)
endif()
--- /dev/null
+macro(set_cache_value)
+ set(${ARGV0} ${ARGV1} CACHE STRING "Result from TRY_RUN" FORCE)
+ set(${ARGV0}__TRYRUN_OUTPUT "dummy output" CACHE STRING "Output from TRY_RUN" FORCE)
+endmacro()
+
+set_cache_value(HAVE_SCHED_GETCPU_EXITCODE 1)
+set_cache_value(HAVE_CLOCK_MONOTONIC_COARSE_EXITCODE 1)
+set_cache_value(HAVE_CLOCK_MONOTONIC_EXITCODE 0)
+
+
+# TODO: these are taken from macOS, check these whether they're correct for iOS
+# some of them are probably not used by what we use from NativeAOT so could be reduced
+set_cache_value(FILE_OPS_CHECK_FERROR_OF_PREVIOUS_CALL_EXITCODE 1)
+set_cache_value(HAS_POSIX_SEMAPHORES_EXITCODE 1)
+set_cache_value(HAVE_BROKEN_FIFO_KEVENT_EXITCODE 1)
+set_cache_value(HAVE_BROKEN_FIFO_SELECT_EXITCODE 1)
+set_cache_value(HAVE_CLOCK_REALTIME_EXITCODE 0)
+set_cache_value(HAVE_CLOCK_THREAD_CPUTIME_EXITCODE 0)
+set_cache_value(HAVE_CLOCK_GETTIME_NSEC_NP_EXITCODE 0)
+set_cache_value(HAVE_COMPATIBLE_ACOS_EXITCODE 0)
+set_cache_value(HAVE_COMPATIBLE_ASIN_EXITCODE 0)
+set_cache_value(HAVE_COMPATIBLE_ATAN2_EXITCODE 0)
+set_cache_value(HAVE_COMPATIBLE_EXP_EXITCODE 1)
+set_cache_value(HAVE_COMPATIBLE_ILOGB0_EXITCODE 0)
+set_cache_value(HAVE_COMPATIBLE_ILOGBNAN_EXITCODE 1)
+set_cache_value(HAVE_COMPATIBLE_LOG10_EXITCODE 0)
+set_cache_value(HAVE_COMPATIBLE_LOG_EXITCODE 0)
+set_cache_value(HAVE_COMPATIBLE_POW_EXITCODE 0)
+set_cache_value(HAVE_FUNCTIONAL_PTHREAD_ROBUST_MUTEXES_EXITCODE 1)
+set_cache_value(HAVE_LARGE_SNPRINTF_SUPPORT_EXITCODE 0)
+set_cache_value(HAVE_MMAP_DEV_ZERO_EXITCODE 1)
+set_cache_value(HAVE_PROCFS_CTL_EXITCODE 1)
+set_cache_value(HAVE_PROCFS_STAT_EXITCODE 1)
+set_cache_value(HAVE_SCHED_GET_PRIORITY_EXITCODE 0)
+set_cache_value(HAVE_VALID_NEGATIVE_INF_POW_EXITCODE 0)
+set_cache_value(HAVE_VALID_POSITIVE_INF_POW_EXITCODE 0)
+set_cache_value(HAVE_WORKING_CLOCK_GETTIME_EXITCODE 0)
+set_cache_value(HAVE_WORKING_GETTIMEOFDAY_EXITCODE 0)
+set_cache_value(MMAP_ANON_IGNORES_PROTECTION_EXITCODE 1)
+set_cache_value(ONE_SHARED_MAPPING_PER_FILEREGION_PER_PROCESS_EXITCODE 1)
+set_cache_value(PTHREAD_CREATE_MODIFIES_ERRNO_EXITCODE 1)
+set_cache_value(REALPATH_SUPPORTS_NONEXISTENT_FILES_EXITCODE 1)
+set_cache_value(SEM_INIT_MODIFIES_ERRNO_EXITCODE 1)
+set_cache_value(SSCANF_SUPPORT_ll_EXITCODE 0)
+set_cache_value(UNGETC_NOT_RETURN_EOF_EXITCODE 1)
+set_cache_value(HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP_EXITCODE 1)
@if not defined _echo @echo off
setlocal EnableDelayedExpansion EnableExtensions
-set __VersionFolder=%~dp0
-set __RepoRoot=%~dp0..\..\..
-set __artifactsObjDir=%__RepoRoot%\artifacts\obj
+set "__VersionFolder=%~dp0"
+set "__RepoRoot=%~dp0..\..\.."
+:: normalize
+for %%i in ("%__RepoRoot%") do set "__RepoRoot=%%~fi"
+set "__artifactsObjDir=%__RepoRoot%\artifacts\obj"
for /r "%__VersionFolder%" %%a in (*.h *.rc) do (
if not exist "%__artifactsObjDir%\%%~nxa" (
downloadPath: '$(Build.ArtifactStagingDirectory)/__download__'
downloadType: specific
itemPattern: |
- Build_$(_BuildConfig)/bin/Linux${{ parameters.osSuffix }}.$(_BuildArch).$(_BuildConfig)/**
+ Build_$(_BuildConfig)/bin/linux${{ parameters.osSuffix }}.$(_BuildArch).$(_BuildConfig)/**
checkDownloadedFiles: true
- task: CopyFiles@2
displayName: 'Binplace Product'
inputs:
- sourceFolder: $(Build.ArtifactStagingDirectory)/__download__/Build_$(_BuildConfig)/bin/Linux${{ parameters.osSuffix }}.$(_BuildArch).$(_BuildConfig)
- targetFolder: '$(Build.SourcesDirectory)/artifacts/bin/Linux.$(_BuildArch).$(_BuildConfig)'
+ sourceFolder: $(Build.ArtifactStagingDirectory)/__download__/Build_$(_BuildConfig)/bin/linux${{ parameters.osSuffix }}.$(_BuildArch).$(_BuildConfig)
+ targetFolder: '$(Build.SourcesDirectory)/artifacts/bin/linux.$(_BuildArch).$(_BuildConfig)'
- ${{ if eq(parameters.isCodeQLRun, 'true') }}:
- task: CodeQL3000Init@0
["Timestamp"] = GetTimeStampText(),
["TempPath"] = Path.GetTempPath(),
["WorkingDir"] = GetInitialWorkingDir(),
- ["OS"] = OS.Kind.ToString(),
+ ["OS"] = OS.Kind.ToString().ToLowerInvariant(),
["IsAlpine"] = OS.IsAlpine.ToString().ToLowerInvariant(),
["TargetRid"] = GetRid(),
["TargetArchitecture"] = OS.TargetArchitecture.ToString().ToLowerInvariant(),
<HostArgs Condition="'$(SetFxVersion)' == 'true'">--fx-version $(FrameworkVersion)</HostArgs>
<Options>
- <Option Condition="$(OS) == Linux">
+ <Option Condition="'$(OS)' == 'linux'">
<SOSPath>$(InstallDir)/libsosplugin.so</SOSPath>
</Option>
- <Option Condition="$(OS) == OSX">
+ <Option Condition="'$(OS)' == 'osx'">
<SOSPath>$(InstallDir)/libsosplugin.dylib</SOSPath>
</Option>
</Options>
#cmakedefine01 HAVE_COMPATIBLE_LOG10
#cmakedefine01 UNGETC_NOT_RETURN_EOF
#cmakedefine01 HAS_POSIX_SEMAPHORES
-#cmakedefine01 GETPWUID_R_SETS_ERRNO
#cmakedefine01 FILE_OPS_CHECK_FERROR_OF_PREVIOUS_CALL
#define PAL_THREAD_PRIORITY_MIN 0
exit(0);
}" HAS_POSIX_SEMAPHORES)
set(CMAKE_REQUIRED_LIBRARIES)
-check_cxx_source_runs("
-#include <sys/types.h>
-#include <pwd.h>
-#include <errno.h>
-#include <unistd.h>
-#include <stdlib.h>
-
-int main(void)
-{
- struct passwd sPasswd;
- struct passwd *pPasswd;
- char buf[1];
- int bufLen = sizeof(buf)/sizeof(buf[0]);
- int euid = geteuid();
- int ret = 0;
-
- errno = 0; // clear errno
- ret = getpwuid_r(euid, &sPasswd, buf, bufLen, &pPasswd);
- if (0 != ret)
- {
- if (ERANGE == errno)
- {
- return 0;
- }
- }
- return 1; // assume errno is NOT set for all other cases
-}" GETPWUID_R_SETS_ERRNO)
check_cxx_source_runs("
#include <stdio.h>
#include <stdlib.h>
<!-- Run OpenVirtualProcess tests on Linux -->
<RunTestsLinux_x64>false</RunTestsLinux_x64>
- <RunTestsLinux_x64 Condition="'$(OS)' == 'Linux'">true</RunTestsLinux_x64>
+ <RunTestsLinux_x64 Condition="'$(OS)' == 'linux'">true</RunTestsLinux_x64>
<RunTestsLinux_x64 Condition="'$(TargetArchitecture)' != 'x64'">false</RunTestsLinux_x64>
<RunTestsLinux_arm64>false</RunTestsLinux_arm64>
- <RunTestsLinux_arm64 Condition="'$(OS)' == 'Linux'">true</RunTestsLinux_arm64>
+ <RunTestsLinux_arm64 Condition="'$(OS)' == 'linux'">true</RunTestsLinux_arm64>
<RunTestsLinux_arm64 Condition="'$(TargetArchitecture)' != 'arm64'">false</RunTestsLinux_arm64>
<Options>
<RuntimeModuleDir>$(DotNetRoot)/shared/Microsoft.NETCore.App/$(RuntimeFrameworkVersion)</RuntimeModuleDir>
<Options>
- <Option Condition="'$(OS)' == 'Linux'">
+ <Option Condition="'$(OS)' == 'linux'">
<DbgShimPath>$(InstallDir)/libdbgshim.so</DbgShimPath>
<RuntimeModulePath Condition="'$(RuntimeModuleDir)' != ''">$(RuntimeModuleDir)/libcoreclr.so</RuntimeModulePath>
<DbiModulePath Condition="'$(RuntimeModuleDir)' != ''">$(RuntimeModuleDir)/libmscordbi.so</DbiModulePath>
<DacModulePath Condition="'$(RuntimeModuleDir)' != ''">$(RuntimeModuleDir)/libmscordaccore.so</DacModulePath>
</Option>
- <Option Condition="'$(OS)' == 'OSX'">
+ <Option Condition="'$(OS)' == 'osx'">
<DbgShimPath>$(InstallDir)/libdbgshim.dylib</DbgShimPath>
<RuntimeModulePath Condition="'$(RuntimeModuleDir)' != ''">$(RuntimeModuleDir)/libcoreclr.dylib</RuntimeModulePath>
<DbiModulePath Condition="'$(RuntimeModuleDir)' != ''">$(RuntimeModuleDir)/libmscordbi.dylib</DbiModulePath>
<InstallDir>$(RootBinDir)/bin/$(OS).$(TargetArchitecture).$(TargetConfiguration)</InstallDir>
<Options>
- <Option Condition="'$(OS)' == 'Linux'">
+ <Option Condition="'$(OS)' == 'linux'">
<SOSPath>$(InstallDir)/libsosplugin.so</SOSPath>
</Option>
- <Option Condition="'$(OS)' == 'OSX'">
+ <Option Condition="'$(OS)' == 'osx'">
<SOSPath>$(InstallDir)/libsosplugin.dylib</SOSPath>
</Option>
</Options>
<!-- Run tests on Linux -->
<RunTestsLinux_x64>false</RunTestsLinux_x64>
- <RunTestsLinux_x64 Condition="'$(OS)' == 'Linux'">$(RunTests)</RunTestsLinux_x64>
+ <RunTestsLinux_x64 Condition="'$(OS)' == 'linux'">$(RunTests)</RunTestsLinux_x64>
<RunTestsLinux_x64 Condition="'$(TargetArchitecture)' != 'x64'">false</RunTestsLinux_x64>
<RunTestsLinux_arm64>false</RunTestsLinux_arm64>
- <RunTestsLinux_arm64 Condition="'$(OS)' == 'Linux'">$(RunTests)</RunTestsLinux_arm64>
+ <RunTestsLinux_arm64 Condition="'$(OS)' == 'linux'">$(RunTests)</RunTestsLinux_arm64>
<RunTestsLinux_arm64 Condition="'$(TargetArchitecture)' != 'arm64'">false</RunTestsLinux_arm64>
<!-- Linux x64 testing -->
<!-- Run tests on OSX x64 -->
<RunTestsOSX>false</RunTestsOSX>
- <RunTestsOSX Condition="'$(OS)' == 'OSX'">true</RunTestsOSX>
+ <RunTestsOSX Condition="'$(OS)' == 'osx'">true</RunTestsOSX>
<RunTestsOSX Condition="'$(TargetArchitecture)' == 'arm'">false</RunTestsOSX>
<RunTestsOSX Condition="'$(TargetArchitecture)' == 'arm64'">false</RunTestsOSX>
{
Dictionary<string, string> initialConfig = new()
{
- ["OS"] = OS.Kind.ToString(),
+ ["OS"] = OS.Kind.ToString().ToLowerInvariant(),
["TargetArchitecture"] = OS.TargetArchitecture.ToString().ToLowerInvariant(),
["TestDataFile"] = TestDataPath,
};
projects / platform / core / dotnet / diagnostics.git / commitdiff