# **********************************************************

# Copyright (c) 2010-2013 Google, Inc. All rights reserved.

# Copyright (c) 2009-2010 VMware, Inc. All rights reserved.

# **********************************************************

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions are met:

#

# * Redistributions of source code must retain the above copyright notice,

# this list of conditions and the following disclaimer.

#

# * Redistributions in binary form must reproduce the above copyright notice,

# this list of conditions and the following disclaimer in the documentation

# and/or other materials provided with the distribution.

#

# * Neither the name of VMware, Inc. nor the names of its contributors may be

# used to endorse or promote products derived from this software without

# specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED. IN NO EVENT SHALL VMWARE, INC. OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH

# DAMAGE.

###########################################################################

# Missing features:

# i#77: make DRstats a subproject to support with different compiler from libutil

# i#84: nmake adds space before 1st / in 1st arg to a command invoked with quotes

# i#74: create source tarball via 'make package_source'

# i#68: replace perl with cmake scripts and CTest

# i#70: symbol store support in core/Makefile and tools/Makefile

# i#72: RHEL3 linker script has no __executable_start

# i#60: re-add libutil/ unit tests

#

# Not filed:

# * move info like "build core solely from DDK" from make/compiler.mk into

# HowToBuild.wiki

###########################################################################

if ("${CMAKE_GENERATOR}" MATCHES "Visual Studio 10")

# for i#801 workaround

cmake_minimum_required(VERSION 2.8.8)

elseif ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")

# for output dir name control

cmake_minimum_required(VERSION 2.8.2)

else ()

cmake_minimum_required(VERSION 2.6.4) # VERSION_LESS

endif ()

# for non-makefile-based generators (i.e., Visual Studio) there is no

# CMAKE_BUILD_TYPE and instead there are multiple configs.

# note that we would love cmake to support multi-config for makefiles too,

# but given that it doesn't, and that we don't have full control

# over the output dir names (until cmake 2.8.4), I'm collapsing

# the VS generator configs to a single choice to match the makefiles.

# this must be done prior to the project() command and the var

# must be set in the cache.

if ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")

if (DEBUG)

set(CMAKE_CONFIGURATION_TYPES "Debug" CACHE STRING "" FORCE)

else (DEBUG)

set(CMAKE_CONFIGURATION_TYPES "Release" CACHE STRING "" FORCE)

endif (DEBUG)

# we want to use the _LOCATION_<config> property

string(TOUPPER "${CMAKE_CONFIGURATION_TYPES}" upper)

set(location_suffix "_${upper}")

else ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")

set(location_suffix "")

endif ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")

set(cmake_ver_string

"${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_RELEASE_VERSION}")

if ("${cmake_ver_string}" VERSION_LESS "2.6.4")

# Workaround for cmake bug #8639 where CMAKE_ASM_SOURCE_FILE_EXTENSIONS

# is not set and our asm files are not built (should be fixed in 2.6.4).

# We can simply set the var ahead of time, luckily, since noone clears it:

# Alternative workarounds:

# - Use ASM-ATT instead of ASM: should work

# - I tried puting a patched CMakeASMInformation.cmake ahead of share/Modules

# but enable_language() seems to not use the CMAKE_MODULE_PATH

set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS s;S;asm)

endif ("${cmake_ver_string}" VERSION_LESS "2.6.4")

# I want to override the default CMAKE_INSTALL_PREFIX, but allow it to

# be set (as the same var name, so CPack and other standard tools

# work) externally. The best solution is to check whether defined BEFORE

# the project() command.

# If we didn't use standard tools we could set CMAKE_INSTALL_PREFIX

# to be CACHE INTERNAL FORCE to INSTALL_PREFIX.

if (NOT DEFINED CMAKE_INSTALL_PREFIX)

set(install_override ON)

else (NOT DEFINED CMAKE_INSTALL_PREFIX)

set(install_override OFF)

endif (NOT DEFINED CMAKE_INSTALL_PREFIX)

# Allow users to set -m32 in just CFLAGS and have it apply to CXXFLAGS as well.

# CMake puts such flags in various variables early on and we'd have to go

# manually add to CMAKE_SHARED_LIBRARY_CXX_FLAGS or something to fix later.

if (NOT DEFINED ENV{CXXFLAGS})

set(ENV{CXXFLAGS} "$ENV{CFLAGS}")

endif (NOT DEFINED ENV{CXXFLAGS})

# Don't use the default-Debug build type set for the try-compiles

set(specified_build_type "${CMAKE_BUILD_TYPE}")

project(DynamoRIO NONE)

if (DEFINED GENERATE_PDBS AND NOT GENERATE_PDBS)

# i#310: support building over cygwin ssh where we cannot build pdbs.

# To prevent cmake's try-compile for its working compiler test and

# its ABI determination test we request a Release build config

# via a custom Plaform/Windows-cl.cmake in our make/ dir.

set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/make")

endif ()

enable_language(C)

enable_language(CXX)

if ("${CMAKE_GENERATOR}" MATCHES "Ninja")

# i#1040: Ninja sets the type to Debug if it's not in the cache

set(CMAKE_BUILD_TYPE "${specified_build_type}" CACHE STRING

"Choose the type of build: Debug or Release" FORCE)

else ()

set(CMAKE_BUILD_TYPE "${specified_build_type}")

endif ()

include(CheckCCompilerFlag)

###########################################################################

# utility functions

include(make/utils.cmake)

###########################################################################

# configuration options

# many are core-specific

# configurations that also have defines

option(DRSTATS_DEMO "build DRstats without the no-longer-supported Run, etc. controls" ON)

# we honor CMAKE_BUILD_TYPE since many cmake users are used to it

if ("${CMAKE_BUILD_TYPE}" MATCHES "Debug")

set(DEBUG_DEFAULT ON)

else ()

set(DEBUG_DEFAULT OFF)

endif ()

set(DEBUG_DESCR "Build with asserts and logging enabled (also controlled by CMAKE_BUILD_TYPE=Debug)")

