git.cworth.org Git - vogl/blob - src/build_options.cmake

   1 #
   2 # cmake -DCMAKE_BUILD_TYPE=Debug ..
   3 #
   4 #   http://www.cmake.org/Wiki/CMake_FAQ
   5 #   http://www.cmake.org/Wiki/CMake_Useful_Variables
   6 #   http://clang.llvm.org/docs/LanguageExtensions.html
   7 #
   8 #   Address Sanitizer: http://clang.llvm.org/docs/AddressSanitizer.html
   9 #                      https://code.google.com/p/address-sanitizer/wiki/AddressSanitizer#Getting_AddressSanitizer
  10 #
  11 cmake_minimum_required(VERSION 2.8)
  12
  13 option(BUILD_X64 "build 64-bit" FALSE)
  14 option(CMAKE_VERBOSE "Verbose CMake" FALSE)
  15 if( CMAKE_VERBOSE )
  16     SET(CMAKE_VERBOSE_MAKEFILE ON)
  17 endif()
  18
  19 # http://clang.llvm.org/docs/AddressSanitizer.html
  20 # https://code.google.com/p/address-sanitizer/wiki/Flags#Turning_off_instrumentation
  21 # http://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=230762
  22 option(WITH_ASAN "Enable address sanitizer" OFF) # gcc4.8+, clang 3.1+
  23
  24 #option(WITH_MSAN "Enable memory sanitizer" OFF)
  25 #option(WITH_TSAN "Enable thread sanitizer" OFF)
  26 option(WITH_HARDENING "Enable hardening: Compile-time protection against static sized buffer overflows" OFF)
  27 option(CLANG_ANALYZE "Do clang analyze build" OFF)
  28 option(CLANG_EVERYTHING "Do clang build with -Weverything" OFF)
  29 option(USE_TELEMETRY "Build with Telemetry" OFF)
  30
  31 if( NOT BUILD_X64 )
  32   # If we're in our 64-bit chroot, default to 64-bit, else 32-bit
  33   if( "$ENV{SCHROOT_CHROOT_NAME}" MATCHES "(.*)amd64(.*)" )
  34     set(BUILD_X64 "TRUE")
  35   else()
  36     set(BUILD_X64 "FALSE")
  37   endif()
  38 endif( NOT BUILD_X64 )
  39
  40 # Generate bitness suffix to use
  41 if (BUILD_X64)
  42     set(CMAKE_EXECUTABLE_SUFFIX 64)
  43     set(CMAKE_SHARED_LIBRARY_SUFFIX "64.so")
  44 else()
  45     set(CMAKE_EXECUTABLE_SUFFIX 32)
  46     set(CMAKE_SHARED_LIBRARY_SUFFIX "32.so")
  47 endif()
  48
  49 # Default to release build
  50 if( NOT CMAKE_BUILD_TYPE )
  51     set( CMAKE_BUILD_TYPE Release )
  52 endif()
  53
  54 # Make sure we're using 64-bit versions of stat, fopen, etc.
  55 # Large File Support extensions:
  56 #   http://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html#Feature-Test-Macros
  57 add_definitions(-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGE_FILES)
  58
  59 # support for inttypes.h macros
  60 add_definitions(-D__STDC_LIMIT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_CONSTANT_MACROS)
  61
  62 set(CMAKE_CXX_FLAGS_LIST "-g -Wall -Wextra")
  63 set(CMAKE_CXX_FLAGS_RELEASE_LIST "-g -O2 -DNDEBUG")
  64 set(CMAKE_CXX_FLAGS_DEBUG_LIST "-g -O0 -D_DEBUG")
  65
  66 #if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
  67 #   if ( NOT BUILD_X64 )
  68 #      # Fix startup crash in dlopen_notify_callback (called indirectly from our dlopen() function) when tracing glxspheres on my AMD dev box (x86 release only)
  69 #      # Also fixes tracing Q3 Arena using release tracer
  70 #      add_definitions("-mstack-alignment=8")
  71 #   endif()
  72 #endif()
  73
  74 set(OPENGL_LIBRARY "GL")
  75
  76 if( USE_TELEMETRY )
  77   add_definitions("-DUSE_TELEMETRY")
  78 endif()
  79
  80 # clang doesn't print colored diagnostics when invoked from Ninja
  81 if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
  82   if (UNIX AND CMAKE_GENERATOR STREQUAL "Ninja")
  83       add_definitions ("-fcolor-diagnostics")
  84   endif()
  85 endif()
  86
  87 if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
  88   if (CLANG_EVERYTHING)
  89       set(CMAKE_CXX_FLAGS_LIST ${CMAKE_CXX_FLAGS_LIST}
  90           "-pedantic"               # Warn on language extensions
  91           "-fdiagnostics-show-name" # Enable display of diagnostic name
  92           "-Weverything"            # Enable all warnings
  93           "-Wno-unused-macros"
  94           "-Wno-padded"
  95           "-Wno-variadic-macros"
  96           )
  97   elseif ()
  98       set(CMAKE_CXX_FLAGS_LIST ${CMAKE_CXX_FLAGS_LIST}
  99           "--analyze"
 100           "-ferror-limit=0"         # Don't ever stop emitting diagnostics
 101           "-fshow-column"           # Print column number in diagnostic.
 102           "-fcaret-diagnostics"     # Print source line and ranges from source code in diagnostic
 103           "-pedantic"               # Warn on language extensions
 104           "-fdiagnostics-show-name" # Enable display of diagnostic name
 105           "-Weverything"            # Enable all warnings
 106           "-Wno-unused-macros"
 107           "-Wno-padded"
 108           "-Wno-variadic-macros"
 109           # "-Wno-missing-prototypes"
 110           )
 111   endif()
 112 endif()
 113
 114 if (NOT BUILD_X64)
 115     set(CMAKE_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS_LIST} -m32")
 116 endif()
 117
 118 function(add_compiler_flag flag)
 119     set(CMAKE_C_FLAGS    "${CMAKE_C_FLAGS}   ${flag}" PARENT_SCOPE)
 120     set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} ${flag}" PARENT_SCOPE)
 121 endfunction()
 122
 123 function(add_linker_flag flag)
 124     set(CMAKE_EXE_LINKER_FLAGS   "${CMAKE_EXE_LINKER_FLAGS} ${flag}" PARENT_SCOPE)
 125 endfunction()
 126
 127 function(add_shared_linker_flag flag)
 128     set(CMAKE_SHARED_LINKER_FLAGS   "${CMAKE_SHARED_LINKER_FLAGS} ${flag}" PARENT_SCOPE)
 129 endfunction()
 130
 131 #
 132 # To show the include files as you're building, do this:
 133 #    add_compiler_flag("-H")
 134 # For Visual Studio, it's /showIncludes I believe...
 135 #
 136
 137 # stack-protector-strong: http://gcc.gnu.org/ml/gcc-patches/2012-06/msg00974.html
 138 ## -fstack-protector-strong
 139 # Compile with the option "-fstack-usage" and a file .su will be generated with stack
 140 # information for each function.
 141 ## -fstack-usage
 142
 143 # For more info on -fno-strict-aliasing: "Just Say No to strict aliasing optimizations in C": http://nothings.org/
 144 # The Linux kernel is compiled with -fno-strict-aliasing: https://lkml.org/lkml/2003/2/26/158 or http://www.mail-archive.com/linux-btrfs@vger.kernel.org/msg01647.html
 145
 146 ### TODO: see if sse is generated with these instructions and clang:
 147 ## -march=corei7 -msse -mfpmath=sse
 148
 149 set(MARCH_STR "-march=corei7")
 150 if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
 151    if ( NOT BUILD_X64 )
 152       # Fix startup crash in dlopen_notify_callback (called indirectly from our dlopen() function) when tracing glxspheres on my AMD dev box (x86 release only)
 153       # Also fixes tracing Q3 Arena using release tracer
 154       # Clang is generating sse2 code even when it shouldn't be:
 155       #  http://lists.cs.uiuc.edu/pipermail/cfe-dev/2012-March/020310.html
 156       set(MARCH_STR "-march=i586")
 157    endif()
 158 endif()
 159
 160 set(CMAKE_CXX_FLAGS_LIST
 161     ${CMAKE_CXX_FLAGS_LIST}
 162     "-fno-omit-frame-pointer"
 163     ${MARCH_STR}
 164     # "-msse2 -mfpmath=sse" # To build with SSE instruction sets
 165     "-Wno-unused-parameter -Wno-unused-function"
 166     "-fno-strict-aliasing" # DO NOT remove this, we have lots of code that will fail in obscure ways otherwise because it was developed with MSVC first.
 167     "-fno-math-errno"
 168         "-fvisibility=hidden"
 169     # "-fno-exceptions" # Exceptions are enabled by default for c++ files, disabled for c files.
 170     )
 171
 172 if (CMAKE_COMPILER_IS_GNUCC)
 173     execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
 174     string(REGEX MATCHALL "[0-9]+" GCC_VERSION_COMPONENTS ${GCC_VERSION})
 175     list(GET GCC_VERSION_COMPONENTS 0 GCC_MAJOR)
 176     list(GET GCC_VERSION_COMPONENTS 1 GCC_MINOR)
 177     # message(STATUS "Detected GCC v ${GCC_MAJOR} . ${GCC_MINOR}")
 178 endif()
 179
 180 if (GCC_VERSION VERSION_GREATER 4.8 OR GCC_VERSION VERSION_EQUAL 4.8)
 181     set(CMAKE_CXX_FLAGS_LIST ${CMAKE_CXX_FLAGS_LIST}
 182         "-Wno-unused-local-typedefs"
 183     )
 184 endif()
 185
 186 if (WITH_HARDENING)
 187     # http://gcc.gnu.org/ml/gcc-patches/2004-09/msg02055.html
 188     add_definitions(-D_FORTIFY_SOURCE=2 -fpic)
 189     if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
 190         # During program load, several ELF memory sections need to be written to by the
 191         # linker, but can be turned read-only before turning over control to the
 192         # program. This prevents some GOT (and .dtors) overwrite attacks, but at least
 193         # the part of the GOT used by the dynamic linker (.got.plt) is still vulnerable.
 194         add_definitions(-pie -z now -z relro)
 195     endif()
 196 endif()
 197
 198 ## -fsanitize=address
 199 ## -fsanitize=address-full
 200 ## -fsanitize=integer
 201 ## -fsanitize=thread
 202 ## -fsanitize=undefined
 203 ## -fsanitize=memory
 204 ## -fsanitize-memory-track-origins
 205 if (WITH_ASAN)
 206     set(CMAKE_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS_LIST} -fsanitize=address" )
 207     set(CMAKE_EXE_LINK_FLAGS_LIST "${CMAKE_EXE_LINK_FLAGS_LIST} -fsanitize=address")
 208     set(CMAKE_SHARED_LINK_FLAGS_LIST "${CMAKE_SHARED_LINK_FLAGS_LIST} -fsanitize=address")
 209     link_libraries(asan)
 210 endif (WITH_ASAN)
 211
 212 #if (WITH_MSAN)
 213 #    set(CMAKE_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS_LIST} -fpic -fsanitize-memory-track-origins -fsanitize=memory" )
 214 #    set(SANITIZER_LIBRARY "-lmsan -ldl")
 215 #endif (WITH_MSAN)
 216 #message(STATUS "Msan is: ${WITH_MSAN} ${SANITIZER_LIBRARY}")
 217 #
 218 #if (WITH_TSAN)
 219 #    set(CMAKE_CXX_FLAGS_LIST "${CMAKE_CXX_FLAGS_LIST} -fpic -fsanitize=thread" )
 220 #    set(SANITIZER_LIBRARY "-ltsan -ldl")
 221 #endif (WITH_TSAN)
 222 #message(STATUS "Tsan is: ${WITH_TSAN} ${SANITIZER_LIBRARY}")
 223
 224 set(CMAKE_EXE_LINK_FLAGS_LIST
 225     "-Wl,--no-undefined"
 226     # "-lmcheck"
 227     )
 228 set(CMAKE_SHARED_LINK_FLAGS_LIST
 229     "-Wl,--no-undefined"
 230     )
 231
 232 # Compiler flags
 233 string(REPLACE ";" " " CMAKE_C_FLAGS              "${CMAKE_CXX_FLAGS_LIST}")
 234 string(REPLACE ";" " " CMAKE_C_FLAGS_RELEASE      "${CMAKE_CXX_FLAGS_RELEASE_LIST}")
 235 string(REPLACE ";" " " CMAKE_C_FLAGS_DEBUG        "${CMAKE_CXX_FLAGS_DEBUG_LIST}")
 236
 237 string(REPLACE ";" " " CMAKE_CXX_FLAGS            "${CMAKE_CXX_FLAGS_LIST}")
 238 string(REPLACE ";" " " CMAKE_CXX_FLAGS_RELEASE    "${CMAKE_CXX_FLAGS_RELEASE_LIST}")
 239 string(REPLACE ";" " " CMAKE_CXX_FLAGS_DEBUG      "${CMAKE_CXX_FLAGS_DEBUG_LIST}")
 240
 241 # Linker flags (exe)
 242 string(REPLACE ";" " " CMAKE_EXE_LINKER_FLAGS     "${CMAKE_EXE_LINK_FLAGS_LIST}")
 243 # Linker flags (shared)
 244 string(REPLACE ";" " " CMAKE_SHARED_LINKER_FLAGS  "${CMAKE_SHARED_LINK_FLAGS_LIST}")
 245
 246 set(RADPROJ_BUILD_DIR ${CMAKE_SOURCE_DIR}/../vogl_build)
 247 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${RADPROJ_BUILD_DIR}/bin)
 248 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${RADPROJ_BUILD_DIR}/bin)
 249
 250 # Telemetry setup
 251 function(telemetry_init)
 252   if( USE_TELEMETRY )
 253     include_directories("${SRC_DIR}/telemetry/include")
 254
 255     if( BUILD_X64 )
 256         find_library(RAD_TELEMETRY_LIBRARY libTelemetryX64.link.a HINTS ${SRC_DIR}/telemetry/lib)
 257         find_library(RAD_TELEMETRY_SO libTelemetryX64.so HINTS ${SRC_DIR}/telemetry/redist)
 258     else()
 259         find_library(RAD_TELEMETRY_LIBRARY libTelemetryX86.link.a HINTS ${SRC_DIR}/telemetry/lib)
 260         find_library(RAD_TELEMETRY_SO libTelemetryX86.so HINTS ${SRC_DIR}/telemetry/redist)
 261     endif()
 262   endif()
 263 endfunction()
 264
 265 if (USE_TELEMETRY)
 266   set(TELEMETRY_LIBRARY telemetry)
 267 else()
 268   set(TELEMETRY_LIBRARY )
 269 endif()
 270
 271 function(build_options_finalize)
 272     if( CMAKE_VERBOSE )
 273         message("  CMAKE_PROJECT_NAME: ${CMAKE_PROJECT_NAME}")
 274         message("  PROJECT_NAME: ${PROJECT_NAME}")
 275         message("  BUILD_X64: ${BUILD_X64}")
 276         message("  BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 277         message("  PROJECT_BINARY_DIR: ${PROJECT_BINARY_DIR}")
 278         message("  CMAKE_SOURCE_DIR: ${CMAKE_SOURCE_DIR}")
 279         message("  PROJECT_SOURCE_DIR: ${PROJECT_SOURCE_DIR}")
 280         message("  CMAKE_CURRENT_LIST_FILE: ${CMAKE_CURRENT_LIST_FILE}")
 281         message("  CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
 282         message("  CXX_FLAGS_RELEASE: ${CMAKE_CXX_FLAGS_RELEASE}")
 283         message("  CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}")
 284         message("  EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}")
 285         message("  SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}")
 286         message("  SHARED_LIBRARY_C_FLAGS: ${CMAKE_SHARED_LIBRARY_C_FLAGS}")
 287         message("  SHARED_LIBRARY_CXX_FLAGS: ${CMAKE_SHARED_LIBRARY_CXX_FLAGS}")
 288         message("  SHARED_LIBRARY_LINK_CXX_FLAGS: ${CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS}")
 289         message("  SHARED_LIBRARY_LINK_C_FLAGS: ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS}")
 290         message("  CMAKE_C_COMPILER: ${CMAKE_C_COMPILER}")
 291         message("  CMAKE_CXX_COMPILER: ${CMAKE_CXX_COMPILER}")
 292         message("  CMAKE_C_COMPILER_ID: ${CMAKE_C_COMPILER_ID}")
 293         message("  CMAKE_EXECUTABLE_SUFFIX: ${CMAKE_EXECUTABLE_SUFFIX}")
 294         message("")
 295     endif()
 296 endfunction()
 297