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
 158     if (CMAKE_SYSTEM_NAME STREQUAL Darwin)
 159
 160       # Ensure that dsymutil and strip is present
 161       find_program(DSYMUTIL dsymutil)
 162       if (DSYMUTIL STREQUAL "DSYMUTIL-NOTFOUND")
 163           message(FATAL_ERROR "dsymutil not found")
 164       endif()
 165       find_program(STRIP strip)
 166       if (STRIP STREQUAL "STRIP-NOTFOUND")
 167           message(FATAL_ERROR "strip not found")
 168       endif()
 169
 170     else (CMAKE_SYSTEM_NAME STREQUAL Darwin)
 171
 172       # Ensure that objcopy is present
 173       find_program(OBJCOPY objcopy)
 174       if (OBJCOPY STREQUAL "OBJCOPY-NOTFOUND")
 175           message(FATAL_ERROR "objcopy not found")
 176       endif()
 177     endif (CMAKE_SYSTEM_NAME STREQUAL Darwin)
 178 endif(WIN32)
 179
 180 # Build a list of compiler definitions by putting -D in front of each define.
 181 function(get_compile_definitions DefinitionName)
 182     # Get the current list of definitions
 183     get_directory_property(COMPILE_DEFINITIONS_LIST COMPILE_DEFINITIONS)
 184
 185     foreach(DEFINITION IN LISTS COMPILE_DEFINITIONS_LIST)
 186         if (${DEFINITION} MATCHES "^\\$<\\$<CONFIG:([^>]+)>:([^>]+)>$")
 187             # The entries that contain generator expressions must have the -D inside of the
 188             # expression. So we transform e.g. $<$<CONFIG:Debug>:_DEBUG> to $<$<CONFIG:Debug>:-D_DEBUG>
 189             set(DEFINITION "$<$<CONFIG:${CMAKE_MATCH_1}>:-D${CMAKE_MATCH_2}>")
 190         else()
 191             set(DEFINITION -D${DEFINITION})
 192         endif()
 193         list(APPEND DEFINITIONS ${DEFINITION})
 194     endforeach()
 195     set(${DefinitionName} ${DEFINITIONS} PARENT_SCOPE)
 196 endfunction(get_compile_definitions)
 197
 198 # Build a list of include directories by putting -I in front of each include dir.
 199 function(get_include_directories IncludeDirectories)
 200     get_directory_property(dirs INCLUDE_DIRECTORIES)
 201     foreach(dir IN LISTS dirs)
 202         list(APPEND INC_DIRECTORIES -I${dir})
 203     endforeach()
 204     set(${IncludeDirectories} ${INC_DIRECTORIES} PARENT_SCOPE)
 205 endfunction(get_include_directories)
 206
 207 # Set the passed in RetSources variable to the list of sources with added current source directory
 208 # to form absolute paths.
 209 # The parameters after the RetSources are the input files.
 210 function(convert_to_absolute_path RetSources)
 211     set(Sources ${ARGN})
 212     foreach(Source IN LISTS Sources)
 213         list(APPEND AbsolutePathSources ${CMAKE_CURRENT_SOURCE_DIR}/${Source})
 214     endforeach()
 215     set(${RetSources} ${AbsolutePathSources} PARENT_SCOPE)
 216 endfunction(convert_to_absolute_path)
 217
 218 #Preprocess exports definition file
 219 function(preprocess_def_file inputFilename outputFilename)
 220   get_compile_definitions(PREPROCESS_DEFINITIONS)
 221
 222   add_custom_command(
 223     OUTPUT ${outputFilename}
 224     COMMAND ${CMAKE_CXX_COMPILER} /P /EP /TC ${PREPROCESS_DEFINITIONS}  /Fi${outputFilename}  ${inputFilename}
 225     DEPENDS ${inputFilename}
 226     COMMENT "Preprocessing ${inputFilename}"
 227   )
 228
 229   set_source_files_properties(${outputFilename}
 230                               PROPERTIES GENERATED TRUE)
 231 endfunction()
 232
 233 function(generate_exports_file inputFilename outputFilename)
 234
 235   if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 236     set(AWK_SCRIPT generateexportedsymbols.awk)
 237   else()
 238     set(AWK_SCRIPT generateversionscript.awk)
 239   endif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 240
 241   add_custom_command(
 242     OUTPUT ${outputFilename}
 243     COMMAND ${AWK} -f ${CMAKE_SOURCE_DIR}/${AWK_SCRIPT} ${inputFilename} >${outputFilename}
 244     DEPENDS ${inputFilename} ${CMAKE_SOURCE_DIR}/${AWK_SCRIPT}
 245     COMMENT "Generating exports file ${outputFilename}"
 246   )
 247   set_source_files_properties(${outputFilename}
 248                               PROPERTIES GENERATED TRUE)
 249 endfunction()
 250
 251 function(add_precompiled_header header cppFile targetSources)
 252   if(MSVC)
 253     set(precompiledBinary "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/stdafx.pch")
 254
 255     set_source_files_properties(${cppFile}
 256                                 PROPERTIES COMPILE_FLAGS "/Yc\"${header}\" /Fp\"${precompiledBinary}\""
 257                                            OBJECT_OUTPUTS "${precompiledBinary}")
 258     set_source_files_properties(${${targetSources}}
 259                                 PROPERTIES COMPILE_FLAGS "/Yu\"${header}\" /Fp\"${precompiledBinary}\""
 260                                            OBJECT_DEPENDS "${precompiledBinary}")
 261     # Add cppFile to SourcesVar
 262     set(${targetSources} ${${targetSources}} ${cppFile} PARENT_SCOPE)
 263   endif(MSVC)
 264 endfunction()
 265
 266 function(strip_symbols targetName outputFilename)
 267   if(CLR_CMAKE_PLATFORM_UNIX)
 268     if(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELEASE)
 269
 270       # On the older version of cmake (2.8.12) used on Ubuntu 14.04 the TARGET_FILE
 271       # generator expression doesn't work correctly returning the wrong path and on
 272       # the newer cmake versions the LOCATION property isn't supported anymore.
 273       if(CMAKE_VERSION VERSION_EQUAL 3.0 OR CMAKE_VERSION VERSION_GREATER 3.0)
 274           set(strip_source_file $<TARGET_FILE:${targetName}>)
 275       else()
 276           get_property(strip_source_file TARGET ${targetName} PROPERTY LOCATION)
 277       endif()
 278
 279       if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 280         set(strip_destination_file ${strip_source_file}.dwarf)
 281
 282         add_custom_command(
 283           TARGET ${targetName}
 284           POST_BUILD
 285           VERBATIM
 286           COMMAND ${DSYMUTIL} --flat --minimize ${strip_source_file}
 287           COMMAND ${STRIP} -u -r ${strip_source_file}
 288           COMMENT Stripping symbols from ${strip_source_file} into file ${strip_destination_file}
 289         )
 290       else(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 291         set(strip_destination_file ${strip_source_file}.dbg)
 292
 293         add_custom_command(
 294           TARGET ${targetName}
 295           POST_BUILD
 296           VERBATIM
 297           COMMAND ${OBJCOPY} --only-keep-debug ${strip_source_file} ${strip_destination_file}
 298           COMMAND ${OBJCOPY} --strip-unneeded ${strip_source_file}
 299           COMMAND ${OBJCOPY} --add-gnu-debuglink=${strip_destination_file} ${strip_source_file}
 300           COMMENT Stripping symbols from ${strip_source_file} into file ${strip_destination_file}
 301         )
 302       endif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 303
 304       set(${outputFilename} ${strip_destination_file} PARENT_SCOPE)
 305     endif(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELEASE)
 306   endif(CLR_CMAKE_PLATFORM_UNIX)
 307 endfunction()
 308
 309 function(install_clr targetName)
 310   strip_symbols(${targetName} strip_destination_file)
 311
 312   # On the older version of cmake (2.8.12) used on Ubuntu 14.04 the TARGET_FILE
 313   # generator expression doesn't work correctly returning the wrong path and on
 314   # the newer cmake versions the LOCATION property isn't supported anymore.
 315   if(CMAKE_VERSION VERSION_EQUAL 3.0 OR CMAKE_VERSION VERSION_GREATER 3.0)
 316       set(install_source_file $<TARGET_FILE:${targetName}>)
 317   else()
 318       get_property(install_source_file TARGET ${targetName} PROPERTY LOCATION)
 319   endif()
 320
 321   install(PROGRAMS ${install_source_file} DESTINATION .)
 322   if(WIN32)
 323       install(FILES ${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>/${targetName}.pdb DESTINATION PDB)
 324   else()
 325       install(FILES ${strip_destination_file} DESTINATION .)
 326   endif()
 327 endfunction()
 328
 329 # Includes
 330
 331 if (CMAKE_CONFIGURATION_TYPES) # multi-configuration generator?
 332     set(CMAKE_CONFIGURATION_TYPES "Debug;Checked;Release;RelWithDebInfo" CACHE STRING "" FORCE)
 333 endif (CMAKE_CONFIGURATION_TYPES)
 334
 335 set(CMAKE_C_FLAGS_CHECKED ${CLR_C_FLAGS_CHECKED_INIT} CACHE STRING "Flags used by the compiler during checked builds.")
 336 set(CMAKE_CXX_FLAGS_CHECKED ${CLR_CXX_FLAGS_CHECKED_INIT} CACHE STRING "Flags used by the compiler during checked builds.")
 337 set(CMAKE_EXE_LINKER_FLAGS_CHECKED "")
 338 set(CMAKE_SHARED_LINKER_FLAGS_CHECKED "")
 339
 340 if (WIN32)
 341   # For multi-configuration toolset (as Visual Studio)
 342   # set the different configuration defines.
 343   foreach (Config DEBUG CHECKED RELEASE RELWITHDEBINFO)
 344     foreach (Definition IN LISTS CLR_DEFINES_${Config}_INIT)
 345       set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:${Config}>:${Definition}>)
 346     endforeach (Definition)
 347   endforeach (Config)
 348
 349 elseif (CLR_CMAKE_PLATFORM_UNIX)
 350   # Set the values to display when interactively configuring CMAKE_BUILD_TYPE
 351   set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "DEBUG;CHECKED;RELEASE;RELWITHDEBINFO")
 352
 353   # Use uppercase CMAKE_BUILD_TYPE for the string comparisons below
 354   string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_CMAKE_BUILD_TYPE)
 355
 356   # For single-configuration toolset
 357   # set the different configuration defines.
 358   if (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG)
 359     # First DEBUG
 360     set_property(DIRECTORY  PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_DEBUG_INIT})
 361   elseif (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
 362     # Then CHECKED
 363     set_property(DIRECTORY PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_CHECKED_INIT})
 364   elseif (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELEASE)
 365     # Then RELEASE
 366     set_property(DIRECTORY PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_RELEASE_INIT})
 367   elseif (UPPERCASE_CMAKE_BUILD_TYPE STREQUAL RELWITHDEBINFO)
 368     # And then RELWITHDEBINFO
 369     set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS ${CLR_DEFINES_RELWITHDEBINFO_INIT})
 370   else ()
 371     message(FATAL_ERROR "Unknown build type! Set CMAKE_BUILD_TYPE to DEBUG, CHECKED, RELEASE, or RELWITHDEBINFO!")
 372   endif ()
 373
 374 endif(WIN32)
 375
 376 if (CLR_CMAKE_PLATFORM_UNIX)
 377   add_definitions(-DPLATFORM_UNIX=1)
 378
 379   if(CLR_CMAKE_PLATFORM_LINUX)
 380     if(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 381       message("Detected Linux x86_64")
 382       add_definitions(-DLINUX64)
 383     elseif(CLR_CMAKE_PLATFORM_ARCH_ARM)
 384       message("Detected Linux ARM")
 385       add_definitions(-DLINUX32)
 386     elseif(CLR_CMAKE_PLATFORM_ARCH_ARM64)
 387       message("Detected Linux ARM64")
 388       add_definitions(-DLINUX64)
 389     else()
 390       clr_unknown_arch()
 391     endif()
 392   endif(CLR_CMAKE_PLATFORM_LINUX)
 393
 394   if(CLR_CMAKE_PLATFORM_DARWIN)
 395     message("Detected OSX x86_64")
 396   endif(CLR_CMAKE_PLATFORM_DARWIN)
 397
 398   if(CLR_CMAKE_PLATFORM_FREEBSD)
 399     message("Detected FreeBSD amd64")
 400   endif(CLR_CMAKE_PLATFORM_FREEBSD)
 401
 402   # Disable frame pointer optimizations so profilers can get better call stacks
 403   add_compile_options(-fno-omit-frame-pointer)
 404
 405   # The -fms-extensions enable the stuff like __if_exists, __declspec(uuid()), etc.
 406   add_compile_options(-fms-extensions )
 407   #-fms-compatibility      Enable full Microsoft Visual C++ compatibility
 408   #-fms-extensions         Accept some non-standard constructs supported by the Microsoft compiler
 409
 410   if(CLR_CMAKE_PLATFORM_DARWIN)
 411     # We cannot enable "stack-protector-strong" on OS X due to a bug in clang compiler (current version 7.0.2)
 412     add_compile_options(-fstack-protector)
 413   else()
 414     add_compile_options(-fstack-protector-strong)
 415   endif(CLR_CMAKE_PLATFORM_DARWIN)
 416
 417   # set the CLANG sanitizer flags for debug build
 418   if(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
 419     # obtain settings from running enablesanitizers.sh
 420     string(FIND "$ENV{DEBUG_SANITIZERS}" "asan" __ASAN_POS)
 421     string(FIND "$ENV{DEBUG_SANITIZERS}" "ubsan" __UBSAN_POS)
 422     if ((${__ASAN_POS} GREATER -1) OR (${__UBSAN_POS} GREATER -1))
 423       set(CLR_SANITIZE_CXX_FLAGS "${CLR_SANITIZE_CXX_FLAGS} -fsanitize-blacklist=${CMAKE_CURRENT_SOURCE_DIR}/sanitizerblacklist.txt -fsanitize=")
 424       set(CLR_SANITIZE_LINK_FLAGS "${CLR_SANITIZE_LINK_FLAGS} -fsanitize=")
 425       if (${__ASAN_POS} GREATER -1)
 426         set(CLR_SANITIZE_CXX_FLAGS "${CLR_SANITIZE_CXX_FLAGS}address,")
 427         set(CLR_SANITIZE_LINK_FLAGS "${CLR_SANITIZE_LINK_FLAGS}address,")
 428         message("Address Sanitizer (asan) enabled")
 429       endif ()
 430       if (${__UBSAN_POS} GREATER -1)
 431         # all sanitizier flags are enabled except alignment (due to heavy use of __unaligned modifier)
 432         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")
 433         set(CLR_SANITIZE_LINK_FLAGS "${CLR_SANITIZE_LINK_FLAGS}undefined")
 434         message("Undefined Behavior Sanitizer (ubsan) enabled")
 435       endif ()
 436
 437       # -fdata-sections -ffunction-sections: each function has own section instead of one per .o file (needed for --gc-sections)
 438       # -fPIC: enable Position Independent Code normally just for shared libraries but required when linking with address sanitizer
 439       # -O1: optimization level used instead of -O0 to avoid compile error "invalid operand for inline asm constraint"
 440       set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${CLR_SANITIZE_CXX_FLAGS} -fdata-sections -ffunction-sections -fPIC -O1")
 441       set(CMAKE_CXX_FLAGS_CHECKED "${CMAKE_CXX_FLAGS_CHECKED} ${CLR_SANITIZE_CXX_FLAGS} -fdata-sections -ffunction-sections -fPIC -O1")
 442
 443       set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${CLR_SANITIZE_LINK_FLAGS}")
 444       set(CMAKE_EXE_LINKER_FLAGS_CHECKED "${CMAKE_EXE_LINKER_FLAGS_CHECKED} ${CLR_SANITIZE_LINK_FLAGS}")
 445
 446       # -Wl and --gc-sections: drop unused sections\functions (similar to Windows /Gy function-level-linking)
 447       set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} ${CLR_SANITIZE_LINK_FLAGS} -Wl,--gc-sections")
 448       set(CMAKE_SHARED_LINKER_FLAGS_CHECKED "${CMAKE_SHARED_LINKER_FLAGS_CHECKED} ${CLR_SANITIZE_LINK_FLAGS} -Wl,--gc-sections")
 449     endif ()
 450   endif(UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG OR UPPERCASE_CMAKE_BUILD_TYPE STREQUAL CHECKED)
 451
 452   add_definitions(-DDISABLE_CONTRACTS)
 453   # The -ferror-limit is helpful during the porting, it makes sure the compiler doesn't stop
 454   # after hitting just about 20 errors.
 455   add_compile_options(-ferror-limit=4096)
 456
 457   # All warnings that are not explicitly disabled are reported as errors
 458   add_compile_options(-Werror)
 459
 460   # Disabled warnings
 461   add_compile_options(-Wno-unused-private-field)
 462   add_compile_options(-Wno-unused-variable)
 463   # Explicit constructor calls are not supported by clang (this->ClassName::ClassName())
 464   add_compile_options(-Wno-microsoft)
 465   # This warning is caused by comparing 'this' to NULL
 466   add_compile_options(-Wno-tautological-compare)
 467   # There are constants of type BOOL used in a condition. But BOOL is defined as int
 468   # and so the compiler thinks that there is a mistake.
 469   add_compile_options(-Wno-constant-logical-operand)
 470
 471   add_compile_options(-Wno-unknown-warning-option)
 472
 473   #These seem to indicate real issues
 474   add_compile_options(-Wno-invalid-offsetof)
 475   # The following warning indicates that an attribute __attribute__((__ms_struct__)) was applied
 476   # to a struct or a class that has virtual members or a base class. In that case, clang
 477   # may not generate the same object layout as MSVC.
 478   add_compile_options(-Wno-incompatible-ms-struct)
 479
 480 endif(CLR_CMAKE_PLATFORM_UNIX)
 481
 482 if (WIN32)
 483   # Compile options for targeting windows
 484
 485   # The following options are set by the razzle build
 486   add_compile_options(/TP) # compile all files as C++
 487   add_compile_options(/d2Zi+) # make optimized builds debugging easier
 488   add_compile_options(/nologo) # Suppress Startup Banner
 489   add_compile_options(/W3) # set warning level to 3
 490   add_compile_options(/WX) # treat warnings as errors
 491   add_compile_options(/Oi) # enable intrinsics
 492   add_compile_options(/Oy-) # disable suppressing of the creation of frame pointers on the call stack for quicker function calls
 493   add_compile_options(/U_MT) # undefine the predefined _MT macro
 494   add_compile_options(/GF) # enable read-only string pooling
 495   add_compile_options(/Gm-) # disable minimal rebuild
 496   add_compile_options(/EHa) # enable C++ EH (w/ SEH exceptions)
 497   add_compile_options(/Zp8) # pack structs on 8-byte boundary
 498   add_compile_options(/Gy) # separate functions for linker
 499   add_compile_options(/Zc:wchar_t-) # C++ language conformance: wchar_t is NOT the native type, but a typedef
 500   add_compile_options(/Zc:forScope) # C++ language conformance: enforce Standard C++ for scoping rules
 501   add_compile_options(/GR-) # disable C++ RTTI
 502   add_compile_options(/FC) # use full pathnames in diagnostics
 503   add_compile_options(/MP) # Build with Multiple Processes (number of processes equal to the number of processors)
 504   add_compile_options(/GS) # Buffer Security Check
 505   add_compile_options(/Zm200) # Specify Precompiled Header Memory Allocation Limit of 150MB
 506   add_compile_options(/wd4960 /wd4961 /wd4603 /wd4627 /wd4838 /wd4456 /wd4457 /wd4458 /wd4459 /wd4091 /we4640)
 507   add_compile_options(/Zi) # enable debugging information
 508
 509   if (CLR_CMAKE_PLATFORM_ARCH_I386)
 510     add_compile_options(/Gz)
 511   endif (CLR_CMAKE_PLATFORM_ARCH_I386)
 512
 513   add_compile_options($<$<OR:$<CONFIG:Release>,$<CONFIG:Relwithdebinfo>>:/GL>)
 514   add_compile_options($<$<OR:$<OR:$<CONFIG:Release>,$<CONFIG:Relwithdebinfo>>,$<CONFIG:Checked>>:/O1>)
 515
 516   if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 517   # The generator expression in the following command means that the /homeparams option is added only for debug builds
 518   add_compile_options($<$<CONFIG:Debug>:/homeparams>) # Force parameters passed in registers to be written to the stack
 519   endif (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 520
 521   if(NOT CLR_CMAKE_PLATFORM_ARCH_ARM64)
 522     # enable control-flow-guard support for native components for non-Arm64 builds
 523     add_compile_options(/guard:cf)
 524     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /guard:cf")
 525     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /guard:cf")
 526   endif (NOT CLR_CMAKE_PLATFORM_ARCH_ARM64)
 527
 528   # Incremental linking with CFG is broken until next VS release.
 529   # This needs to be appended to the last for each build type to override the default flag.
 530   set(NO_INCREMENTAL_LINKER_FLAGS "/INCREMENTAL:NO")
 531
 532   # Linker flags
 533   #
 534   # Disable the following line for UNIX altjit on Windows
 535   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /MANIFEST:NO") #Do not create Side-by-Side Assembly Manifest
 536   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SUBSYSTEM:WINDOWS,6.00") #windows subsystem
 537   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LARGEADDRESSAWARE") # can handle addresses larger than 2 gigabytes
 538   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /RELEASE") #sets the checksum in the header
 539   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /NXCOMPAT") #Compatible with Data Execution Prevention
 540   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DYNAMICBASE") #Use address space layout randomization
 541   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUGTYPE:cv,fixup") #debugging format
 542   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /PDBCOMPRESS") #shrink pdb size
 543   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /DEBUG")
 544   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /IGNORE:4197,4013,4254,4070,4221")
 545
 546   set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /IGNORE:4221")
 547
 548   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG /PDBCOMPRESS")
 549   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:1572864")
 550
 551   # Debug build specific flags
 552   set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "/NOVCFEATURE ${NO_INCREMENTAL_LINKER_FLAGS}")
 553   set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${NO_INCREMENTAL_LINKER_FLAGS}")
 554
 555   # Checked build specific flags
 556   set(CMAKE_SHARED_LINKER_FLAGS_CHECKED "${CMAKE_SHARED_LINKER_FLAGS_CHECKED} /OPT:REF /OPT:NOICF /NOVCFEATURE ${NO_INCREMENTAL_LINKER_FLAGS}")
 557   set(CMAKE_STATIC_LINKER_FLAGS_CHECKED "${CMAKE_STATIC_LINKER_FLAGS_CHECKED}")
 558   set(CMAKE_EXE_LINKER_FLAGS_CHECKED "${CMAKE_EXE_LINKER_FLAGS_CHECKED} /OPT:REF /OPT:NOICF ${NO_INCREMENTAL_LINKER_FLAGS}")
 559
 560   # Release build specific flags
 561   set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF /OPT:ICF ${NO_INCREMENTAL_LINKER_FLAGS}")
 562   set(CMAKE_STATIC_LINKER_FLAGS_RELEASE "${CMAKE_STATIC_LINKER_FLAGS_RELEASE} /LTCG")
 563   set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG /OPT:REF /OPT:ICF ${NO_INCREMENTAL_LINKER_FLAGS}")
 564
 565   # ReleaseWithDebugInfo build specific flags
 566   set(CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO} /LTCG /OPT:REF /OPT:ICF ${NO_INCREMENTAL_LINKER_FLAGS}")
 567   set(CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO} /LTCG")
 568   set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO} /LTCG /OPT:REF /OPT:ICF ${NO_INCREMENTAL_LINKER_FLAGS}")
 569
 570 # Temporary until cmake has VS generators for arm64
 571 if(CLR_CMAKE_PLATFORM_ARCH_ARM64)
 572   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /machine:arm64")
 573   set(CMAKE_STATIC_LINKER_FLAGS "${CMAKE_STATIC_LINKER_FLAGS} /machine:arm64")
 574   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /machine:arm64")
 575 endif(CLR_CMAKE_PLATFORM_ARCH_ARM64)
 576
 577 endif (WIN32)
 578
 579 OPTION(CMAKE_ENABLE_CODE_COVERAGE "Enable code coverage" OFF)
 580
 581 if(CMAKE_ENABLE_CODE_COVERAGE)
 582
 583   if(CLR_CMAKE_PLATFORM_UNIX)
 584     string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_CMAKE_BUILD_TYPE)
 585     if(NOT UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG)
 586       message( WARNING "Code coverage results with an optimised (non-Debug) build may be misleading" )
 587     endif(NOT UPPERCASE_CMAKE_BUILD_TYPE STREQUAL DEBUG)
 588
 589     add_compile_options(-fprofile-arcs)
 590     add_compile_options(-ftest-coverage)
 591     set(CLANG_COVERAGE_LINK_FLAGS  "--coverage")
 592     set(CMAKE_SHARED_LINKER_FLAGS  "${CMAKE_SHARED_LINKER_FLAGS} ${CLANG_COVERAGE_LINK_FLAGS}")
 593     set(CMAKE_EXE_LINKER_FLAGS     "${CMAKE_EXE_LINKER_FLAGS} ${CLANG_COVERAGE_LINK_FLAGS}")
 594   else()
 595     message(FATAL_ERROR "Code coverage builds not supported on current platform")
 596   endif(CLR_CMAKE_PLATFORM_UNIX)
 597
 598 endif(CMAKE_ENABLE_CODE_COVERAGE)
 599
 600 # Start of projects that require usage of platform include files
 601
 602 if(CLR_CMAKE_PLATFORM_UNIX)
 603   add_subdirectory(src/corefx)
 604 endif(CLR_CMAKE_PLATFORM_UNIX)
 605
 606 if(IS_64BIT_BUILD)
 607   add_definitions(-DBIT64=1)
 608 endif(IS_64BIT_BUILD)
 609
 610 if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 611   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 612     add_definitions(-DDBG_TARGET_AMD64_UNIX)
 613   endif()
 614   add_definitions(-D_TARGET_AMD64_=1)
 615   add_definitions(-DDBG_TARGET_AMD64)
 616 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64)
 617   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM64)
 618     add_definitions(-DDBG_TARGET_ARM64_UNIX)
 619   endif()
 620   add_definitions(-D_TARGET_ARM64_=1)
 621   add_definitions(-DDBG_TARGET_ARM64)
 622 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
 623   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
 624     add_definitions(-DDBG_TARGET_ARM_UNIX)
 625   endif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
 626   add_definitions(-D_TARGET_ARM_=1)
 627   add_definitions(-DDBG_TARGET_ARM)
 628 elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
 629   add_definitions(-D_TARGET_X86_=1)
 630   add_definitions(-DDBG_TARGET_X86)
 631 else ()
 632   clr_unknown_arch()
 633 endif (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 634
 635 if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 636   add_definitions(-D_AMD64_)
 637   add_definitions(-D_WIN64)
 638   add_definitions(-DAMD64)
 639 elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
 640   add_definitions(-D_X86_)
 641 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
 642   add_definitions(-D_ARM_)
 643   add_definitions(-DARM)
 644 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64)
 645   add_definitions(-D_ARM64_)
 646   add_definitions(-DARM64)
 647   add_definitions(-D_WIN64)
 648 else ()
 649   clr_unknown_arch()
 650 endif ()
 651
 652 if (WIN32)
 653   set(FEATURE_EVENT_TRACE 1)
 654 endif()
 655 if(CLR_CMAKE_PLATFORM_LINUX AND CLR_CMAKE_PLATFORM_ARCH_AMD64)
 656   set(FEATURE_EVENT_TRACE 1)
 657 endif()
 658
 659 if(CLR_CMAKE_PLATFORM_UNIX)
 660   add_subdirectory(src/ToolBox/SOS/lldbplugin)
 661   add_subdirectory(src/pal)
 662   add_subdirectory(src/coreclr/hosts/unixcoreruncommon)
 663   add_subdirectory(src/coreclr/hosts/unixcorerun)
 664   add_subdirectory(src/coreclr/hosts/unixcoreconsole)
 665   add_subdirectory(src/ildasm/unixcoreclrloader)
 666 endif(CLR_CMAKE_PLATFORM_UNIX)
 667
 668 if(CLR_CMAKE_PLATFORM_DARWIN)
 669   add_subdirectory(src/coreclr/hosts/osxbundlerun)
 670 endif(CLR_CMAKE_PLATFORM_DARWIN)
 671
 672 # Add this subdir. We install the headers for the jit.
 673 add_subdirectory(src/pal/prebuilt/inc)
 674
 675 add_subdirectory(src/debug/debug-pal)
 676
 677 if(WIN32)
 678   add_subdirectory(src/gc/sample)
 679 endif()
 680
 681 # End of projects that require usage of platform include files
 682
 683 # Enable for UNIX altjit on Windows - set(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64 1)
 684 # Enable for UNIX altjit on Windows - add_definitions(-DCLR_CMAKE_PLATFORM_UNIX=1)
 685
 686 # Disable the following line for UNIX altjit on Windows
 687 set(CMAKE_CXX_STANDARD_LIBRARIES "") # do not link against standard win32 libs i.e. kernel32, uuid, user32, etc.
 688
 689 # Include directory directives
 690
 691 # Include the basic prebuilt headers - required for getting fileversion resource details.
 692 include_directories("src/pal/prebuilt/inc")
 693
 694 if (CLR_CMAKE_PLATFORM_UNIX)
 695   include_directories("src/pal/inc")
 696   include_directories("src/pal/inc/rt")
 697   include_directories("src/pal/src/safecrt")
 698 endif (CLR_CMAKE_PLATFORM_UNIX)
 699
 700 # Libraries
 701
 702 if (WIN32)
 703
 704     # Define the CRT lib references that link into Desktop imports
 705     set(STATIC_MT_CRT_LIB  "libcmt$<$<OR:$<CONFIG:Debug>,$<CONFIG:Checked>>:d>.lib")
 706     set(STATIC_MT_VCRT_LIB  "libvcruntime$<$<OR:$<CONFIG:Debug>,$<CONFIG:Checked>>:d>.lib")
 707     set(STATIC_MT_CPP_LIB  "libcpmt$<$<OR:$<CONFIG:Debug>,$<CONFIG:Checked>>:d>.lib")
 708
 709     # ARM64_TODO: Enable this for Windows Arm64
 710     if (NOT CLR_CMAKE_PLATFORM_ARCH_ARM64)
 711       # Define the uCRT lib reference
 712       set(STATIC_MT_UCRT_LIB  "libucrt$<$<OR:$<CONFIG:Debug>,$<CONFIG:Checked>>:d>.lib")
 713     endif()
 714
 715 endif(WIN32)
 716
 717 # Definition directives
 718
 719 if (CLR_CMAKE_PLATFORM_UNIX)
 720
 721   if(CLR_CMAKE_PLATFORM_DARWIN)
 722     add_definitions(-D_XOPEN_SOURCE)
 723   endif(CLR_CMAKE_PLATFORM_DARWIN)
 724
 725   if (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 726     add_definitions(-DUNIX_AMD64_ABI)
 727   elseif (CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM)
 728     add_definitions(-DUNIX_ARM_ABI)
 729   endif()
 730
 731 endif(CLR_CMAKE_PLATFORM_UNIX)
 732
 733 add_definitions(-D_BLD_CLR)
 734 add_definitions(-DDEBUGGING_SUPPORTED)
 735 add_definitions(-DPROFILING_SUPPORTED)
 736
 737 if(WIN32)
 738   add_definitions(-DWIN32)
 739   add_definitions(-D_WIN32)
 740   add_definitions(-DWINVER=0x0602)
 741   add_definitions(-D_WIN32_WINNT=0x0602)
 742   add_definitions(-DWIN32_LEAN_AND_MEAN=1)
 743   if(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_I386)
 744     add_definitions(-D_CRT_SECURE_NO_WARNINGS)
 745     # Only enable edit and continue on windows x86 and x64
 746     # exclude Linux, arm & arm64
 747     add_definitions(-DEnC_SUPPORTED)
 748   endif(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_I386)
 749 endif(WIN32)
 750
 751 # Features - please keep them alphabetically sorted
 752
 753 add_definitions(-DFEATURE_APPDOMAIN_RESOURCE_MONITORING)
 754 if(WIN32)
 755     add_definitions(-DFEATURE_APPX)
 756 endif(WIN32)
 757 if(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_ARM OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 758     add_definitions(-DFEATURE_ARRAYSTUB_AS_IL)
 759 endif()
 760
 761 add_definitions(-DFEATURE_ASYNC_IO)
 762 add_definitions(-DFEATURE_BCL_FORMATTING)
 763 add_definitions(-DFEATURE_COLLECTIBLE_TYPES)
 764
 765 if(WIN32)
 766     add_definitions(-DFEATURE_CLASSIC_COMINTEROP)
 767     add_definitions(-DFEATURE_COMINTEROP)
 768     add_definitions(-DFEATURE_COMINTEROP_APARTMENT_SUPPORT)
 769     add_definitions(-DFEATURE_COMINTEROP_UNMANAGED_ACTIVATION)
 770     add_definitions(-DFEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION)
 771 endif(WIN32)
 772
 773 add_definitions(-DFEATURE_CORECLR)
 774 if (CLR_CMAKE_PLATFORM_UNIX)
 775   add_definitions(-DFEATURE_COREFX_GLOBALIZATION)
 776 endif(CLR_CMAKE_PLATFORM_UNIX)
 777 add_definitions(-DFEATURE_CORESYSTEM)
 778 add_definitions(-DFEATURE_CORRUPTING_EXCEPTIONS)
 779 if(CLR_CMAKE_PLATFORM_UNIX)
 780     add_definitions(-DFEATURE_DBGIPC_TRANSPORT_DI)
 781     add_definitions(-DFEATURE_DBGIPC_TRANSPORT_VM)
 782 endif(CLR_CMAKE_PLATFORM_UNIX)
 783 if(FEATURE_EVENT_TRACE)
 784     add_definitions(-DFEATURE_EVENT_TRACE=1)
 785     if(CLR_CMAKE_PLATFORM_UNIX)
 786         add_definitions(-DFEATURE_EVENTSOURCE_XPLAT=1)
 787     endif(CLR_CMAKE_PLATFORM_UNIX)
 788 endif(FEATURE_EVENT_TRACE)
 789 add_definitions(-DFEATURE_EXCEPTIONDISPATCHINFO)
 790 # NetBSD doesn't implement this feature
 791 if(NOT CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM AND NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD)
 792     add_definitions(-DFEATURE_HIJACK)
 793 endif(NOT CLR_CMAKE_PLATFORM_UNIX_TARGET_ARM AND NOT CMAKE_SYSTEM_NAME STREQUAL NetBSD)
 794 add_definitions(-DFEATURE_HOST_ASSEMBLY_RESOLVER)
 795 add_definitions(-DFEATURE_HOSTED_BINDER)
 796 add_definitions(-DFEATURE_ICASTABLE)
 797 if (CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 798   add_definitions(-DFEATURE_IMPLICIT_TLS)
 799   set(FEATURE_IMPLICIT_TLS 1)
 800 endif(CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 801 add_definitions(-DFEATURE_ISYM_READER)
 802 add_definitions(-DFEATURE_LOADER_OPTIMIZATION)
 803 add_definitions(-DFEATURE_MANAGED_ETW)
 804 add_definitions(-DFEATURE_MANAGED_ETW_CHANNELS)
 805 add_definitions(-DFEATURE_MAIN_CLR_MODULE_USES_CORE_NAME)
 806 add_definitions(-DFEATURE_MERGE_CULTURE_SUPPORT_AND_ENGINE)
 807 if(WIN32)
 808 # Disable the following for UNIX altjit on Windows
 809 add_definitions(-DFEATURE_MERGE_JIT_AND_ENGINE)
 810 endif(WIN32)
 811 add_definitions(-DFEATURE_MULTICOREJIT)
 812 add_definitions(-DFEATURE_NORM_IDNA_ONLY)
 813 if(CLR_CMAKE_PLATFORM_UNIX)
 814   add_definitions(-DFEATURE_PAL)
 815   add_definitions(-DFEATURE_PAL_SXS)
 816   add_definitions(-DFEATURE_PAL_ANSI)
 817 endif(CLR_CMAKE_PLATFORM_UNIX)
 818 if(CLR_CMAKE_PLATFORM_LINUX)
 819     add_definitions(-DFEATURE_PERFMAP)
 820 endif(CLR_CMAKE_PLATFORM_LINUX)
 821 add_definitions(-DFEATURE_PREJIT)
 822 add_definitions(-DFEATURE_RANDOMIZED_STRING_HASHING)
 823 if(NOT DEFINED CLR_CMAKE_PLATFORM_ARCH_ARM64)
 824   add_definitions(-DFEATURE_READYTORUN)
 825   set(FEATURE_READYTORUN 1)
 826 endif(NOT DEFINED CLR_CMAKE_PLATFORM_ARCH_ARM64)
 827
 828 if (WIN32)
 829   if (CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_I386)
 830     add_definitions(-DFEATURE_REJIT)
 831   endif(CLR_CMAKE_PLATFORM_ARCH_AMD64 OR CLR_CMAKE_PLATFORM_ARCH_I386)
 832 endif(WIN32)
 833
 834 add_definitions(-DFEATURE_STANDALONE_SN)
 835 add_definitions(-DFEATURE_STRONGNAME_DELAY_SIGNING_ALLOWED)
 836 add_definitions(-DFEATURE_STRONGNAME_MIGRATION)
 837 if (CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 838     add_definitions(-DFEATURE_STUBS_AS_IL)
 839 endif(CLR_CMAKE_PLATFORM_UNIX OR CLR_CMAKE_PLATFORM_ARCH_ARM64)
 840 add_definitions(-DFEATURE_SVR_GC)
 841 add_definitions(-DFEATURE_SYMDIFF)
 842 add_definitions(-DFEATURE_SYNTHETIC_CULTURES)
 843 if(CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 844   add_definitions(-DFEATURE_UNIX_AMD64_STRUCT_PASSING)
 845   add_definitions(-DFEATURE_UNIX_AMD64_STRUCT_PASSING_ITF)
 846 endif (CLR_CMAKE_PLATFORM_UNIX_TARGET_AMD64)
 847 add_definitions(-DFEATURE_USE_ASM_GC_WRITE_BARRIERS)
 848 add_definitions(-DFEATURE_VERSIONING)
 849 if(WIN32)
 850     add_definitions(-DFEATURE_VERSIONING_LOG)
 851 endif(WIN32)
 852 add_definitions(-DFEATURE_WIN32_REGISTRY)
 853 add_definitions(-DFEATURE_WINDOWSPHONE)
 854 add_definitions(-DFEATURE_WINMD_RESILIENT)
 855
 856 if(CLR_CMAKE_BUILD_TESTS)
 857   add_subdirectory(tests)
 858 endif(CLR_CMAKE_BUILD_TESTS)
 859
 860 if (CLR_CMAKE_PLATFORM_ARCH_AMD64)
 861     set(ARCH_SOURCES_DIR amd64)
 862 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM64)
 863     set(ARCH_SOURCES_DIR arm64)
 864 elseif (CLR_CMAKE_PLATFORM_ARCH_ARM)
 865     set(ARCH_SOURCES_DIR arm)
 866 elseif (CLR_CMAKE_PLATFORM_ARCH_I386)
 867     set(ARCH_SOURCES_DIR i386)
 868 else ()
 869     clr_unknown_arch()
 870 endif ()
 871
 872 add_definitions(-D_SECURE_SCL=0)
 873 add_definitions(-DUNICODE)
 874 add_definitions(-D_UNICODE)
 875
 876 # Compiler options
 877
 878 if(WIN32)
 879   add_compile_options(/FIWarningControl.h) # force include of WarningControl.h
 880   add_compile_options(/Zl) # omit default library name in .OBJ
 881 endif(WIN32)
 882
 883 # Microsoft.Dotnet.BuildTools.Coreclr version
 884 set(BuildToolsVersion "1.0.4-prerelease")
 885 set(BuildToolsDir "${CLR_DIR}/packages/Microsoft.DotNet.BuildTools.CoreCLR/${BuildToolsVersion}")
 886
 887 add_subdirectory(src)