CMakeLists.txt

   1 cmake_minimum_required(VERSION 3.4)
   2
   3 if (POLICY CMP0072)
   4         cmake_policy (SET CMP0072 OLD)
   5 endif()
   6
   7 project (piglit)
   8
   9 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
  10
  11 INCLUDE (GNUInstallDirs)
  12 INCLUDE (CheckCCompilerFlag)
  13 INCLUDE (CheckCSourceCompiles)
  14 INCLUDE (CheckCXXCompilerFlag)
  15 INCLUDE (CheckFunctionExists)
  16 INCLUDE (CheckSymbolExists)
  17 INCLUDE (CheckIncludeFile)
  18 INCLUDE (FindPkgConfig)
  19
  20 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
  21
  22 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
  23         set(DEFAULT_EGL ON)
  24         set(DEFAULT_GLX ON)
  25         set(DEFAULT_WGL OFF)
  26         set(DEFAULT_WAFFLE ON)
  27         set(DEFAULT_X11 ON)
  28
  29         set(DEFAULT_GLES_TESTS_BUILD ON)
  30         set(DEFAULT_VK_TESTS_BUILD ON)
  31 elseif(APPLE)
  32         set(DEFAULT_EGL OFF)
  33         set(DEFAULT_GLX OFF)
  34         set(DEFAULT_WGL OFF)
  35         set(DEFAULT_WAFFLE OFF)
  36         set(DEFAULT_X11 OFF)
  37
  38         set(DEFAULT_GLES_TESTS_BUILD OFF)
  39         set(DEFAULT_VK_TESTS_BUILD OFF)
  40 elseif(WIN32)
  41         set(DEFAULT_EGL OFF)
  42         set(DEFAULT_GLX OFF)
  43         set(DEFAULT_WGL ON)
  44         set(DEFAULT_WAFFLE OFF)
  45         set(DEFAULT_X11 OFF)
  46
  47         set(DEFAULT_GLES_TESTS_BUILD OFF)
  48         set(DEFAULT_VK_TESTS_BUILD OFF)
  49 else()
  50         message(FATAL_ERROR "Unsupported platform")
  51 endif()
  52
  53 option(PIGLIT_SSE2 "Build with SSE2 support on 32-bit x86 architecture" ON)
  54
  55 option(PIGLIT_USE_WAFFLE "Use Waffle in place of GLUT" ${DEFAULT_WAFFLE})
  56
  57 option(PIGLIT_USE_X11 "Use X11" ${DEFAULT_X11})
  58
  59 option(PIGLIT_BUILD_GLX_TESTS "Build tests that require GLX" ${DEFAULT_GLX})
  60 option(PIGLIT_BUILD_WGL_TESTS "Build tests that require WGL" ${DEFAULT_WGL})
  61
  62 option(PIGLIT_BUILD_GL_TESTS "Build tests for OpenGL" ON)
  63 option(PIGLIT_BUILD_GLES1_TESTS "Build tests for OpenGL ES1" ${DEFAULT_GLES_TESTS_BUILD})
  64 option(PIGLIT_BUILD_GLES2_TESTS "Build tests for OpenGL ES2" ${DEFAULT_GLES_TESTS_BUILD})
  65 option(PIGLIT_BUILD_GLES3_TESTS "Build tests for OpenGL ES3" ${DEFAULT_GLES_TESTS_BUILD})
  66 option(PIGLIT_BUILD_CL_TESTS "Build tests for OpenCL" OFF)
  67 option(PIGLIT_BUILD_VK_TESTS "Build tests for Vulkan" ${DEFAULT_VK_TESTS_BUILD})
  68
  69 find_package(Threads)
  70 find_package(PNG)
  71 if(PNG_FOUND)
  72         add_definitions(-DPIGLIT_HAS_PNG)
  73 endif(PNG_FOUND)
  74
  75 if(PIGLIT_BUILD_GLX_TESTS AND NOT PIGLIT_USE_X11)
  76         message(FATAL_ERROR "X11 has to be enabled for GLX to build")
  77 endif()
  78
  79 if(PIGLIT_USE_X11)
  80         find_package(X11 REQUIRED)
  81         set(PIGLIT_HAS_X11 True)
  82         add_definitions(-DPIGLIT_HAS_X11)
  83 endif()
  84
  85 if(PIGLIT_BUILD_GL_TESTS)
  86         find_package(OpenGL REQUIRED)
  87 endif()
  88
  89 if(PIGLIT_USE_WAFFLE)
  90         if (NOT WIN32)
  91                 pkg_check_modules(Waffle REQUIRED waffle-1)
  92
  93                 if(NOT Waffle_FOUND)
  94                         message(FATAL_ERROR "Failed to find Waffle. If Waffle "
  95                         "is not packaged for your distribution, you can get "
  96                         "it at https://gitlab.freedesktop.org/mesa/waffle."
  97                 )
  98                 endif()
  99
 100                 # Check the installed waffle version.
 101                 #
 102                 # We cannot reliably check the version with pkg_check_modules(), but
 103                 # instead must check the version manually as below. The problem is that,
 104                 # if one passes a required version to pkg_check_modules(), CMake
 105                 # validates the required version at most once for the lifetime of the
 106                 # source tree.  If someone changes the required version by editing the
 107                 # CMakeLists, CMake fails to detect the new requirement.
 108                 set(Waffle_REQUIRED_VERSION "1.6.0")
 109                 if(Waffle_VERSION VERSION_LESS Waffle_REQUIRED_VERSION)
 110                         message(FATAL_ERROR "Found waffle-${Waffle_VERSION}, but "
 111                         "piglit requires waffle-${Waffle_REQUIRED_VERSION}")
 112                 endif()
 113         else ()
 114                 find_path(Waffle_INCLUDE_DIRS waffle.h)
 115                 find_library(Waffle_LDFLAGS waffle-1)
 116                 if(Waffle_INCLUDE_DIRS AND Waffle_LDFLAGS)
 117                         set(Waffle_FOUND TRUE)
 118                 else()
 119                         message(FATAL_ERROR "Failed to find Waffle. Get and build Waffle from "
 120                                 "https://gitlab.freedesktop.org/mesa/waffle and set "
 121                                 "Waffle_INCLUDE_DIRS and Waffle_LDFLAGS variables accordingly."
 122                         )
 123                 endif()
 124         endif ()
 125
 126         add_definitions(-DPIGLIT_USE_WAFFLE)
 127         add_definitions(-DWAFFLE_API_VERSION=0x0103)
 128 else()
 129         find_package(GLUT REQUIRED)
 130
 131         # The 'REQUIRED' above correctly produces an error for
 132         # OpenGL, but there's a bug involving FindGLUT.cmake
 133         # that fails to produce the error as of CMake 2.8.5.
 134         #
 135         # Instead, CMake keeps going and eventually spams
 136         # the console with a message for every target that used
 137         # e.g. the ${GLUT_INCLUDE_DIR} variable. So it
 138         # prints a line for basically every single test in piglit.
 139         #
 140         # Work around the bug and error out quickly here instead.
 141         if (NOT GLUT_FOUND)
 142                 message(FATAL_ERROR "GLUT library not found")
 143         endif()
 144 endif(PIGLIT_USE_WAFFLE)
 145
 146 if(PIGLIT_BUILD_GLES1_TESTS AND NOT PIGLIT_USE_WAFFLE)
 147         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES1_TESTS requires PIGLIT_USE_WAFFLE")
 148 endif(PIGLIT_BUILD_GLES1_TESTS AND NOT PIGLIT_USE_WAFFLE)
 149
 150 if(PIGLIT_BUILD_GLES2_TESTS AND NOT PIGLIT_USE_WAFFLE)
 151         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES2_TESTS requires PIGLIT_USE_WAFFLE")
 152 endif(PIGLIT_BUILD_GLES2_TESTS AND NOT PIGLIT_USE_WAFFLE)
 153
 154 if(PIGLIT_BUILD_GLES3_TESTS AND NOT PIGLIT_USE_WAFFLE)
 155         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES3_TESTS requires PIGLIT_USE_WAFFLE")
 156 endif(PIGLIT_BUILD_GLES3_TESTS AND NOT PIGLIT_USE_WAFFLE)
 157
 158 if(PIGLIT_BUILD_CL_TESTS)
 159         find_package(OpenCL 1.2 REQUIRED)
 160 endif(PIGLIT_BUILD_CL_TESTS)
 161
 162 if(PIGLIT_USE_X11 AND OPENGL_gl_LIBRARY AND PIGLIT_BUILD_GLX_TESTS)
 163         set(PIGLIT_HAS_GLX True)
 164         add_definitions(-DPIGLIT_HAS_GLX)
 165 endif()
 166
 167 IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 168         pkg_check_modules(GBM QUIET gbm>=17.1)
 169         if(GBM_FOUND)
 170                 set(PIGLIT_HAS_GBM True)
 171                 add_definitions(-DPIGLIT_HAS_GBM)
 172                 set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${GBM_LIBRARIES})
 173                 CHECK_FUNCTION_EXISTS(gbm_bo_map PIGLIT_HAS_GBM_BO_MAP)
 174                 if (PIGLIT_HAS_GBM_BO_MAP)
 175                         add_definitions(-DPIGLIT_HAS_GBM_BO_MAP)
 176                 endif()
 177                 CHECK_FUNCTION_EXISTS(gbm_bo_get_fd_for_plane PIGLIT_HAS_GBM_BO_GET_FD_FOR_PLANE)
 178                 if (PIGLIT_HAS_GBM_BO_GET_FD_FOR_PLANE)
 179                         add_definitions(-DPIGLIT_HAS_GBM_BO_GET_FD_FOR_PLANE)
 180                 endif()
 181         endif(GBM_FOUND)
 182
 183         pkg_check_modules(WAYLAND QUIET wayland-client)
 184         if (WAYLAND_FOUND)
 185                 set(PIGLIT_HAS_WAYLAND True)
 186                 add_definitions(-DPIGLIT_HAS_WAYLAND)
 187                 include_directories(${WAYLAND_INCLUDE_DIRS})
 188
 189                 FIND_LIBRARY(HAVE_XKBCOMMON NAMES xkbcommon)
 190                 if(NOT HAVE_XKBCOMMON)
 191                         message(FATAL_ERROR "Wayland support requires xkbcommon. "
 192                                 "Failed to find xkbcommon library.")
 193                 endif()
 194                 pkg_check_modules(XKBCOMMON QUIET xkbcommon)
 195         endif()
 196
 197         pkg_check_modules(LIBDRM QUIET libdrm)
 198         pkg_check_modules(XCB QUIET xcb)
 199         pkg_check_modules(XCB_DRI2 QUIET xcb-dri2)
 200         pkg_check_modules(GLPROTO QUIET glproto)
 201         pkg_check_modules(LIBVULKAN QUIET vulkan)
 202 ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 203         if (PIGLIT_USE_WAFFLE)
 204                 set(PIGLIT_HAS_WGL True)
 205                 add_definitions(-DPIGLIT_HAS_WGL)
 206         endif()
 207 ENDIF()
 208
 209 if(PIGLIT_BUILD_VK_TESTS)
 210         if (NOT LIBVULKAN_FOUND)
 211                 message(FATAL_ERROR "libvulkan required by vulkan tests not found")
 212         endif()
 213
 214         find_program(GLSLANG_VALIDATOR NAMES glslangValidator)
 215
 216         if (NOT GLSLANG_VALIDATOR)
 217                 message(FATAL_ERROR "glslangValidator required by vulkan tests not found")
 218         endif()
 219 endif(PIGLIT_BUILD_VK_TESTS)
 220
 221 # Choose to build tests that use dma_buf.
 222 #
 223 # Piglit's dma_buf utilities require xcb-dri2 to gain DRM authentication, and
 224 # gbm_bo_map() to be available for generating dma_bufs, and libdrm for fourcc
 225 # definitions.
 226 #
 227 if(LIBDRM_FOUND AND LIBDRM_VERSION VERSION_GREATER "2.4.97" AND XCB_DRI2_FOUND AND PIGLIT_HAS_GBM_BO_MAP)
 228         set(PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID true)
 229 else()
 230         set(PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID false)
 231 endif()
 232
 233 if(PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID)
 234         option(PIGLIT_BUILD_DMA_BUF_TESTS "Build tests that use dma_buf" ON)
 235 else()
 236         option(PIGLIT_BUILD_DMA_BUF_TESTS "Build tests that use dma_buf" OFF)
 237 endif()
 238
 239 # If the users has updated PIGLIT_BUILD_DMA_BUF_TESTS in the CMakeCache, then
 240 # we need to validate it.
 241 if(PIGLIT_BUILD_DMA_BUF_TESTS AND NOT PIGLIT_BUILD_DMA_BUF_TESTS_IS_VALID)
 242         message(FATAL_ERROR
 243                 "PIGLIT_BUILD_DMA_BUF_TESTS require libdrm, "
 244                 "gbm_bo_map(), libdrm>=2.4.98 and xcb-dri2")
 245 endif()
 246
 247 IF(PIGLIT_BUILD_GLX_TESTS)
 248         pkg_check_modules(GLPROTO REQUIRED glproto)
 249 ENDIF()
 250
 251 if (NOT Python_ADDITIONAL_VERSIONS)
 252         set(Python_ADDITIONAL_VERSIONS 3.12 3.11 3.10 3.9 3.8 3.7 3.6)
 253 endif()
 254 find_package(PythonInterp REQUIRED)
 255 find_package(PythonNumpy 1.7.0 REQUIRED)
 256 find_package(PythonMako 1.0.2 REQUIRED)
 257
 258 pkg_search_module(BASH_COMPLETION bash-completion)
 259
 260 # Default to compiling with debug information (`gcc -g`):
 261 if(NOT CMAKE_BUILD_TYPE)
 262         SET(CMAKE_BUILD_TYPE Debug CACHE STRING
 263         "May be one of: None Debug RelWithDebInfo Release MinSizeRel" FORCE)
 264 endif(NOT CMAKE_BUILD_TYPE)
 265
 266 if (NOT MSVC)
 267         if (PIGLIT_SSE2 AND CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)")
 268                 # enables SSE2 and precision used on x86-64 by default
 269                 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse2 -mfpmath=sse")
 270                 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse2 -mfpmath=sse")
 271         else()
 272                 # degrade performance a bit, but enforce required precision
 273                 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ffloat-store")
 274                 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffloat-store")
 275         endif()
 276         CHECK_C_COMPILER_FLAG("-Wall" C_COMPILER_FLAG_WALL)
 277         IF (C_COMPILER_FLAG_WALL)
 278                 SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
 279         ENDIF (C_COMPILER_FLAG_WALL)
 280         CHECK_CXX_COMPILER_FLAG("-Wall" CXX_COMPILER_FLAG_WALL)
 281         IF (CXX_COMPILER_FLAG_WALL)
 282                 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 283         ENDIF (CXX_COMPILER_FLAG_WALL)
 284
 285         # Target C99.  GCC's default is gnu11 for 5.0 and newer, gnu89 for
 286         # older versions.
 287         check_c_compiler_flag ("-std=gnu99" C_COMPILER_FLAG_STD_GNU99)
 288         if (C_COMPILER_FLAG_STD_GNU99)
 289                 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99")
 290         endif ()
 291         # MSVC does not support C99 variable length arrays
 292         CHECK_C_COMPILER_FLAG("-Werror=vla" C_COMPILER_FLAG_WEVLA)
 293         IF (C_COMPILER_FLAG_WEVLA)
 294                 SET (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=vla")
 295         ENDIF ()
 296         # GCC allows void pointer arithmetic, but it is not part of ISO C and
 297         # in particular MSVC will throw `C2036: 'void *' : unknown size`
 298         check_c_compiler_flag ("-Werror=pointer-arith" C_COMPILER_FLAG_WEPOINTER_ARITH)
 299         if (C_COMPILER_FLAG_WEPOINTER_ARITH)
 300                 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=pointer-arith")
 301         endif ()
 302         # MSVC only supports C99 variadic macros.  It doesn't support the
 303         # non-standard GNU named variadic macro syntax that's documented in
 304         # https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html
 305         #
 306         # XXX: on older GCC version this option has no effect unless -Wpedantic
 307         # is set, but this should be fixed on future GCC versions, per
 308         # https://gcc.gnu.org/ml/gcc-patches/2014-04/msg01459.html
 309         check_c_compiler_flag ("-Werror=variadic-macros" C_COMPILER_FLAG_WVARIADIC_MACROS)
 310         if (C_COMPILER_FLAG_WVARIADIC_MACROS)
 311                 set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror=variadic-macros")
 312         endif ()
 313
 314         CHECK_CXX_COMPILER_FLAG("-Wno-narrowing" CXX_COMPILER_FLAG_WNO_NARROWING)
 315         IF (CXX_COMPILER_FLAG_WNO_NARROWING)
 316                 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-narrowing")
 317         ENDIF (CXX_COMPILER_FLAG_WNO_NARROWING)
 318 else ()
 319         # Adjust warnings
 320         add_definitions (-W3)
 321         add_definitions (-wd4018) # signed/unsigned mismatch
 322         add_definitions (-wd4244) # conversion from 'type1' to 'type2', possible loss of data
 323         add_definitions (-wd4305) # truncation from 'type1' to 'type2'
 324         add_definitions (-wd4800) # forcing value to bool 'true' or 'false' (performance warning)
 325
 326         add_definitions (-D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_CRT_NONSTDC_NO_WARNINGS)
 327         add_definitions (-D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS)
 328 endif ()
 329
 330 if (MINGW)
 331         # Match MSVC default stack size
 332         set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--stack,1048576")
 333 endif ()
 334
 335 if (${CMAKE_C_COMPILER_ID} STREQUAL "SunPro")
 336         # Use C++ to link C files.
 337         # http://developers.sun.com/solaris/articles/mixing.html#linking
 338         # Modified rule from Modules/CMakeCInformation.cmake.
 339         set (CMAKE_C_LINK_EXECUTABLE
 340                 "<CMAKE_CXX_COMPILER> <FLAGS> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
 341 endif()
 342
 343 # Always enable GNU C extensions.  Non-GNU platforms will need to
 344 # define wrappers for them.
 345 add_definitions(-D_GNU_SOURCE)
 346
 347 if (WIN32)
 348         # MSVC & MinGW only define & use APIENTRY
 349         add_definitions (-DGLAPIENTRY=__stdcall)
 350
 351         # Avoid namespace pollution when including windows.h
 352         # http://support.microsoft.com/kb/166474
 353         add_definitions (-DWIN32_LEAN_AND_MEAN=1)
 354
 355         # Don't define min/max macros
 356         add_definitions (-DNOMINMAX)
 357
 358         # Even more no min/max macros
 359         add_definitions (-D_CRT_DECLARE_NONSTDC_NAMES=0)
 360
 361         # Define M_PI and others
 362         add_definitions (-D_USE_MATH_DEFINES)
 363 endif (WIN32)
 364
 365 if (APPLE)
 366         # Don't warn about using deprecated OpenGL/GLUT functions.
 367         # TODO: It would be nice to silence just the deprecation macros from
 368         # OpenGLAvailability.h as opposed to all deprecated functions.
 369         set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
 370         set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
 371 endif ()
 372
 373 if (OPENGL_FOUND)
 374         if (APPLE)
 375                 find_path(GLEXT_INCLUDE_DIR
 376                         NAMES OpenGL/glext.h
 377                         PATHS ${OPENGL_INCLUDE_DIR}
 378                         DOC "Include for OpenGL/glext.h on OSX"
 379                 )
 380         else (APPLE)
 381                 find_path(GLEXT_INCLUDE_DIR
 382                         NAMES GL/glext.h
 383                         PATHS ${OPENGL_INCLUDE_DIR}
 384                         DOC "Include for GL/glext.h"
 385                 )
 386         endif (APPLE)
 387 endif()
 388
 389 if(CMAKE_USE_PTHREADS_INIT)
 390         set(PIGLIT_HAS_PTHREADS true)
 391         add_definitions(-DPIGLIT_HAS_PTHREADS)
 392 endif()
 393
 394 FIND_LIBRARY(HAVE_LIBRT NAMES rt)
 395 if(HAVE_LIBRT)
 396         set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} rt)
 397 endif()
 398
 399 check_c_source_compiles(
 400         "
 401         #define _POSIX_C_SOURCE 199309L
 402         #include <time.h>
 403         int main() { return clock_gettime(CLOCK_MONOTONIC, NULL); }
 404         "
 405         PIGLIT_HAS_POSIX_CLOCK_MONOTONIC
 406 )
 407
 408 if(PIGLIT_HAS_PTHREADS AND PIGLIT_HAS_POSIX_CLOCK_MONOTONIC)
 409         check_c_source_compiles(
 410                 "
 411                 #include <signal.h>
 412                 #include <time.h>
 413                 static void timeout(union sigval val) { }
 414                 int main() {
 415                         struct sigevent sev = {
 416                                 .sigev_notify = SIGEV_THREAD,
 417                                 .sigev_notify_function = timeout,
 418                         };
 419                         timer_t timerid;
 420                         return timer_create(CLOCK_MONOTONIC, &sev, &timerid);
 421                 }
 422                 "
 423                 PIGLIT_HAS_POSIX_TIMER_NOTIFY_THREAD
 424         )
 425 endif()
 426
 427 set(CMAKE_REQUIRED_LIBRARIES)
 428
 429 if(PIGLIT_HAS_POSIX_CLOCK_MONOTONIC)
 430         add_definitions(-DPIGLIT_HAS_POSIX_CLOCK_MONOTONIC)
 431 endif()
 432
 433 if(PIGLIT_HAS_POSIX_TIMER_NOTIFY_THREAD)
 434         add_definitions(-DPIGLIT_HAS_POSIX_TIMER_NOTIFY_THREAD)
 435 endif()
 436
 437 if(GBM_FOUND)
 438         FIND_LIBRARY(HAVE_LIBCACA NAMES caca)
 439         if(HAVE_LIBCACA)
 440                 set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} caca)
 441                 add_definitions(-DPIGLIT_HAS_LIBCACA)
 442         endif(HAVE_LIBCACA)
 443 endif(GBM_FOUND)
 444
 445 if(PIGLIT_USE_WAFFLE AND ${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
 446         pkg_check_modules(EGL egl)
 447 endif()
 448
 449 if(EGL_FOUND)
 450         set(PIGLIT_HAS_EGL True)
 451         add_definitions(-DPIGLIT_HAS_EGL)
 452         include_directories(${EGL_INCLUDE_DIRS})
 453         add_definitions (${EGL_CFLAGS_OTHER})
 454 endif()
 455
 456 if(PIGLIT_BUILD_GLES1_TESTS AND NOT EGL_FOUND)
 457         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES1_TESTS requires EGL. "
 458                             "Failed to find EGL library.")
 459 endif()
 460
 461 if(PIGLIT_BUILD_GLES2_TESTS AND NOT EGL_FOUND)
 462         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES2_TESTS requires EGL. "
 463                             "Failed to find EGL library.")
 464 endif()
 465
 466 if(PIGLIT_BUILD_GLES3_TESTS AND NOT EGL_FOUND)
 467         message(FATAL_ERROR "Option PIGLIT_BUILD_GLES3_TESTS requires EGL. "
 468                             "Failed to find EGL library.")
 469 endif()
 470
 471 # Put all executables into the bin subdirectory
 472 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${piglit_BINARY_DIR}/bin)
 473 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${piglit_BINARY_DIR}/lib)
 474
 475 # Do the same for MSVC, regardless of the build type. This only works correctly
 476 # for CMake 2.8.1 and above.
 477 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${piglit_BINARY_DIR}/bin)
 478 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${piglit_BINARY_DIR}/bin)
 479 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_MINSIZEREL ${piglit_BINARY_DIR}/bin)
 480 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO ${piglit_BINARY_DIR}/bin)
 481
 482 check_function_exists(asprintf  HAVE_ASPRINTF)
 483 check_function_exists(ffs       HAVE_FFS)
 484 check_function_exists(strchrnul HAVE_STRCHRNUL)
 485 check_function_exists(strndup   HAVE_STRNDUP)
 486 if(NOT MINGW)
 487         check_function_exists(fopen_s   HAVE_FOPEN_S)
 488 endif()
 489 check_function_exists(setrlimit HAVE_SETRLIMIT)
 490
 491 check_symbol_exists(htobe32 "endian.h" HAVE_HTOBE32)
 492 check_symbol_exists(htole16 "endian.h" HAVE_HTOLE16)
 493 check_symbol_exists(htole32 "endian.h" HAVE_HTOLE32)
 494 check_symbol_exists(htole64 "endian.h" HAVE_HTOLE64)
 495
 496 check_include_file(sys/time.h  HAVE_SYS_TIME_H)
 497 check_include_file(sys/types.h HAVE_SYS_TYPES_H)
 498 check_include_file(sys/resource.h  HAVE_SYS_RESOURCE_H)
 499 check_include_file(sys/stat.h  HAVE_SYS_STAT_H)
 500 check_include_file(unistd.h    HAVE_UNISTD_H)
 501 check_include_file(fcntl.h     HAVE_FCNTL_H)
 502 check_include_file(linux/sync_file.h HAVE_LINUX_SYNC_FILE_H)
 503 check_include_file(endian.h    HAVE_ENDIAN_H)
 504 check_include_file(libgen.h    HAVE_LIBGEN_H)
 505
 506 if(DEFINED PIGLIT_INSTALL_VERSION)
 507         set(PIGLIT_INSTALL_VERSION_SUFFIX
 508             "-${PIGLIT_INSTALL_VERSION}")
 509 else()
 510         set(PIGLIT_INSTALL_VERSION_SUFFIX "")
 511 endif()
 512 set(PIGLIT_INSTALL_LIBDIR
 513     "${CMAKE_INSTALL_LIBDIR}/piglit${PIGLIT_INSTALL_VERSION_SUFFIX}")
 514 if(NOT IS_ABSOLUTE ${PIGLIT_INSTALL_LIBDIR})
 515         set(PIGLIT_INSTALL_FULL_LIBDIR "${CMAKE_INSTALL_PREFIX}/${PIGLIT_INSTALL_LIBDIR}")
 516 else()
 517         set(PIGLIT_INSTALL_FULL_LIBDIR "${PIGLIT_INSTALL_LIBDIR}")
 518 endif()
 519
 520 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 521         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--enable-new-dtags")
 522 endif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
 523
 524 SET(CMAKE_INSTALL_RPATH "${PIGLIT_INSTALL_FULL_LIBDIR}/lib")
 525
 526 configure_file(
 527         "${piglit_SOURCE_DIR}/tests/util/config.h.in"
 528         "${piglit_BINARY_DIR}/tests/util/config.h"
 529 )
 530
 531 include(cmake/piglit_util.cmake)
 532 include(cmake/piglit_dispatch.cmake)
 533
 534 include_directories(src)
 535 add_subdirectory(cmake/target_api)
 536 add_subdirectory(generated_tests)
 537 add_subdirectory(replayer)
 538
 539
 540 ##############################################################################
 541 # Packaging
 542
 543 install (
 544         FILES
 545                 COPYING
 546                 README.md
 547                 RELEASE
 548         DESTINATION share/doc/piglit${PIGLIT_INSTALL_VERSION_SUFFIX}
 549 )
 550
 551 install (
 552         DIRECTORY framework
 553         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 554         FILES_MATCHING PATTERN "*.py"
 555 )
 556
 557 install (
 558         DIRECTORY templates
 559         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 560 )
 561
 562 install (
 563         DIRECTORY tests
 564         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 565         FILES_MATCHING REGEX ".*\\.(xml|xml.gz|py|program_test|shader_test|shader_source|frag|vert|geom|tesc|tese|comp|spv|ktx|cl|txt|inc|vk_shader_test)$"
 566         REGEX "CMakeFiles|CMakeLists|serializer.py|opengl.py|cl.py|quick_gl.py|glslparser.py|shader.py|quick_shader.py|no_error.py|llvmpipe_gl.py|sanity.py" EXCLUDE
 567 )
 568
 569 install (
 570         DIRECTORY ${CMAKE_BINARY_DIR}/tests
 571         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 572         FILES_MATCHING REGEX ".*\\.xml.gz"
 573 )
 574
 575 install (
 576         DIRECTORY ${CMAKE_BINARY_DIR}/generated_tests
 577         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 578         FILES_MATCHING REGEX ".*\\.(shader_test|program_test|frag|vert|geom|tesc|tese|comp|cl|txt|vk_shader_test)$"
 579         REGEX "CMakeFiles|CMakeLists" EXCLUDE
 580 )
 581
 582 install (
 583         DIRECTORY generated_tests
 584         DESTINATION ${PIGLIT_INSTALL_LIBDIR}
 585         FILES_MATCHING REGEX ".*\\.inc$"
 586         REGEX "CMakeFiles|CMakeLists" EXCLUDE
 587 )
 588
 589 if (BASH_COMPLETION_FOUND)
 590         pkg_get_variable(BASH_COMPLETION_COMPLETIONSDIR bash-completion completionsdir)
 591
 592         if(NOT "${BASH_COMPLETION_PREFIX}" STREQUAL "${CMAKE_INSTALL_PREFIX}")
 593                 string(REGEX REPLACE "^${BASH_COMPLETION_PREFIX}" "${CMAKE_INSTALL_PREFIX}" COMP_DIR ${BASH_COMPLETION_COMPLETIONSDIR})
 594                 set(BASH_COMPLETION_COMPLETIONSDIR ${COMP_DIR})
 595                 unset(COMP_DIR)
 596         endif()
 597
 598         install(
 599                 FILES completions/bash/piglit
 600                 DESTINATION ${BASH_COMPLETION_COMPLETIONSDIR}
 601         )
 602 endif (BASH_COMPLETION_FOUND)
 603
 604 if (WIN32)
 605         set (PYTHON_SUFFIX ".py")
 606 else ()
 607         set (PYTHON_SUFFIX "")
 608 endif ()
 609 install (
 610         PROGRAMS piglit RENAME piglit${PIGLIT_INSTALL_VERSION_SUFFIX}${PYTHON_SUFFIX}
 611         DESTINATION ${CMAKE_INSTALL_BINDIR}
 612 )
 613
 614 # Install MinGW runtime DLLs
 615 if (MINGW)
 616         if (CMAKE_SIZEOF_VOID_P EQUAL 8)
 617                 set (LIBGCC_DLL_NAME libgcc_s_seh-1.dll)
 618         else ()
 619                 set (LIBGCC_DLL_NAME libgcc_s_sjlj-1.dll)
 620         endif ()
 621         execute_process (
 622                 COMMAND ${CMAKE_C_COMPILER} -print-file-name=${LIBGCC_DLL_NAME}
 623                 OUTPUT_STRIP_TRAILING_WHITESPACE
 624                 OUTPUT_VARIABLE LIBGCC_DLL
 625         )
 626         execute_process (
 627                 COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libstdc++-6.dll
 628                 OUTPUT_STRIP_TRAILING_WHITESPACE
 629                 OUTPUT_VARIABLE LIBSTDCXX_DLL
 630         )
 631         if (EXISTS ${LIBGCC_DLL})
 632                 message (STATUS "Found libgcc DLL: ${LIBGCC_DLL}")
 633                 install (FILES ${LIBGCC_DLL} DESTINATION ${PIGLIT_INSTALL_LIBDIR}/bin)
 634         endif ()
 635         if (EXISTS ${LIBSTDCXX_DLL})
 636                 message (STATUS "Found libstdc++ DLL: ${LIBSTDCXX_DLL}")
 637                 install (FILES ${LIBSTDCXX_DLL} DESTINATION ${PIGLIT_INSTALL_LIBDIR}/bin)
 638         endif ()
 639 endif ()
 640
 641 # Install Waffle DLL if specified
 642 if (WIN32 AND Waffle_DLL)
 643         install (FILES ${Waffle_DLL} DESTINATION ${PIGLIT_INSTALL_LIBDIR}/bin)
 644 endif ()
 645
 646
 647 set (CPACK_PACKAGE_VERSION_MAJOR "1")
 648 set (CPACK_PACKAGE_VERSION_MINOR "0")
 649
 650 # Use current date in YYYYMMDD format as patch number
 651 execute_process (
 652         COMMAND ${PYTHON_EXECUTABLE} -c "import time, sys; sys.stdout.write(time.strftime('%Y%m%d'))"
 653         OUTPUT_VARIABLE CPACK_PACKAGE_VERSION_PATCH
 654 )
 655
 656 # cpack mistakenly detects Mingw-w64 as win32
 657 if (MINGW)
 658         if (CMAKE_SIZEOF_VOID_P EQUAL 8)
 659                 set (CPACK_SYSTEM_NAME win64)
 660         endif ()
 661 endif ()
 662
 663 # See http://www.vtk.org/Wiki/CMake:CPackPackageGenerators
 664 if (WIN32)
 665         set (CPACK_GENERATOR "7Z")
 666         set (CPACK_STRIP_FILES ON)
 667 else ()
 668         set (CPACK_GENERATOR "TBZ2")
 669 endif ()
 670
 671 include(CPack)