option(DEBUG ${DEBUG_DESCR} ${DEBUG_DEFAULT})

# support later changes

if ("${CMAKE_BUILD_TYPE}" MATCHES "Debug")

set(DEBUG ON CACHE BOOL ${DEBUG_DESCR} FORCE)

elseif (NOT "${CMAKE_BUILD_TYPE}" STREQUAL "")

set(DEBUG OFF CACHE BOOL ${DEBUG_DESCR} FORCE)

endif ()

# INTERNAL option now matches DEBUG

if (DEBUG)

set(INTERNAL_DEFAULT ON)

else (DEBUG)

set(INTERNAL_DEFAULT OFF)

endif (DEBUG)

set(INTERNAL "" CACHE STRING "for developer use: ON or OFF overrides default")

if ("${INTERNAL}" STREQUAL "")

set(INTERNAL ${INTERNAL_DEFAULT})

endif()

# target

if (APPLE)

set(MACOS 1)

elseif (UNIX)

set(LINUX 1)

endif (APPLE)

if (WIN32)

set(WINDOWS 1)

endif (WIN32)

# Whether 64-bit is expected to be selected by user setting up compiler

# prior to invoking CMake: it has to be that way for Windows, and for

# Linux the user should set CFLAGS to -m32 or -m64

# to override gcc's default. To simplify matters we only look at

# CMAKE_C_SIZEOF_DATA_PTR, controlled by CFLAGS, so the user doesn't

# have to also set CXXFLAGS (CMAKE_SIZEOF_VOID_P happens

# to come from CXXFLAGS). (CMAKE_C_SIZEOF_DATA_PTR can be relied on

# to be set in all CMake versions we support.)

if (CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)

set(X64 ON)

else(CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)

set(X64 OFF)

endif (CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)

option(VMKERNEL "target VMkernel (not officially supported yet)")

# high-level configurations

option(VMAP "client support" ON)

option(VPS "security support but no client support")

option(VMSAFE "client support including security API")

if (VMAP)

set(CLIENT_INTERFACE 1)

set(APP_EXPORTS 1)

endif (VMAP)

if (VMSAFE)

set(PROGRAM_SHEPHERDING 1)

set(CLIENT_INTERFACE 1)

set(APP_EXPORTS 1)

set(HOT_PATCHING_INTERFACE 1)

endif (VMSAFE)

if (VPS)

set(PROGRAM_SHEPHERDING 1)

set(HOT_PATCHING_INTERFACE 1)

set(PROCESS_CONTROL 1)

if (WIN32)

set(GBOP 1)

endif (WIN32)

endif (VPS)

option(STATIC_LIBRARY "build DR statically (not supported yet)")

if (STATIC_LIBRARY)

set(SHARED_OR_STATIC STATIC)

else ()

set(SHARED_OR_STATIC SHARED)

endif ()

# temporary: once build+support issues fixed, remove and add HOT_PATCHING_INTERFACE

# to VMAP by default

option(PROBE "enable not-yet-supported Probe API")

mark_as_advanced(PROBE)

if (PROBE)

set(HOT_PATCHING_INTERFACE 1)

endif (PROBE)

# For developers

# CMake note: never set option vars as it prevents override by cache var:

# instead set default value in separate var and use that to initialize option.

# For a dependent option, use a string var and only set it if the string is ""

# (xref i#170 and see below).

if (INTERNAL OR DEBUG)

set(KSTATS_DEFAULT ON)

else (INTERNAL OR DEBUG)

set(KSTATS_DEFAULT 0FF)

endif (INTERNAL OR DEBUG)

# no KSTATS for caller profiling: we want to be as close to release

# build as we can, but w/o optimizations

if (CALLPROF)

set(KSTATS_DEFAULT 0FF)

endif (CALLPROF)

set(KSTATS "" CACHE STRING "internal kstat profiling: ON or OFF overrides default")

# FIXME i#170: once CMake 2.8 is released we can detect whether 2.8 is

# in use, and if so use a value-enum to get drop-down of possible values, like so:

# set_property(CACHE KSTATS PROPERTY STRINGS "" "ON" "OFF")

if ("${KSTATS}" STREQUAL "")

set(KSTATS ${KSTATS_DEFAULT})

endif()

option(CALLPROF "internal caller profiling support")

option(LINKCOUNT "internal linkcount profiling")

option(PROFILE "profiling build: disables FPO and tweaks other flags" OFF)

if (WIN32)

# xref PR 192750 - runregression uses this to avoid over-ssh pdb issues

option(GENERATE_PDBS "generate Windows debug information" ON)

# instead of config files use registry like in the old days

# (i#85/PR 212034 and i#265/PR 486139 switched DR to config files)

option(PARAMS_IN_REGISTRY "parameters from registry instead of config files")

endif (WIN32)

# for users

option(DISABLE_WARNINGS "disable warnings")

option(SET_PREFERRED_BASE "set a preferred library base address")

if (WIN32 AND DEBUG)

# apparently no numeric type so we use STRING

set(preferred_base "0x15000000" CACHE STRING "Preferred library base address")

elseif (UNIX AND NOT X64)

# put dynamorio at top of address space, little chance of conflict

set(preferred_base "0xf7000000" CACHE STRING "Preferred library base address")

else (UNIX AND NOT X64)

set(preferred_base "0x71000000" CACHE STRING "Preferred library base address")

endif (WIN32 AND DEBUG)

# for x64: PR 253624: we need our library to be next to our heap

# for win32: not PIC so need a base

# we studied existing exe + dll bases and tried to pick non-conflicting addresses

# for 32-bit Linux: we put dynamorio at top of address space so little chance

# of conflict with app for early injection.

# there should be no noticeable perf hit from this (b/c no relocations for DR lib)

# so it's ok to be on for non-early injection

set(SET_PREFERRED_BASE 1)

if (VMKERNEL)

# we end up with the default executable base (0x08*) so go back to 0 base

# (else we fail to load on esx)

