CMakeLists.txt

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