CMakeLists.txt

   1 # Require at least version 2.8.12 of CMake
   2 cmake_minimum_required(VERSION 2.8.12)
   3
   4 # Set the project name
   5 project(CoreCLR)
   6
   7 set(CORECLR_SET_RPATH ON)
   8
   9 if(CORECLR_SET_RPATH)
  10     # Enable @rpath support for shared libraries.
  11     set(MACOSX_RPATH ON)
  12 endif(CORECLR_SET_RPATH)
  13
  14 if(CMAKE_VERSION VERSION_EQUAL 3.0 OR CMAKE_VERSION VERSION_GREATER 3.0)
  15     cmake_policy(SET CMP0042 NEW)
  16 endif()
  17
  18 set(CLR_DIR ${CMAKE_CURRENT_SOURCE_DIR})
  19 set(VM_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/vm)
  20 set(GENERATED_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/src/inc)
  21
  22 function(clr_unknown_arch)
  23     if (WIN32)
  24         message(FATAL_ERROR "Only AMD64, ARM64 and I386 are supported")
  25     else()
  26         message(FATAL_ERROR "Only AMD64, ARM64 and ARM are supported")
  27     endif()
  28 endfunction()
  29
  30 if(CMAKE_SYSTEM_NAME STREQUAL Linux)
  31     set(CLR_CMAKE_PLATFORM_UNIX 1)
  32     if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64)
  33         set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
  34     elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL armv7l)
  35         set(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM 1)
  36         # Because we don't use CMAKE_C_COMPILER/CMAKE_CXX_COMPILER to use clang
  37         # we have to set the triple by adding a compiler argument
  38         add_compile_options(-target armv7-linux-gnueabihf)
  39         add_compile_options(-mthumb)
  40         add_compile_options(-mfpu=vfpv3)
  41     elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
  42         set(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64 1)
  43     else()
  44         clr_unknown_arch()
  45     endif()
  46     set(CLR_CMAKE_PLATFORM_LINUX 1)
  47 endif(CMAKE_SYSTEM_NAME STREQUAL Linux)
  48
  49 if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
  50   set(CLR_CMAKE_PLATFORM_UNIX 1)
  51   set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
  52   set(CLR_CMAKE_PLATFORM_DARWIN 1)
  53   if(CMAKE_VERSION VERSION_LESS "3.4.0")
  54     set(CMAKE_ASM_COMPILE_OBJECT "${CMAKE_C_COMPILER} <FLAGS> <DEFINES> -o <OBJECT> -c <SOURCE>")
  55   else()
  56     set(CMAKE_ASM_COMPILE_OBJECT "${CMAKE_C_COMPILER} <FLAGS> <DEFINES> <INCLUDES> -o <OBJECT> -c <SOURCE>")
  57   endif(CMAKE_VERSION VERSION_LESS "3.4.0")
  58 endif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
  59
  60 if(CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
  61   set(CLR_CMAKE_PLATFORM_UNIX 1)
  62   set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
  63   set(CLR_CMAKE_PLATFORM_FREEBSD 1)
  64 endif(CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
  65
  66 if(CMAKE_SYSTEM_NAME STREQUAL OpenBSD)
  67   set(CLR_CMAKE_PLATFORM_UNIX 1)
  68   set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
  69   set(CLR_CMAKE_PLATFORM_OPENBSD 1)
  70 endif(CMAKE_SYSTEM_NAME STREQUAL OpenBSD)
  71
  72 if(CMAKE_SYSTEM_NAME STREQUAL NetBSD)
  73   set(CLR_CMAKE_PLATFORM_UNIX 1)
  74   set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
  75   set(CLR_CMAKE_PLATFORM_NETBSD 1)
  76 endif(CMAKE_SYSTEM_NAME STREQUAL NetBSD)
  77
  78 if(CMAKE_SYSTEM_NAME STREQUAL SunOS)
  79   set(CLR_CMAKE_PLATFORM_UNIX 1)
  80   EXECUTE_PROCESS(
  81     COMMAND isainfo -n
  82     OUTPUT_VARIABLE SUNOS_NATIVE_INSTRUCTION_SET
  83     )
  84   if(SUNOS_NATIVE_INSTRUCTION_SET MATCHES "amd64")
  85     set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
  86     set(CMAKE_SYSTEM_PROCESSOR "amd64")
  87   else()
  88     clr_unknown_arch()
  89   endif()
  90   set(CLR_CMAKE_PLATFORM_SUNOS 1)
  91 endif(CMAKE_SYSTEM_NAME STREQUAL SunOS)
  92
  93 if(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
  94   set(CLR_CMAKE_PLATFORM_ARCH_ARM 1)
  95 elseif(CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64)
  96   set(CLR_CMAKE_PLATFORM_ARCH_ARM64 1)
  97 elseif(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
  98   set(CLR_CMAKE_PLATFORM_ARCH_AMD64 1)
  99 elseif(WIN32)
 100   if (CLR_CMAKE_TARGET_ARCH STREQUAL x64)
 101     set(CLR_CMAKE_PLATFORM_ARCH_AMD64 1)
 102     set(IS_64BIT_BUILD 1)
 103   elseif(CLR_CMAKE_TARGET_ARCH STREQUAL x86)
 104     set(CLR_CMAKE_PLATFORM_ARCH_I386 1)
 105     set(IS_64BIT_BUILD 0)
 106   elseif(CLR_CMAKE_TARGET_ARCH STREQUAL arm64)
 107     set(CLR_CMAKE_PLATFORM_ARCH_ARM64 1)
 108     set(IS_64BIT_BUILD 1)
 109
 110     # CMAKE_CXX_COMPILER will default to the compiler installed with
 111     # Visual studio. Overwrite it to the compiler on the path.
 112     # TODO, remove when cmake generator supports Arm64 as a target.
 113
 114     find_program(PATH_CXX_COMPILER cl)
 115     set(CMAKE_CXX_COMPILER ${PATH_CXX_COMPILER})
 116
 117     message("Overwriting the CMAKE_CXX_COMPILER.")
 118     message(CMAKE_CXX_COMPILER found:${CMAKE_CXX_COMPILER})
 119   else()
 120     clr_unknown_arch()
 121   endif()
 122 endif()
 123
 124 if(CLR_CMAKE_PLATFORM_UNIX)
 125   # Set flag to indicate if this will be a 64bit build
 126   # CMAKE_SYSTEM_PROCESSOR returns the value of `uname -p`.
 127   # For the AMD/Intel 64bit architecure two different strings are common.
 128   # Linux and Darwin identify it as "x86_64" while FreeBSD uses the
 129   # "amd64" string. Accept either of the two here.
 130   if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
 131     set(IS_64BIT_BUILD 1)
 132   endif (CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL aarch64)
 133 endif(CLR_CMAKE_PLATFORM_UNIX)
 134
 135 # Ensure that python is present
 136 find_program(PYTHON python)
 137 if (PYTHON STREQUAL "PYTHON-NOTFOUND")
 138     message(FATAL_ERROR "PYTHON not found: Please install Python 2.7.9 or later from https://www.python.org/downloads/")
 139 endif()
 140
 141 if(WIN32)
 142     enable_language(ASM_MASM)
 143
 144     # Ensure that MC is present
 145     find_program(MC mc)
 146     if (MC STREQUAL "MC-NOTFOUND")
 147         message(FATAL_ERROR "MC not found")
 148     endif()
 149 else()
 150     enable_language(ASM)
 151
 152     # Ensure that awk is present
 153     find_program(AWK awk)
 154     if (AWK STREQUAL "AWK-NOTFOUND")
 155         message(FATAL_ERROR "AWK not found")
 156     endif()
 157 endif(WIN32)
 158
 159 # Build a list of compiler definitions by putting -D in front of each define.
 160 function(get_compile_definitions DefinitionName)
 161     # Get the current list of definitions
 162     get_directory_property(COMPILE_DEFINITIONS_LIST COMPILE_DEFINITIONS)
 163
 164     foreach(DEFINITION IN LISTS COMPILE_DEFINITIONS_LIST)
 165         if (${DEFINITION} MATCHES "^\\$<\\$<CONFIG:([^>]+)>:([^>]+)>$")
 166             # The entries that contain generator expressions must have the -D inside of the
 167             # expression. So we transform e.g. $<$<CONFIG:Debug>:_DEBUG> to $<$<CONFIG:Debug>:-D_DEBUG>
 168             set(DEFINITION "$<$<CONFIG:${CMAKE_MATCH_1}>:-D${CMAKE_MATCH_2}>")
 169         else()
 170             set(DEFINITION -D${DEFINITION})
 171         endif()
 172         list(APPEND DEFINITIONS ${DEFINITION})
 173     endforeach()
 174     set(${DefinitionName} ${DEFINITIONS} PARENT_SCOPE)
 175 endfunction(get_compile_definitions)
 176
 177 # Build a list of include directories by putting -I in front of each include dir.
 178 function(get_include_directories IncludeDirectories)
 179     get_directory_property(dirs INCLUDE_DIRECTORIES)
 180     foreach(dir IN LISTS dirs)
 181         list(APPEND INC_DIRECTORIES -I${dir})
 182     endforeach()
 183     set(${IncludeDirectories} ${INC_DIRECTORIES} PARENT_SCOPE)
 184 endfunction(get_include_directories)
 185
 186 # Set the passed in RetSources variable to the list of sources with added current source directory
 187 # to form absolute paths.
 188 # The parameters after the RetSources are the input files.
 189 function(convert_to_absolute_path RetSources)
 190     set(Sources ${ARGN})
 191     foreach(Source IN LISTS Sources)
 192         list(APPEND AbsolutePathSources ${CMAKE_CURRENT_SOURCE_DIR}/${Source})
 193     endforeach()
 194     set(${RetSources} ${AbsolutePathSources} PARENT_SCOPE)
 195 endfunction(convert_to_absolute_path)
 196
 197 #Preprocess exports definition file
 198 function(preprocess_def_file inputFilename outputFilename)
 199   get_compile_definitions(PREPROCESS_DEFINITIONS)
 200
 201   add_custom_command(
 202     OUTPUT ${outputFilename}
 203     COMMAND ${CMAKE_CXX_COMPILER} /P /EP /TC ${PREPROCESS_DEFINITIONS}  /Fi${outputFilename}  ${inputFilename}
 204     DEPENDS ${inputFilename}
 205     COMMENT "Preprocessing ${inputFilename}"
 206   )
 207
 208   set_source_files_properties(${outputFilename}
 209                               PROPERTIES GENERATED TRUE)
 210 endfunction()
 211
 212 function(generate_exports_file inputFilename outputFilename)
 213
 214   if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 215     set(AWK_SCRIPT generateexportedsymbols.awk)
 216   else()
 217     set(AWK_SCRIPT generateversionscript.awk)
 218   endif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 219
 220   add_custom_command(
 221     OUTPUT ${outputFilename}
 222     COMMAND ${AWK} -f ${CMAKE_SOURCE_DIR}/${AWK_SCRIPT} ${inputFilename} >${outputFilename}
 223     DEPENDS ${inputFilename} ${CMAKE_SOURCE_DIR}/${AWK_SCRIPT}
 224     COMMENT "Generating exports file ${outputFilename}"
 225   )
 226   set_source_files_properties(${outputFilename}
 227                               PROPERTIES GENERATED TRUE)
 228 endfunction()
 229
 230 function(add_precompiled_header header cppFile targetSources)
 231   if(MSVC)
 232     set(precompiledBinary "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/stdafx.pch")
 233
 234     set_source_files_properties(${cppFile}
 235                                 PROPERTIES COMPILE_FLAGS "/Yc\"${header}\" /Fp\"${precompiledBinary}\""
 236                                            OBJECT_OUTPUTS "${precompiledBinary}")
 237     set_source_files_properties(${${targetSources}}
 238                                 PROPERTIES COMPILE_FLAGS "/Yu\"${header}\" /Fp\"${precompiledBinary}\""
 239                                            OBJECT_DEPENDS "${precompiledBinary}")
 240     # Add cppFile to SourcesVar
 241     set(${targetSources} ${${targetSources}} ${cppFile} PARENT_SCOPE)
 242   endif(MSVC)
 243 endfunction()
 244
 245 # Includes
 246
 247 if (CMAKE_CONFIGURATION_TYPES) # multi-configuration generator?
 248     set(CMAKE_CONFIGURATION_TYPES "Debug;Checked;Release;RelWithDebInfo" CACHE STRING "" FORCE)
 249 endif (CMAKE_CONFIGURATION_TYPES)
 250
 251 set(CMAKE_C_FLAGS_CHECKED ${CLR_C_FLAGS_CHECKED_INIT} CACHE STRING "Flags used by the compiler during checked builds.")
 252 set(CMAKE_CXX_FLAGS_CHECKED ${CLR_CXX_FLAGS_CHECKED_INIT} CACHE STRING "Flags used by the compiler during checked builds.")
 253 set(CMAKE_EXE_LINKER_FLAGS_CHECKED "")
 254 set(CMAKE_SHARED_LINKER_FLAGS_CHECKED "")
 255
 256 if (WIN32)
 257   # For multi-configuration toolset (as Visual Studio)
 258   # set the different configuration defines.
 259   foreach (Config DEBUG CHECKED RELEASE RELWITHDEBINFO)
 260     foreach (Definition IN LISTS CLR_DEFINES_${Config}_INIT)
 261       set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:${Config}>:${Definition}>)
 262     endforeach (Definition)
 263   endforeach (Config)
 264
 265 elseif (CLR_CMAKE_PLATFORM_UNIX)
 266   # Set the values to display when interactively configuring CMAKE_BUILD_TYPE
 267   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "DEBUG;CHECKED;RELEASE;RELWITHDEBINFO")
 268
 269   # Use uppercase CMAKE_BUILD_TYPE for the string comparisons below
 270   string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_CMAKE_BUILD_TYPE)
 271
 272   # For single-configuration toolset
 273   # set the different configuration defines.
 274   if (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG)
 275     # First DEBUG
 276     set_property(DIRECTORY  PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_DEBUG_INIT})
 277   elseif (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
 278     # Then CHECKED
 279     set_property(DIRECTORY PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_CHECKED_INIT})
 280   elseif (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELEASE)
 281     # Then RELEASE
 282     set_property(DIRECTORY PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_RELEASE_INIT})
 283   elseif (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELWITHDEBINFO)
 284     # And then RELWITHDEBINFO
 285     set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_RELWITHDEBINFO_INIT})
 286   else ()
 287     message(FATAL_ERROR "Unknown build type! Set CMAKE_BUILD_TYPE to DEBUG, CHECKED, RELEASE, or RELWITHDEBINFO!")
 288   endif ()
 289
 290 endif(WIN32)
 291
 292 if (CLR_CMAKE_PLATFORM_UNIX)
 293   add_definitions(-DPLATFORM_UNIX=1)
 294
 295   if(CLR_CMAKE_PLATFORM_LINUX)
 296     add_definitions(-D__LINUX__=1)
 297     if(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 298       message("Detected Linux x86_64")
 299       add_definitions(-DLINUX64)
 300     elseif(CLR_CMAKE_PLATFORM_ARCH_ARM)
 301       message("Detected Linux ARM")
 302       add_definitions(-DLINUX32)
 303     elseif(CLR_CMAKE_PLATFORM_ARCH_ARM64)
 304       message("Detected Linux ARM64")
 305       add_definitions(-DLINUX64)
 306     else()
 307       clr_unknown_arch()
 308     endif()
 309   endif(CLR_CMAKE_PLATFORM_LINUX)
 310
 311   if(CLR_CMAKE_PLATFORM_DARWIN)
 312     message("Detected OSX x86_64")
 313   endif(CLR_CMAKE_PLATFORM_DARWIN)
 314
 315   if(CLR_CMAKE_PLATFORM_FREEBSD)
 316     message("Detected FreeBSD amd64")
 317   endif(CLR_CMAKE_PLATFORM_FREEBSD)
 318
 319   # Disable frame pointer optimizations so profilers can get better call stacks
 320   add_compile_options(-fno-omit-frame-pointer)
 321
 322   # The -fms-extensions enable the stuff like __if_exists, __declspec(uuid()), etc.
 323   add_compile_options(-fms-extensions )
 324   #-fms-compatibility      Enable full Microsoft Visual C++ compatibility
 325   #-fms-extensions         Accept some non-standard constructs supported by the Microsoft compiler
 326
 327   if(CLR_CMAKE_PLATFORM_DARWIN)
 328     # We cannot enable "stack-protector-strong" on OS X due to a bug in clang compiler (current version 7.0.2)
 329     add_compile_options(-fstack-protector)
 330   else()
 331     add_compile_options(-fstack-protector-strong)
 332   endif(CLR_CMAKE_PLATFORM_DARWIN)
 333
 334   # set the CLANG sanitizer flags for debug build
 335   if(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
 336     # obtain settings from running enablesanitizers.sh
 337     string(FIND "$ENV{DEBUG_SANITIZERS}" "asan" __ASAN_POS)
 338     string(FIND "$ENV{DEBUG_SANITIZERS}" "ubsan" __UBSAN_POS)
 339     if ((${__ASAN_POS} GREATER -1) OR (${__UBSAN_POS} GREATER -1))
 340       set(CLR_SANITIZE_CXX_FLAGS "${CLR_SANITIZE_CXX_FLAGS} -fsanitize-blacklist=${CMAKE_CURRENT_SOURCE_DIR}/sanitizerblacklist.txt -fsanitize=")
 341       set(CLR_SANITIZE_LINK_FLAGS "${CLR_SANITIZE_LINK_FLAGS} -fsanitize=")
 342       if (${__ASAN_POS} GREATER -1)
 343         set(CLR_SANITIZE_CXX_FLAGS "${CLR_SANITIZE_CXX_FLAGS}address,")
 344         set(CLR_SANITIZE_LINK_FLAGS "${CLR_SANITIZE_LINK_FLAGS}address,")
 345         message("Address Sanitizer (asan) enabled")
 346       endif ()
 347       if (${__UBSAN_POS} GREATER -1)
 348         # all sanitizier flags are enabled except alignment (due to heavy use of __unaligned modifier)
 349         set(CLR_SANITIZE_CXX_FLAGS "${CLR_SANITIZE_CXX_FLAGS}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")
 350         set(CLR_SANITIZE_LINK_FLAGS "${CLR_SANITIZE_LINK_FLAGS}undefined")
 351         message("Undefined Behavior Sanitizer (ubsan) enabled")
 352       endif ()
 353
 354       # -fdata-sections -ffunction-sections: each function has own section instead of one per .o file (needed for --gc-sections)
 355       # -fPIC: enable Position Independent Code normally just for shared libraries but required when linking with address sanitizer
 356       # -O1: optimization level used instead of -O0 to avoid compile error "invalid operand for inline asm constraint"
 357       set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${CLR_SANITIZE_CXX_FLAGS} -fdata-sections -ffunction-sections -fPIC -O1")
 358       set(CMAKE_CXX_FLAGS_CHECKED "${CMAKE_CXX_FLAGS_CHECKED} ${CLR_SANITIZE_CXX_FLAGS} -fdata-sections -ffunction-sections -fPIC -O1")
 359
 360       set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${CLR_SANITIZE_LINK_FLAGS}")
 361       set(CMAKE_EXE_LINKER_FLAGS_CHECKED "${CMAKE_EXE_LINKER_FLAGS_CHECKED} ${CLR_SANITIZE_LINK_FLAGS}")
 362
 363       # -Wl and --gc-sections: drop unused sections\functions (similar to Windows /Gy function-level-linking)
 364       set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} ${CLR_SANITIZE_LINK_FLAGS} -Wl,--gc-sections")
 365       set(CMAKE_SHARED_LINKER_FLAGS_CHECKED "${CMAKE_SHARED_LINKER_FLAGS_CHECKED} ${CLR_SANITIZE_LINK_FLAGS} -Wl,--gc-sections")
 366     endif ()
 367   endif(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
 368
 369   add_definitions(-DDISABLE_CONTRACTS)
 370   # The -ferror-limit is helpful during the porting, it makes sure the compiler doesn't stop
 371   # after hitting just about 20 errors.
 372   add_compile_options(-ferror-limit=4096)
 373
 374   # All warnings that are not explicitly disabled are reported as errors
 375   add_compile_options(-Werror)
 376
 377   # Disabled warnings
 378   add_compile_options(-Wno-unused-private-field)
 379   add_compile_options(-Wno-unused-variable)
 380   # Explicit constructor calls are not supported by clang (this->ClassName::ClassName())
 381   add_compile_options(-Wno-microsoft)
 382   # This warning is caused by comparing 'this' to NULL
 383   add_compile_options(-Wno-tautological-compare)
 384   # There are constants of type BOOL used in a condition. But BOOL is defined as int
 385   # and so the compiler thinks that there is a mistake.
 386   add_compile_options(-Wno-constant-logical-operand)
 387
 388   add_compile_options(-Wno-unknown-warning-option)
 389
 390   #These seem to indicate real issues
 391   add_compile_options(-Wno-invalid-offsetof)
 392   # The following warning indicates that an attribute __attribute__((__ms_struct__)) was applied
 393   # to a struct or a class that has virtual members or a base class. In that case, clang
 394   # may not generate the same object layout as MSVC.
 395   add_compile_options(-Wno-incompatible-ms-struct)
 396
 397 endif(CLR_CMAKE_PLATFORM_UNIX)
 398
 399 if (WIN32)
 400   # Compile options for targeting windows
 401
 402   # The following options are set by the razzle build
 403   add_compile_options(/TP) # compile all files as C++
 404   add_compile_options(/d2Zi+) # make optimized builds debugging easier
 405   add_compile_options(/nologo) # Suppress Startup Banner
 406   add_compile_options(/W3) # set warning level to 3
 407   add_compile_options(/WX) # treat warnings as errors
 408   add_compile_options(/Oi) # enable intrinsics
 409   add_compile_options(/Oy-) # disable suppressing of the creation of frame pointers on the call stack for quicker function calls
 410   add_compile_options(/U_MT) # undefine the predefined _MT macro
 411   add_compile_options(/GF) # enable read-only string pooling
 412   add_compile_options(/Gm-) # disable minimal rebuild
 413   add_compile_options(/EHa) # enable C++ EH (w/ SEH exceptions)
 414   add_compile_options(/Zp8) # pack structs on 8-byte boundary
 415   add_compile_options(/GS) # enable security checks
 416   add_compile_options(/Gy) # separate functions for linker
 417   add_compile_options(/Zc:wchar_t-) # C++ language conformance: wchar_t is NOT the native type, but a typedef
 418   add_compile_options(/Zc:forScope) # C++ language conformance: enforce Standard C++ for scoping rules
 419   add_compile_options(/GR-) # disable C++ RTTI
 420   add_compile_options(/FC) # use full pathnames in diagnostics
 421   add_compile_options(/MP) # Build with Multiple Processes (number of processes equal to the number of processors)
 422   add_compile_options(/GS) # Buffer Security Check
 423   add_compile_options(/Zm200) # Specify Precompiled Header Memory Allocation Limit of 150MB
 424   add_compile_options(/wd4960 /wd4961 /wd4603 /wd4627 /wd4838 /wd4456 /wd4457 /wd4458 /wd4459 /wd4091 /we4640)
 425   add_compile_options(/Zi) # enable debugging information
 426
 427   if (CLR_CMAKE_PLATFORM_ARCH_I386)
 428     add_compile_options(/Gz)
 429   endif (CLR_CMAKE_PLATFORM_ARCH_I386)
 430
 431   add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:Relwithdebinfo>>:/GL>)
 432   add_compile_options($<$<OR:$<OR:$<CONFIG:Release>,$<CONFIG:Relwithdebinfo>>,$<CONFIG:Checked>>:/O1>)
 433
 434  if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 435   # The generator expression in the following command means that the /homeparams option is added only for debug builds
 436   add_compile_options($<$<CONFIG:Debug>:/homeparams>) # Force parameters passed in registers to be written to the stack
 437   endif (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 438
 439   if(NOT CLR_CMAKE_PLATFORM_ARCH_ARM64)
 440     # enable control-flow-guard support for native components for non-Arm64 builds
 441     add_compile_options(/guard:cf)
 442     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /guard:cf")
 443     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /guard:cf")
 444
 445     # Incremental linking with CFG is broken until next VS release.
 446     # Disable it for EXE linking (since it is disabled for DLLs already further below)
 447     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /INCREMENTAL:NO")
 448   endif (NOT CLR_CMAKE_PLATFORM_ARCH_ARM64)
 449
 450   # Linker flags
 451   #
 452   # Disable the following line for UNIX altjit on Windows
 453   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO") #Do not create Side-by-Side Assembly Manifest
 454   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SUBSYSTEM:WINDOWS,6.00") #windows subsystem
 455   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LARGEADDRESSAWARE") # can handle addresses larger than 2 gigabytes
 456   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /RELEASE") #sets the checksum in the header
 457   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /NXCOMPAT") #Compatible with Data Execution Prevention
 458   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DYNAMICBASE") #Use address space layout randomization
 459   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUGTYPE:cv,fixup") #debugging format
 460   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /PDBCOMPRESS") #shrink pdb size
 461   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG")
 462   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /IGNORE:4197,4013,4254,4070,4221")
 463   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /INCREMENTAL:NO")
 464
 465   set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /IGNORE:4221")
 466
 467   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG /PDBCOMPRESS")
 468   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:1572864")
 469
 470   # Debug build specific flags
 471   set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "/NOVCFEATURE")
 472
 473   # Checked build specific flags
 474   set(CMAKE_SHARED_LINKER_FLAGS_CHECKED "${CMAKE_SHARED_LINKER_FLAGS_CHECKED} /OPT:REF /OPT:NOICF /NOVCFEATURE")
 475   set(CMAKE_STATIC_LINKER_FLAGS_CHECKED "${CMAKE_STATIC_LINKER_FLAGS_CHECKED}")
 476   set(CMAKE_EXE_LINKER_FLAGS_CHECKED "${CMAKE_EXE_LINKER_FLAGS_CHECKED} /OPT:REF /OPT:NOICF")
 477
 478   # Release build specific flags
 479   set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF /OPT:ICF")
 480   set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} /LTCG")
 481   set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF /OPT:ICF")
 482
 483   # ReleaseWithDebugInfo build specific flags
 484   set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /LTCG /OPT:REF /OPT:ICF")
 485   set(CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
 486   set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /LTCG /OPT:REF /OPT:ICF")
 487
 488 # Temporary until cmake has VS generators for arm64
 489 if(CLR_CMAKE_PLATFORM_ARCH_ARM64)
 490   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /machine:arm64")
 491   set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /machine:arm64")
 492   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /machine:arm64")
 493 endif(CLR_CMAKE_PLATFORM_ARCH_ARM64)
 494
 495 endif (WIN32)
 496
 497 OPTION(CMAKE_ENABLE_CODE_COVERAGE "Enable code coverage" OFF)
 498
 499 if(CMAKE_ENABLE_CODE_COVERAGE)
 500
 501   if(CLR_CMAKE_PLATFORM_UNIX)
 502     string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_CMAKE_BUILD_TYPE)
 503     if(NOT UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG)
 504       message( WARNING "Code coverage results with an optimised (non-Debug) build may be misleading" )
 505     endif(NOT UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG)
 506
 507     add_compile_options(-fprofile-arcs)
 508     add_compile_options(-ftest-coverage)
 509     set(CLANG_COVERAGE_LINK_FLAGS  "--coverage")
 510     set(CMAKE_SHARED_LINKER_FLAGS  "${CMAKE_SHARED_LINKER_FLAGS} ${CLANG_COVERAGE_LINK_FLAGS}")
 511     set(CMAKE_EXE_LINKER_FLAGS     "${CMAKE_EXE_LINKER_FLAGS} ${CLANG_COVERAGE_LINK_FLAGS}")
 512   else()
 513     message(FATAL_ERROR "Code coverage builds not supported on current platform")
 514   endif(CLR_CMAKE_PLATFORM_UNIX)
 515
 516 endif(CMAKE_ENABLE_CODE_COVERAGE)
 517
 518 # Start of projects that require usage of platform include files
 519
 520 if(CLR_CMAKE_PLATFORM_UNIX)
 521   add_subdirectory(src/corefx)
 522 endif(CLR_CMAKE_PLATFORM_UNIX)
 523
 524 if(IS_64BIT_BUILD)
 525   add_definitions(-DBIT64=1)
 526 endif(IS_64BIT_BUILD)
 527
 528 if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 529   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 530     add_definitions(-DDBG_TARGET_AMD64_UNIX)
 531   endif()
 532   add_definitions(-D_TARGET_AMD64_=1)
 533   add_definitions(-DDBG_TARGET_AMD64)
 534 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64)
 535   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64)
 536     add_definitions(-DDBG_TARGET_ARM64_UNIX)
 537   endif()
 538   add_definitions(-D_TARGET_ARM64_=1)
 539   add_definitions(-DDBG_TARGET_ARM64)
 540 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
 541   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
 542     add_definitions(-DDBG_TARGET_ARM_UNIX)
 543   endif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
 544   add_definitions(-D_TARGET_ARM_=1)
 545   add_definitions(-DDBG_TARGET_ARM)
 546 elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
 547   add_definitions(-D_TARGET_X86_=1)
 548   add_definitions(-DDBG_TARGET_X86)
 549 else ()
 550   clr_unknown_arch()
 551 endif (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 552
 553 if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 554   add_definitions(-D_AMD64_)
 555   add_definitions(-D_WIN64)
 556   add_definitions(-DAMD64)
 557 elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
 558   add_definitions(-D_X86_)
 559 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
 560   add_definitions(-D_ARM_)
 561   add_definitions(-DARM)
 562 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64)
 563   add_definitions(-D_ARM64_)
 564   add_definitions(-DARM64)
 565   add_definitions(-D_WIN64)
 566 else ()
 567   clr_unknown_arch()
 568 endif ()
 569
 570 if (WIN32)
 571   set(FEATURE_EVENT_TRACE 1)
 572 endif()
 573 if(CLR_CMAKE_PLATFORM_LINUX AND CLR_CMAKE_PLATFORM_ARCH_AMD64)
 574   set(FEATURE_EVENT_TRACE 1)
 575 endif()
 576
 577 if(CLR_CMAKE_PLATFORM_UNIX)
 578   add_subdirectory(src/ToolBox/SOS/lldbplugin)
 579   add_subdirectory(src/pal)
 580   add_subdirectory(src/coreclr/hosts/unixcoreruncommon)
 581   add_subdirectory(src/coreclr/hosts/unixcorerun)
 582   add_subdirectory(src/coreclr/hosts/unixcoreconsole)
 583   add_subdirectory(src/ildasm/unixcoreclrloader)
 584 endif(CLR_CMAKE_PLATFORM_UNIX)
 585
 586 if(CLR_CMAKE_PLATFORM_DARWIN)
 587   add_subdirectory(src/coreclr/hosts/osxbundlerun)
 588 endif(CLR_CMAKE_PLATFORM_DARWIN)
 589
 590 # Add this subdir. We install the headers for the jit.
 591 add_subdirectory(src/pal/prebuilt/inc)
 592
 593 add_subdirectory(src/debug/debug-pal)
 594
 595 if(WIN32)
 596   add_subdirectory(src/gc/sample)
 597 endif()
 598
 599 # End of projects that require usage of platform include files
 600
 601 # Enable for UNIX altjit on Windows - set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
 602 # Enable for UNIX altjit on Windows - add_definitions(-DCLR_CMAKE_PLATFORM_UNIX=1)
 603
 604 # Disable the following line for UNIX altjit on Windows
 605 set(CMAKE_CXX_STANDARD_LIBRARIES "") # do not link against standard win32 libs i.e. kernel32, uuid, user32, etc.
 606
 607 # Include directory directives
 608
 609 # Include the basic prebuilt headers - required for getting fileversion resource details.
 610 include_directories("src/pal/prebuilt/inc")
 611
 612 if (CLR_CMAKE_PLATFORM_UNIX)
 613   include_directories("src/pal/inc")
 614   include_directories("src/pal/inc/rt")
 615   include_directories("src/pal/src/safecrt")
 616 endif (CLR_CMAKE_PLATFORM_UNIX)
 617
 618 # Libraries
 619
 620 if (WIN32)
 621     set(STATIC_MT_CRT_LIB  "libcmt$<$<OR:$<CONFIG:Debug>,$<CONFIG:Checked>>:d>.lib")
 622     set(STATIC_MT_CPP_LIB  "libcpmt$<$<OR:$<CONFIG:Debug>,$<CONFIG:Checked>>:d>.lib")
 623 endif(WIN32)
 624
 625 # Definition directives
 626
 627 if (CLR_CMAKE_PLATFORM_UNIX)
 628
 629   if(CLR_CMAKE_PLATFORM_DARWIN)
 630     add_definitions(-D_XOPEN_SOURCE)
 631   endif(CLR_CMAKE_PLATFORM_DARWIN)
 632
 633   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 634     add_definitions(-DUNIX_AMD64_ABI)
 635   elseif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
 636     add_definitions(-DUNIX_ARM_ABI)
 637   endif()
 638
 639 endif(CLR_CMAKE_PLATFORM_UNIX)
 640
 641 add_definitions(-D_BLD_CLR)
 642 add_definitions(-DDEBUGGING_SUPPORTED)
 643 add_definitions(-DPROFILING_SUPPORTED)
 644
 645 if(WIN32)
 646   add_definitions(-DWIN32)
 647   add_definitions(-D_WIN32)
 648   add_definitions(-DWINVER=0x0602)
 649   add_definitions(-D_WIN32_WINNT=0x0602)
 650   add_definitions(-DWIN32_LEAN_AND_MEAN=1)
 651   if(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_I386)
 652     add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 653     # Only enable edit and continue on windows x86 and x64
 654     # exclude Linux, arm & arm64
 655     add_definitions(-DEnC_SUPPORTED)
 656   endif(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_I386)
 657 endif(WIN32)
 658
 659 # Features - please keep them alphabetically sorted
 660
 661 add_definitions(-DFEATURE_APPDOMAIN_RESOURCE_MONITORING)
 662 if(WIN32)
 663     add_definitions(-DFEATURE_APPX)
 664 endif(WIN32)
 665 if(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_ARM OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 666     add_definitions(-DFEATURE_ARRAYSTUB_AS_IL)
 667 endif()
 668
 669 add_definitions(-DFEATURE_ASYNC_IO)
 670 add_definitions(-DFEATURE_BCL_FORMATTING)
 671 add_definitions(-DFEATURE_COLLECTIBLE_TYPES)
 672
 673 if(WIN32)
 674     add_definitions(-DFEATURE_CLASSIC_COMINTEROP)
 675     add_definitions(-DFEATURE_COMINTEROP)
 676     add_definitions(-DFEATURE_COMINTEROP_APARTMENT_SUPPORT)
 677     add_definitions(-DFEATURE_COMINTEROP_UNMANAGED_ACTIVATION)
 678     add_definitions(-DFEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION)
 679 endif(WIN32)
 680
 681 add_definitions(-DFEATURE_CORECLR)
 682 if (CLR_CMAKE_PLATFORM_UNIX)
 683   add_definitions(-DFEATURE_COREFX_GLOBALIZATION)
 684 endif(CLR_CMAKE_PLATFORM_UNIX)
 685 add_definitions(-DFEATURE_CORESYSTEM)
 686 add_definitions(-DFEATURE_CORRUPTING_EXCEPTIONS)
 687 if(WIN32)
 688     add_definitions(-DFEATURE_CRYPTO)
 689 endif(WIN32)
 690 if(CLR_CMAKE_PLATFORM_UNIX)
 691     add_definitions(-DFEATURE_DBGIPC_TRANSPORT_DI)
 692     add_definitions(-DFEATURE_DBGIPC_TRANSPORT_VM)
 693 endif(CLR_CMAKE_PLATFORM_UNIX)
 694 if(FEATURE_EVENT_TRACE)
 695     add_definitions(-DFEATURE_EVENT_TRACE=1)
 696     if(CLR_CMAKE_PLATFORM_UNIX)
 697         add_definitions(-DFEATURE_EVENTSOURCE_XPLAT=1)
 698     endif(CLR_CMAKE_PLATFORM_UNIX)
 699 endif(FEATURE_EVENT_TRACE)
 700 add_definitions(-DFEATURE_EXCEPTIONDISPATCHINFO)
 701 add_definitions(-DFEATURE_FRAMEWORK_INTERNAL)
 702 # NetBSD doesn't implement this feature
 703 if(NOT CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM AND NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD)
 704     add_definitions(-DFEATURE_HIJACK)
 705 endif(NOT CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM AND NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD)
 706 add_definitions(-DFEATURE_HOST_ASSEMBLY_RESOLVER)
 707 add_definitions(-DFEATURE_HOSTED_BINDER)
 708 add_definitions(-DFEATURE_ICASTABLE)
 709 if (CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 710   add_definitions(-DFEATURE_IMPLICIT_TLS)
 711   set(FEATURE_IMPLICIT_TLS 1)
 712 endif(CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 713 if(WIN32)
 714     add_definitions(-DFEATURE_ISOSTORE)
 715     add_definitions(-DFEATURE_ISOSTORE_LIGHT)
 716 endif(WIN32)
 717 add_definitions(-DFEATURE_ISYM_READER)
 718 add_definitions(-DFEATURE_LEGACYNETCF)
 719 if(WIN32)
 720     add_definitions(-DFEATURE_LEGACYNETCFCRYPTO)
 721 endif(WIN32)
 722 add_definitions(-DFEATURE_LEGACYNETCF_DBG_HOST_CONTROL)
 723 add_definitions(-DFEATURE_LEGACYNETCFFAS)
 724 if(WIN32)
 725 add_definitions(-DFEATURE_LEGACYSURFACE)
 726 endif(WIN32)
 727 add_definitions(-DFEATURE_LOADER_OPTIMIZATION)
 728 add_definitions(-DFEATURE_MANAGED_ETW)
 729 add_definitions(-DFEATURE_MANAGED_ETW_CHANNELS)
 730 add_definitions(-DFEATURE_MAIN_CLR_MODULE_USES_CORE_NAME)
 731 add_definitions(-DFEATURE_MERGE_CULTURE_SUPPORT_AND_ENGINE)
 732 if(WIN32)
 733 # Disable the following or UNIX altjit on Windows
 734 add_definitions(-DFEATURE_MERGE_JIT_AND_ENGINE)
 735 endif(WIN32)
 736 add_definitions(-DFEATURE_MULTICOREJIT)
 737 add_definitions(-DFEATURE_NORM_IDNA_ONLY)
 738 if(CLR_CMAKE_PLATFORM_UNIX)
 739   add_definitions(-DFEATURE_PAL)
 740   add_definitions(-DFEATURE_PAL_SXS)
 741 endif(CLR_CMAKE_PLATFORM_UNIX)
 742 if(CLR_CMAKE_PLATFORM_LINUX)
 743     add_definitions(-DFEATURE_PERFMAP)
 744 endif(CLR_CMAKE_PLATFORM_LINUX)
 745 add_definitions(-DFEATURE_PREJIT)
 746 add_definitions(-DFEATURE_RANDOMIZED_STRING_HASHING)
 747 if(NOT DEFINED CLR_CMAKE_PLATFORM_ARCH_ARM64)
 748   add_definitions(-DFEATURE_READYTORUN)
 749   set(FEATURE_READYTORUN 1)
 750 endif(NOT DEFINED CLR_CMAKE_PLATFORM_ARCH_ARM64)
 751 add_definitions(-DFEATURE_STANDALONE_SN)
 752 add_definitions(-DFEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED)
 753 add_definitions(-DFEATURE_STRONGNAME_MIGRATION)
 754 if(WIN32)
 755     add_definitions(-DFEATURE_STRONGNAME_TESTKEY_ALLOWED)
 756 endif(WIN32)
 757 if (CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 758     add_definitions(-DFEATURE_STUBS_AS_IL)
 759 endif(CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 760 add_definitions(-DFEATURE_SVR_GC)
 761 add_definitions(-DFEATURE_SYMDIFF)
 762 add_definitions(-DFEATURE_SYNTHETIC_CULTURES)
 763 if(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 764   add_definitions(-DFEATURE_UNIX_AMD64_STRUCT_PASSING)
 765   add_definitions(-DFEATURE_UNIX_AMD64_STRUCT_PASSING_ITF)
 766 endif (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 767 add_definitions(-DFEATURE_USE_ASM_GC_WRITE_BARRIERS)
 768 add_definitions(-DFEATURE_VERSIONING)
 769 if(WIN32)
 770     add_definitions(-DFEATURE_VERSIONING_LOG)
 771 endif(WIN32)
 772 add_definitions(-DFEATURE_WIN32_REGISTRY)
 773 add_definitions(-DFEATURE_WINDOWSPHONE)
 774 add_definitions(-DFEATURE_WINMD_RESILIENT)
 775 if(WIN32)
 776     add_definitions(-DFEATURE_X509)
 777     add_definitions(-DFEATURE_X509_SECURESTRINGS)
 778 endif(WIN32)
 779
 780 if(CLR_CMAKE_BUILD_TESTS)
 781   add_subdirectory(tests)
 782 endif(CLR_CMAKE_BUILD_TESTS)
 783
 784 if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 785     set(ARCH_SOURCES_DIR amd64)
 786 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64)
 787     set(ARCH_SOURCES_DIR arm64)
 788 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
 789     set(ARCH_SOURCES_DIR arm)
 790 elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
 791     set(ARCH_SOURCES_DIR i386)
 792 else ()
 793     clr_unknown_arch()
 794 endif ()
 795
 796 add_definitions(-D_SECURE_SCL=0)
 797 add_definitions(-DUNICODE)
 798 add_definitions(-D_UNICODE)
 799
 800 # Compiler options
 801
 802 if(WIN32)
 803   add_compile_options(/FIWarningControl.h) # force include of WarningControl.h
 804   add_compile_options(/Zl) # omit default library name in .OBJ
 805 endif(WIN32)
 806
 807 # Microsoft.Dotnet.BuildTools.Coreclr version
 808 set(BuildToolsVersion "1.0.4-prerelease")
 809 set(BuildToolsDir "${CLR_DIR}/packages/Microsoft.DotNet.BuildTools.CoreCLR/${BuildToolsVersion}")
 810
 811 add_subdirectory(src)