set(SET_PREFERRED_BASE 1)

set(preferred_base "0x00000000")

endif (VMKERNEL)

# we do not support most users choosing these

mark_as_advanced(

VMKERNEL

VMAP

VMSAFE

VPS

KSTATS

CALLPROF

LINKCOUNT

PROFILE

SET_PREFERRED_BASE

preferred_base

GENERATE_PDBS

DRSTATS_DEMO

)

# we clear both base and build-type cflags and then use just base.

# XXX: could use CMAKE_USER_MAKE_RULES_OVERRIDE to set these but not any cleaner

#

# i#919: Ninja generator does not leave CMAKE_BUILD_TYPE blank, and that affects

# the exported target files, so we set it here. This shouldn't hurt containing

# tools as they should set our DEBUG to match the incoming CMAKE_BUILD_TYPE.

if ("${CMAKE_BUILD_TYPE}" STREQUAL "")

if (DEBUG)

set(CMAKE_BUILD_TYPE "Debug")

else (DEBUG)

set(CMAKE_BUILD_TYPE "Release")

endif (DEBUG)

endif ()

string(TOUPPER "${CMAKE_BUILD_TYPE}" CMAKE_BUILD_TYPE_UPPER)

foreach (config ${CMAKE_BUILD_TYPE} ${CMAKE_CONFIGURATION_TYPES})

string(TOUPPER "${config}" config_upper)

foreach (var

CMAKE_C_FLAGS_${config_upper};

CMAKE_CXX_FLAGS_${config_upper};

CMAKE_EXE_LINKER_FLAGS_${config_upper};

CMAKE_MODULE_LINKER_FLAGS_${config_upper};

CMAKE_SHARED_LINKER_FLAGS_${config_upper})

set(${var} " ") # if "" defaults come back

endforeach ()

endforeach ()

foreach (var CMAKE_C_FLAGS;CMAKE_CXX_FLAGS)

set(${var} " ") # if "" defaults come back

endforeach ()

##################################################

# resources when packaging

# i#83: use svn revision of last commit as patchlevel ver# to distinguish

# mid-release builds.

# XXX: if we later switch to a non-linear version control system we'll

# want to switch to a date or something, but be aware of timezone issues

# so we may want a cron job that updates an official date in the sources.

set(VERSION_NUMBER_PATCHLEVEL 0)

# for now using a hack of running svn or git to get the ver#,

# rather than having it stored in the sources and auto-updated

if (EXISTS "${PROJECT_SOURCE_DIR}/.svn")

find_program(SVN svn DOC "subversion client")

if (SVN)

execute_process(COMMAND ${SVN} info

WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"

RESULT_VARIABLE svn_result

ERROR_VARIABLE svn_err

OUTPUT_VARIABLE svn_out)

if (svn_result OR svn_err)

message(FATAL_ERROR "*** ${SVN} info failed: ***\n${svn_result} ${svn_err}")

endif (svn_result OR svn_err)

string(REGEX MATCH "Revision: [0-9]+" svn_ver "${svn_out}")

string(REGEX REPLACE "Revision: " "" svn_ver "${svn_ver}")

if ("${svn_ver}" STREQUAL "")

# could be another language (xref i#401) so look just for number

# which will rule out URL and UUID fields

string(REGEX MATCH ": [0-9]+\r?\n" svn_ver "${svn_out}")

string(REGEX REPLACE ": ([0-9]+)\r?\n" "\\1" svn_ver "${svn_ver}")

endif ("${svn_ver}" STREQUAL "")

if ("${svn_ver}" STREQUAL "")

# indicate we failed w/ impossible ver#

message(STATUS "WARNING: Unable to obtain actual revision number")

set(VERSION_NUMBER_PATCHLEVEL "42")

else ("${svn_ver}" STREQUAL "")

set(VERSION_NUMBER_PATCHLEVEL "${svn_ver}")

endif ("${svn_ver}" STREQUAL "")

endif (SVN)

else (EXISTS "${PROJECT_SOURCE_DIR}/.svn")

if (EXISTS "${PROJECT_SOURCE_DIR}/.git")

find_program(GIT git DOC "git client")

if (GIT)

execute_process(COMMAND ${GIT} log

WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"

RESULT_VARIABLE git_result

ERROR_VARIABLE git_err

OUTPUT_VARIABLE git_out)

if (git_result OR git_err)

message(FATAL_ERROR "*** ${GIT} show failed: ***\n${git_err}")

endif (git_result OR git_err)

# look for first commit with git-svn-id

string(REGEX MATCH "git-svn-id: http[^@]*@[0-9]+" git_out "${git_out}")

string(REGEX REPLACE "git-svn-id: http[^@]*@" "" git_out "${git_out}")

if (NOT "${git_out}" STREQUAL "")

set(VERSION_NUMBER_PATCHLEVEL "${git_out}")

endif (NOT "${git_out}" STREQUAL "")

endif (GIT)

endif (EXISTS "${PROJECT_SOURCE_DIR}/.git")

endif (EXISTS "${PROJECT_SOURCE_DIR}/.svn")

# N.B.: if VERSION_NUMBER's major number is incremented without also

# incrementing OLDEST_COMPATIBLE_VERSION we'll need to add another

# symlink loop in core/CMakeLists.txt

set(VERSION_NUMBER_DEFAULT "4.1.${VERSION_NUMBER_PATCHLEVEL}")

# do not store the default VERSION_NUMBER in the cache to prevent a stale one

# from preventing future version updates in a pre-existing build dir

set(VERSION_NUMBER "" CACHE STRING "Version number: leave empty for default")

if ("${VERSION_NUMBER}" STREQUAL "")

set(VERSION_NUMBER ${VERSION_NUMBER_DEFAULT})

endif()

string(REGEX REPLACE "\\." "," VERSION_COMMA_DELIMITED "${VERSION_NUMBER}")

message(STATUS "Version number: ${VERSION_NUMBER}")

set(BUILD_NUMBER "0" CACHE STRING "Build number (must be <64K)")

set(UNIQUE_BUILD_NUMBER "0" CACHE STRING "Unique build number")

set(CUSTOM_PRODUCT_NAME "" CACHE STRING "Custom product name")

mark_as_advanced(

VERSION_NUMBER

VERSION_COMMA_DELIMITED

BUILD_NUMBER

UNIQUE_BUILD_NUMBER

CUSTOM_PRODUCT_NAME

)

# This is hardcoded in globals_shared.h: going to leave it that way, but

# adding indirection within cmake files

set(PRODUCT_NAME "DynamoRIO")

if (install_override)

set(CMAKE_INSTALL_PREFIX "${PROJECT_SOURCE_DIR}/exports"

CACHE PATH "install path" FORCE)

endif (install_override)

# for historical reasons we have a separate mirror var

set(INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")

###########################################################################

# toolchain

# Set up assembly support and CMAKE_CPP.

# Note that in cmake < 2.6.4, I had to fix a bug in

# /usr/share/cmake/Modules/CMakeASMInformation.cmake

# where @VAR@ expansion was used, which only works for configure_file()

# now fixed in CMake/Modules/CMakeASMInformation.cmake:1.5

# See top of top-level CMakeLists.txt for our workaround.

set(cpp2asm_newline_script_path "${PROJECT_SOURCE_DIR}/make/CMake_asm.cmake")

include(make/cpp2asm_support.cmake)

if (UNIX)

# We require gas >= 2.18.50 for --32, --64, and the new -msyntax=intel, etc.

# Since this is pretty recent we include a copy (built vs as old a glibc

# as was convenient)

if (NOT CMAKE_ASM_SUPPORTS_INTEL_SYNTAX)

message("${CMAKE_ASM_COMPILER} too old: using ${PROJECT_SOURCE_DIR}/make/as-2.18.50")

set(CMAKE_ASM_COMPILER "${PROJECT_SOURCE_DIR}/make/as-2.18.50")

endif (NOT CMAKE_ASM_SUPPORTS_INTEL_SYNTAX)

endif (UNIX)

if (UNIX)

# Assume clang behaves like gcc. CMake 2.6 won't detect clang and will set

# CMAKE_COMPILER_IS_GNUCC to TRUE, but 2.8 does not. We prefer the 2.6

# behavior.

string(REGEX MATCH "clang" CMAKE_COMPILER_IS_CLANG "${CMAKE_C_COMPILER}")

if (CMAKE_COMPILER_IS_CLANG)

set(CMAKE_COMPILER_IS_GNUCC TRUE)

endif ()

if (CYGWIN)

message(FATAL_ERROR "building using gcc within cygwin is not supported")

endif (CYGWIN)

if (NOT CMAKE_COMPILER_IS_GNUCC)

# we use gcc extensions

message(FATAL_ERROR "gcc is required to build")

endif (NOT CMAKE_COMPILER_IS_GNUCC)

check_if_linker_is_gnu_gold(LINKER_IS_GNU_GOLD)

else (UNIX)

if (NOT ${COMPILER_BASE_NAME} STREQUAL "cl")

# we use cl pragmas and intrinsics

message(FATAL_ERROR "cl (Microsoft C++ compiler) is required to build")

endif (NOT ${COMPILER_BASE_NAME} STREQUAL "cl")

# CMake older than 2.6.3 does not automatically look for ml or ml64

if ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")

# CMAKE_C_COMPILER doesn't have full path, unless user has in PATH

if (MSVC10)

get_filename_component(vc_dir [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0\\Setup\\VC;ProductDir] REALPATH)

elseif (MSVC90)

get_filename_component(vc_dir [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\9.0\\Setup\\VC;ProductDir] REALPATH)

elseif (MSVC80)

get_filename_component(vc_dir [HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup\\VC;ProductDir] REALPATH)

endif()

if (X64)

set(cl_path "${vc_dir}/bin/amd64")

else (X64)

set(cl_path "${vc_dir}/bin")

endif (X64)

# while we can get the cl path, we can't run cl b/c mspdb80.dll must

# be on the PATH: so even w/ VS generators we require PATH to be set.

if ("${CMAKE_C_COMPILER}" STREQUAL "cl")

set(CMAKE_C_COMPILER "${cl_path}/${CMAKE_C_COMPILER}")

endif ()

else ()

get_filename_component(cl_path ${CMAKE_C_COMPILER} PATH)

endif ()

# cmake has CMAKE_RC_COMPILER, but no message compiler

if ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")

# this path is only present for 2008+, but we currently require PATH to

# be set up anyway

get_filename_component(sdk_dir "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]" REALPATH)

if (X64)

set(sdk_bindir "${sdk_dir}/bin/x64")

else (X64)

set(sdk_bindir "${sdk_dir}/bin")

endif (X64)

endif ()

find_program(CMAKE_MC_COMPILER mc.exe HINTS "${sdk_bindir}"

DOC "path to message compiler")

if (NOT CMAKE_MC_COMPILER)

message(FATAL_ERROR "message compiler not found: required to build")

endif (NOT CMAKE_MC_COMPILER)

message(STATUS "Found message compiler: ${CMAKE_MC_COMPILER}")

mark_as_advanced(CMAKE_MC_COMPILER)

endif (UNIX)

find_package(Perl)

if (NOT PERL_FOUND)

message(FATAL_ERROR "perl is required to build")

endif (NOT PERL_FOUND)

if (UNIX) # unlikely to be an issue on Windows

# Check for uint, etc. typedef conflicts like on rhel3 (i#18)

# and set DR_DO_NOT_DEFINE_*

# Note that for later gcc uint and ushort seem to be "soft typedefs":

# defined, but overridable: ?!?

include(CheckTypeSize)

CHECK_TYPE_SIZE(uint DR_DO_NOT_DEFINE_uint)

CHECK_TYPE_SIZE(ushort DR_DO_NOT_DEFINE_ushort)

CHECK_TYPE_SIZE(bool DR_DO_NOT_DEFINE_bool)

CHECK_TYPE_SIZE(byte DR_DO_NOT_DEFINE_byte)

CHECK_TYPE_SIZE(sbyte DR_DO_NOT_DEFINE_sbyte)

CHECK_TYPE_SIZE(uint32 DR_DO_NOT_DEFINE_uint32)

CHECK_TYPE_SIZE(uint64 DR_DO_NOT_DEFINE_uint64)

CHECK_TYPE_SIZE(int32 DR_DO_NOT_DEFINE_int32)

CHECK_TYPE_SIZE(int64 DR_DO_NOT_DEFINE_int64)

# we could do CHECK_SYMBOL_EXISTS for MAX and MIN but they're not

# in standard headers so up to user to define if an issue

if (DR_DO_NOT_DEFINE_bool)

# i#488: ensure bool compatibility with C++

if (NOT ${DR_DO_NOT_DEFINE_bool} EQUAL 1)

message(FATAL_ERROR "incompatible pre-defined \"bool\" type is larger than 1 byte")

endif (NOT ${DR_DO_NOT_DEFINE_bool} EQUAL 1)

endif (DR_DO_NOT_DEFINE_bool)

CHECK_TYPE_SIZE(_Bool DR__Bool_EXISTS)

if (DR__Bool_EXISTS)

if (NOT ${DR__Bool_EXISTS} EQUAL 1)

message(FATAL_ERROR "incompatible \"_Bool\" type is larger than 1 byte")

endif (NOT ${DR__Bool_EXISTS} EQUAL 1)

endif (DR__Bool_EXISTS)

endif (UNIX)

###########################################################################

# basic build rules and flags

# compiler flags

if (UNIX)

# -std=c99 doesn't quite work

# FIXME case 191480: we used to pass -pedantic just to cpp;

# now w/ no separate cpp step we should eliminate the

# warnings and pass -pedantic to main gcc

set(BASE_CFLAGS "-std=gnu99")

# disable strict aliasing opt in gcc 3.3.3 -- gives warnings and makes bad assumptions

set(BASE_CFLAGS "${BASE_CFLAGS} -fno-strict-aliasing")

# Ubuntu defaults to -fstack-protector these days, which depends on app TLS.

CHECK_C_COMPILER_FLAG("-fno-stack-protector" no_stack_protector_avail)

if (no_stack_protector_avail)

set(BASE_CFLAGS "${BASE_CFLAGS} -fno-stack-protector")

endif (no_stack_protector_avail)

# now that the user must set non-default -mNN we don't nec. need these:

if (X64)

set(BASE_CFLAGS "-m64 ${BASE_CFLAGS}")

set(BASE_CXXFLAGS "-m64")

set(LD_FLAGS "-melf_x86_64")

else (X64)

set(BASE_CFLAGS "-m32 ${BASE_CFLAGS}")

set(BASE_CXXFLAGS "-m32")

# i#847 keep stack boundary 4-byte aligned

set(BASE_CFLAGS "${BASE_CFLAGS} -mpreferred-stack-boundary=2")

set(BASE_CXXFLAGS "${BASE_CXXFLAGS} -mpreferred-stack-boundary=2")

set(LD_FLAGS "-melf_i386")

endif (X64)

# there's no cmake warning control so we hardcode it

set(WARN "-Wall -Werror -Wwrite-strings")

if (NOT CMAKE_COMPILER_IS_CLANG)

# Old gcc's ignore unknown -W flags, but -Wall -Werror causes clang to

# complain that it doesn't recognize it.

# Actually this is not true: gcc 4.1.2 aborts on unknown -W so we check

CHECK_C_COMPILER_FLAG("-Wno-unused-but-set-variable" nounused_avail)

if (nounused_avail)

set(WARN "${WARN} -Wno-unused-but-set-variable")

endif (nounused_avail)

else (NOT CMAKE_COMPILER_IS_CLANG)

# clang turns off color when it's writing to a pipe, but the user may still

# wish to force color if it eventually goes to a terminal.

option(CLANG_COLOR_DIAGNOSTICS "force colored clang diagnostics" OFF)

set(clang_args "")

if (CLANG_COLOR_DIAGNOSTICS)

set(clang_args "-fcolor-diagnostics ${clang_args}")

endif (CLANG_COLOR_DIAGNOSTICS)

# Apply to both C and C++.

set(BASE_CFLAGS "${clang_args} ${BASE_CFLAGS}")

set(BASE_CXXFLAGS "${clang_args} ${BASE_CXXFLAGS}")

endif (NOT CMAKE_COMPILER_IS_CLANG)

set(DBG "-g3")

# gcc doesn't change its optimizations based on -g

set(OPT "-O3 ${DBG}")

if (PROFILE)

set(OPT "${OPT} -fno-omit-frame-pointer")

endif ()

if (NOT APPLE)

# Generate the .hash section in addition to .gnu.hash for every target, to

# avoid SIGFPE when running our binaries on old systems:

foreach (config ${CMAKE_BUILD_TYPE} ${CMAKE_CONFIGURATION_TYPES})

string(TOUPPER "${config}" config_upper)

foreach (var

CMAKE_EXE_LINKER_FLAGS_${config_upper};

CMAKE_MODULE_LINKER_FLAGS_${config_upper};

CMAKE_SHARED_LINKER_FLAGS_${config_upper})

set(${var} "-Wl,--hash-style=both")

endforeach ()

endforeach ()

endif ()

# XXX: core-specific: move to core/CMakeLists.txt?

#

# XXX: i#374: we used to use -O to avoid stack overflow in debug

# build (makes a huge difference by having locals/temps share stack

# slots) and had -fno-omit-frame-pointer to keep things more easily

# debuggable (though gcc claims only omits when debuggable), but

# even then many locals were optimized away, and utils.c's first

# statsx.h expansion took over a minute to compile with some

# versions of gcc, so removing the -O (can't repro the stack

# overflows now anyway). If we hit the overflows again, we should

# use -O0 and optimize attributes on the few funcs that need higher

# opt.

set(DBG_OPT "-fno-omit-frame-pointer")

# We disable strcmp intrinsic to avoid stack overflow in

# set_dynamo_options(): case 7853.

if (NOT CMAKE_COMPILER_IS_CLANG)

set(DBG_OPT "${DBG_OPT} -fno-builtin-strcmp")

endif ()

else (UNIX)

# FIXME: why isn't ${CMAKE_CL_NOLOGO} set?

set(BASE_CFLAGS "/nologo")

# build in parallel, always.

# note that /MP is not officially supported on VS 2005 and others

# have seen occasional problems: we'll risk it. we could check for

# "MSVC10 OR MSVC90".

set(BASE_CFLAGS "${BASE_CFLAGS} /MP")

# read-only string pooling

set(BASE_CFLAGS "${BASE_CFLAGS} /GF")

# FIXME case 191729: we should try to enable this.

# Currently we get "unresolved external symbol ___security_cookie"

set(BASE_CFLAGS "${BASE_CFLAGS} /GS-")

# VS2010 has /MD as the default (and does declspec(dllimport) for

# libc routines) so make sure we explicitly request /MT

set(BASE_CFLAGS "${BASE_CFLAGS} /MT")

set(WARN "/W4 /WX")

# Default from cmake has /W3 so remove to avoid warning about overriding

string(REGEX REPLACE "/W[0-9]" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")

string(REGEX REPLACE "/W[0-9]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")

if (GENERATE_PDBS)

set(DBG "/Zi")

set(LINK_DBG "/debug")

set(ASM_DBG "/Zi /Zd")

else (GENERATE_PDBS)

# xref PR 192750 - runregression uses this to avoid over-ssh pdb issues

set(DBG "")

set(LINK_DBG "")

set(ASM_DBG "")

# Default from cmake in DEBUG and RELWITHDEBINFO has /debug

string(REGEX REPLACE "/debug" "" CMAKE_EXE_LINKER_FLAGS

"${CMAKE_EXE_LINKER_FLAGS}")

string(REGEX REPLACE "/debug" "" CMAKE_MODULE_LINKER_FLAGS

"${CMAKE_MODULE_LINKER_FLAGS}")

string(REGEX REPLACE "/debug" "" CMAKE_SHARED_LINKER_FLAGS

"${CMAKE_SHARED_LINKER_FLAGS}")

endif (GENERATE_PDBS)

# w/ cl, using DBG here won't mess up the optimizations, debug line number info

# gets a little messed up, but is better than nothing

set(OPT "/O2 ${DBG}")

# do not use /O2 on windows, it messes up debug info!

# explicitly request /Od even though it's cl's default b/c VS has /O2 as default

# and cl 14.00 hangs compiling core/fragment.c with /Od and DEBUG.

set(DBG_OPT "/Od")

set(ASM_FLAGS "/nologo ${ASM_DBG}")

set(BASE_CXXFLAGS "${BASE_CFLAGS}")

if (CMAKE_RC_FLAGS)

set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} /nologo")

else ()

set(CMAKE_RC_FLAGS "/nologo")

endif ()

endif (UNIX)

string(REPLACE " " ";" ASM_FLAGS_LIST "${ASM_FLAGS}")

if (UNIX)

# Check for -fvisibility

# PR 262458: for gcc >= 3.4 we can use -fvisibility instead of a

# linker version script. Note that we're still using a linker

# script to set our preferred base (PR 253624) and will need to

# for section ordering as well (PR 208267) but those are separate

# scripts.

# Only export functions so marked via attributes

# (For older gcc we use an ugly linker script and an auto-generated export list)

# Using "internal" instead of "hidden" b/c we don't need any indirect

# calls to our non-exported functions

CHECK_C_COMPILER_FLAG("-fvisibility=internal" HAVE_FVISIBILITY_INTERNAL)

CHECK_C_COMPILER_FLAG("-fvisibility=hidden" HAVE_FVISIBILITY_HIDDEN)

# XXX: on macos w/ gcc 4.2.1, the internal flag is accepted with just a

# warning, so the CHECK_C_COMPILER_FLAG passes above. For now we just go to

# hidden for macos instead of a manual test for the warning.

if (HAVE_FVISIBILITY_INTERNAL AND NOT APPLE)

set(VISIBILITY "internal")

elseif (HAVE_FVISIBILITY_HIDDEN)

set(VISIBILITY "hidden")

else ()

message("${CMAKE_C_COMPILER} missing flag -fvisibility, using linker "

"script instead")

set(VISIBILITY " ")

endif ()

if (VISIBILITY)

set(BASE_CFLAGS "${BASE_CFLAGS} -fvisibility=${VISIBILITY}")

set(BASE_CXXFLAGS "${BASE_CXXFLAGS} -fvisibility=${VISIBILITY}")

set(HAVE_FVISIBILITY ON)

endif (VISIBILITY)

if (APPLE OR LINKER_IS_GNU_GOLD)

# XXX: for macos, currently assuming using xcode toolchain.

set(ld_script_option "")

else ()

# Better to use -dT when passing linker options through gcc, but ld

# prior to 2.18 only supports -T

# FIXME: should we duplicate this in DynamoRIOConfig.cmake?

execute_process(COMMAND

${CMAKE_LINKER} --help

RESULT_VARIABLE ld_result

ERROR_VARIABLE ld_error

OUTPUT_VARIABLE ld_out)

if (ld_result OR ld_error)

message(FATAL_ERROR "*** ${CMAKE_LINKER} failed: ***\n${ld_error}")

endif (ld_result OR ld_error)

string(REGEX MATCH "dT" flag_present "${ld_out}")

if (NOT flag_present)

message("${CMAKE_LINKER} missing flag -dT, using -T instead")

set(ld_script_option "-T")

else (NOT flag_present)

set(ld_script_option "-dT")

endif (NOT flag_present)

endif ()

# In the past, there have been tools on Linux that don't know how to follow

# .gnu_debuglink. While we aren't aware of any major tools with this bug

# today, it's useful to be able to turn this off while experimenting with new

# tools.

option(SPLIT_SYMBOLS "whether to split debug symbols from binaries" ON)

mark_as_advanced(SPLIT_SYMBOLS)

# We want separate .debug files for all shared libraries

if (SPLIT_SYMBOLS AND NOT DEFINED CMAKE_OBJCOPY)

find_package(BinUtils)

endif ()

if (SPLIT_SYMBOLS AND EXISTS ${CMAKE_OBJCOPY} AND EXISTS ${CMAKE_STRIP})

# Check for --only-keep-debug support: added ~2.15

execute_process(COMMAND

${CMAKE_OBJCOPY} --help

RESULT_VARIABLE objcopy_result

ERROR_QUIET

OUTPUT_VARIABLE objcopy_out)

if (objcopy_result)

message(FATAL_ERROR "*** ${CMAKE_OBJCOPY} failed to run ***\n")

endif (objcopy_result)

set(strip_local "-x") # Strip local (non-exported) symbols from .symtab.

if (PROFILE)

# Keep .symtab for tools (objdump) that don't always handle split debug

# info gracefully.

set(strip_local "")

endif ()

string(REGEX MATCH "only-keep-debug" flag_present "${objcopy_out}")

if (NOT flag_present)

message("${CMAKE_OBJCOPY} missing flag --only-keep-debug: leaving debug info in .so files")

else (NOT flag_present)

set(CMAKE_C_CREATE_SHARED_LIBRARY

# standard rule

"<CMAKE_C_COMPILER> <CMAKE_SHARED_LIBRARY_C_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_C_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"

# now create a .debug copy

"${CMAKE_OBJCOPY} --only-keep-debug <TARGET> <TARGET>.debug"

# link original to point at .debug copy

# directory components are removed, so "../lib/" is fine

"${CMAKE_OBJCOPY} --add-gnu-debuglink=<TARGET>.debug <TARGET>"

# We can't strip everything since a client's _USES_DR_VERSION_ will be

# removed, so we only strip debug (-g) and local (-x):

# i#572: We used to pass -p here, but that floors the mtime.

"${CMAKE_STRIP} -g ${strip_local} <TARGET>"

)

SET(CMAKE_C_LINK_EXECUTABLE

"<CMAKE_C_COMPILER> <FLAGS> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"

"${CMAKE_OBJCOPY} --only-keep-debug <TARGET> <TARGET>.debug"

"${CMAKE_OBJCOPY} --add-gnu-debuglink=<TARGET>.debug <TARGET>"

"${CMAKE_STRIP} -g ${strip_local} <TARGET>"

)

set(CMAKE_CXX_CREATE_SHARED_LIBRARY

# standard rule

"<CMAKE_CXX_COMPILER> <CMAKE_SHARED_LIBRARY_CXX_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS> <CMAKE_SHARED_LIBRARY_SONAME_CXX_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>"

# now create a .debug copy

"${CMAKE_OBJCOPY} --only-keep-debug <TARGET> <TARGET>.debug"

# link original to point at .debug copy

# directory components are removed, so "../lib/" is fine

"${CMAKE_OBJCOPY} --add-gnu-debuglink=<TARGET>.debug <TARGET>"

# We can't strip everything since a client's _USES_DR_VERSION_ will be

# removed, so we only strip debug (-g) and local (-x):

# i#572: We used to pass -p here, but that floors the mtime.

"${CMAKE_STRIP} -g ${strip_local} <TARGET>"

)

SET(CMAKE_CXX_LINK_EXECUTABLE

"<CMAKE_CXX_COMPILER> <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>"

"${CMAKE_OBJCOPY} --only-keep-debug <TARGET> <TARGET>.debug"

"${CMAKE_OBJCOPY} --add-gnu-debuglink=<TARGET>.debug <TARGET>"

"${CMAKE_STRIP} -g ${strip_local} <TARGET>"

)

endif (NOT flag_present)

endif (SPLIT_SYMBOLS AND EXISTS ${CMAKE_OBJCOPY} AND EXISTS ${CMAKE_STRIP})

endif (UNIX)

# Should we be using fewer of these and using cmake's Debug vs Release?

# Release => -O3 -NDEBUG

# Right now we only support gcc and cl but could change in future

if (DEBUG)

set(CMAKE_C_FLAGS "${BASE_CFLAGS} ${DBG} ${DBG_OPT}")

set(CMAKE_CXX_FLAGS "${BASE_CXXFLAGS} ${DBG} ${DBG_OPT}")

else (DEBUG)

if (CALLPROF)

# no opts -- we need to avoid messing up call frame walking

# FIXME: just disable frame ptr elim opt: but /Oy- ran into some issues

set (OPT "")

endif (CALLPROF)

set(CMAKE_C_FLAGS "${BASE_CFLAGS} ${OPT}")

set(CMAKE_CXX_FLAGS "${BASE_CXXFLAGS} ${OPT}")

endif (DEBUG)

if (NOT DISABLE_WARNINGS)

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARN}")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARN}")

endif (NOT DISABLE_WARNINGS)

###########################################################################

# Issue 20: cross-arch execve depends on these being distinct and not

# subsets of each other (e.g., not "lib" and "lib64") and on the

# release package using these same names.

set(INSTALL_LIB_X64 lib64)

set(INSTALL_LIB_X86 lib32)

if (X64)

set(INSTALL_LIB_BASE ${INSTALL_LIB_X64})

set(INSTALL_BIN bin64)

else (X64)

set(INSTALL_LIB_BASE ${INSTALL_LIB_X86})

set(INSTALL_BIN bin32)

endif (X64)

if (DEBUG)

set(INSTALL_LIB ${INSTALL_LIB_BASE}/debug)

else (DEBUG)

set(INSTALL_LIB ${INSTALL_LIB_BASE}/release)

endif (DEBUG)

set(INSTALL_INCLUDE include)

set(INSTALL_DOCS docs)

# samples are installed via api/samples/ separate CMake project

set(INSTALL_CMAKE cmake)

set(BUILD_INCLUDE "${PROJECT_BINARY_DIR}/${INSTALL_INCLUDE}")

set(BUILD_CMAKE "${PROJECT_BINARY_DIR}/${INSTALL_CMAKE}")

# support DynamoRIO being included as a subdir inside a tool's project,

# where the tool will likely want to suppress DR's install rules.

if (NOT DEFINED DO_DR_INSTALL)

set(DO_DR_INSTALL ON)

endif (NOT DEFINED DO_DR_INSTALL)

macro(DR_install)

if (DO_DR_INSTALL)

install(${ARGV})

endif (DO_DR_INSTALL)

endmacro(DR_install)

# To support an including project exporting its own targets we need

# to export dynamorio, our extensions, and our exports file, but

# we want the includer to be able to stick the actual binaries

# in one place. So we have both a bool DO_DR_INSTALL_TARGETS

# and a path DR_INSTALL_TARGETS_DEST:

if (DO_DR_INSTALL OR NOT DEFINED DO_DR_INSTALL_TARGETS)

set(DO_DR_INSTALL_TARGETS ON)

endif ()

macro(DR_target_install)

if (DO_DR_INSTALL_TARGETS)

install(${ARGV})

endif (DO_DR_INSTALL_TARGETS)

endmacro(DR_target_install)

function (install_exported_target target dest)

if (DO_DR_INSTALL_TARGETS)

if (DEFINED DR_INSTALL_TARGETS_DEST)

set(inst_dst ${DR_INSTALL_TARGETS_DEST})

else ()

set(inst_dst ${dest})

endif ()

install(TARGETS ${target} EXPORT ${exported_targets_name}

DESTINATION ${inst_dst} ${ARGN})

endif (DO_DR_INSTALL_TARGETS)

endfunction (install_exported_target)

# mirror install path for easier use from build dir

# most libs go in base; DR and preload go in {debug,release} subdir

set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${INSTALL_LIB_BASE}")

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")

set(DR_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${INSTALL_LIB}")

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/${INSTALL_BIN}")

# if drinjectlib is built before any exe target this dir won't exist

# and the "cmake -E copy" will fail (PR 549174)

file(MAKE_DIRECTORY "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")

function (set_per_config_ouput_to_match_single_config)

if ("${CMAKE_GENERATOR}" MATCHES "Visual Studio")

# we don't want to support the Debug and Release subdirs so

# we rely on cmake 2.8.2's control over their names

# (up above we require 2.8.2+ for VS generators)

foreach (config ${CMAKE_CONFIGURATION_TYPES})

string(TOUPPER "${config}" config_upper)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${config_upper}

"${CMAKE_RUNTIME_OUTPUT_DIRECTORY}" PARENT_SCOPE)

set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${config_upper}

"${CMAKE_ARCHIVE_OUTPUT_DIRECTORY}" PARENT_SCOPE)

set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${config_upper}

"${CMAKE_LIBRARY_OUTPUT_DIRECTORY}" PARENT_SCOPE)

endforeach ()

endif ()

endfunction (set_per_config_ouput_to_match_single_config)

set_per_config_ouput_to_match_single_config()

# set var needed by configure.cmake.h

string(REGEX REPLACE

"^([0-9]+)\\..*" "\\1" VERSION_NUMBER_MAJOR "${VERSION_NUMBER}")

string(REGEX REPLACE

"^[0-9]+\\.([0-9]+)\\..*" "\\1" VERSION_NUMBER_MINOR "${VERSION_NUMBER}")

math(EXPR VERSION_NUMBER_INTEGER

"${VERSION_NUMBER_MAJOR}*100 + ${VERSION_NUMBER_MINOR}")

# 4.1 broke backcompat in drsyms + 64-bit core (opcodes + reachability)

# 4.0 broke backcompat in drmgr, drsyms, drinjectlib, and dr_get_milliseconds()

set(OLDEST_COMPATIBLE_VERSION "401")

# i#955: a Windows version of ELF DT_RPATH where a local file stores lib paths

set(DR_RPATH_SUFFIX "drpath")

# This does a copy-if-different, so it won't trigger recompilation of

# every single source file if no changes

configure_file(

${PROJECT_SOURCE_DIR}/make/configure.cmake.h

${PROJECT_BINARY_DIR}/configure.h

)

# We want a define that's set to all the options for the C code,

# and a var set to all the options for genapi.pl.

# Something like cpp -dN but we need it on Windows and want only defines.

# Strategy: add -D<define> token after each #define, and then run

# cpp => left with just the -D<define> that are defined.

# If we append this to configure.h we'll trigger recompilation of

# everything, so we generate a separate header file.

file(READ ${PROJECT_BINARY_DIR}/configure.h configure_h)

string(REGEX REPLACE

"(# *define *)([^_][^ \r\n]+)( *\r?\n)"

"\\1\\2\\3-D\\2\n" configure_h_mod "${configure_h}")

set(defines_tmpfile ${PROJECT_BINARY_DIR}/configure_temp.h)

# we do NOT add ${defines_tmpfile} to set_directory_properties

# ADDITIONAL_MAKE_CLEAN_FILES b/c it's built at configure time:

# would be part of "make distclean" but cmake does not have that.

file(WRITE ${defines_tmpfile} "${configure_h_mod}")

# No way to get cmdline defines from cmake: but shouldn't be any, all

# in configure.h, except the -Ddynamorio_EXPORTS that cmake defines.

# Note: cpp w/ no 2nd filename prints to stdout (explicit "-" => pause at end)

execute_process(COMMAND

${CMAKE_CPP} ${CMAKE_CPP_FLAGS} -E ${CPP_NO_LINENUM} ${defines_tmpfile}

RESULT_VARIABLE cpp_result

ERROR_VARIABLE cpp_err

OUTPUT_VARIABLE cpp_out

)

if (WIN32)