Skip to content

Commit

Permalink
Update xgl from commit 36e1c4ef
Browse files Browse the repository at this point in the history 
Update Khronos Vulkan Headers to 1.3.301
Update compliant CTS version to 1.3.9.2
Fix buffer overflow when the count of display modes exceeds MaxModePerScreen(64) (xgl issues #179)
Expose extension VK_EXT_swapchain_colorspace
Fix command buffer stack usage estimates
Add persistent waves to CPS path
Extend GFX11 app opts to Strix
Copy cbState struct as a whole
Add BG3 layer to modify a barrier
Disable dcc when the application transitions to the feedback loop image layout (AMDVLK Issue #375)
Fix NSA threshold for World War Z and Sniper Elite 5
Get WaveSize from GPURT compiler options
Remove unnecessary UpdateFrameTraceController call
Update RtFp16BoxNodes Values
Change VK_ASSERT_MSG to VK_ASSERT_ALWAYS_MSG
Set AllowVaryWaveSize for GPURT shaders
Remove VK_ALLOC_A macro
Fix nsaThreshold definitions in app_profile
Bail out on error when parsing shader profile
Enable the option OptimizePointSizeWrite
Fix CTS failures in dEQP-VK.pipeline.pipeline_library.graphics_library.misc.other.*
Disable descriptorBufferCaptureReplay
Disabling DCC for VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR
Update some settings' value
[RT] Fix the use of 'forceInvalidAccelStruct' setting
Fix usage of LayoutUncompressed for LAYOUT_RENDERING_LOCAL_READ
Fix coding standard issues in vk_defines
Expose more graphics and compute queues
Disable htile for external memory when creating image to work-around the corruption issue in interop with mesa GL
Initializing the fence count to 0 for every device index.
[DPRINTF] Fix debug printf crash
Fix sample shading is enabled for POPS incorrectly
Expose VK_KHR_compute_shader_derivatives
Fix menu list corruption in Blender 4.3.0 Beta
no rgp markers for rgd
Bump up GPURT version to 51
Enable GpuRt setting for persistent waves
Update PAL Version in XGL 909
VK_EXT_shader_replicated_composites - Driver Implementation
Fix "Unknown()" events appearing in RGP captures
Specify SRD stride for SrvTable and TypedSrvTables as 4
Fix memory leaks
Reset plane index according to the latest aspectMask to fix corruption in Blender 4.3.0 Beta: EEVEE render engine
Fix an assertion of incorrect primitive type
Remove m_stringTableId from devmode
Bugs fix for Proton Raytracing Games
Acq rel for CmdWaitEvents
Clean up macros and build options
  • Loading branch information
@qiaojbao
qiaojbao committed Dec 4, 2024
1 parent 786ec85 commit a367518
Show file tree
Hide file tree
Showing 79 changed files with 1,812 additions and 1,541 deletions.
108 changes: 54 additions & 54 deletions CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,8 +28,8 @@ cmake_policy(SET CMP0091 NEW)

# This part set before "project(XGL VERSION 1 LANGUAGES C CXX)".
# In a system has both gcc and clang compiler.
option(XGL_USE_CLANG "Build with clang?" OFF)
if(UNIX AND XGL_USE_CLANG)
option(VKI_USE_CLANG "Build with clang?" OFF)
if(UNIX AND VKI_USE_CLANG)
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
include(XglCompilerOptions)
xgl_use_clang_compiler()
Expand Down Expand Up @@ -108,75 +108,75 @@ xgl_set_compiler()

### Sanitizers ########################################################################################################
# Temporary variables
set(ICD_SANITIZER_LINK_FLAGS "")
set(ICD_SANITIZER_COMPILE_FLAGS "")
set(VKI_SANITIZER_LINK_FLAGS "")
set(VKI_SANITIZER_COMPILE_FLAGS "")

if(XGL_USE_SANITIZER)
if(VKI_USE_SANITIZER)
# -pthread is needed sometimes to fix a cmake bug: https://gitlab.kitware.com/cmake/cmake/issues/16609
string(APPEND ICD_SANITIZER_LINK_FLAGS " -pthread")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -pthread")
if(UNIX)
if(XGL_USE_SANITIZER MATCHES "Address")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -shared-libasan")
if(VKI_USE_SANITIZER MATCHES "Address")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -shared-libasan")
endif()

if(XGL_USE_SANITIZER STREQUAL "Address")
if(VKI_USE_SANITIZER STREQUAL "Address")
xgl_append_common_sanitizer_flags()
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize=address")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize=address")
elseif (XGL_USE_SANITIZER MATCHES "Memory(WithOrigins)?")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize=address")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize=address")
elseif (VKI_USE_SANITIZER MATCHES "Memory(WithOrigins)?")
xgl_append_common_sanitizer_flags()
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize=memory")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize=memory")
if(XGL_USE_SANITIZER STREQUAL "MemoryWithOrigins")
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize-memory-track-origins")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize-memory-track-origins")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize=memory")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize=memory")
if(VKI_USE_SANITIZER STREQUAL "MemoryWithOrigins")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize-memory-track-origins")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize-memory-track-origins")
endif()
elseif(XGL_USE_SANITIZER STREQUAL "Undefined")
elseif(VKI_USE_SANITIZER STREQUAL "Undefined")
xgl_append_common_sanitizer_flags()
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize=undefined -fno-sanitize=vptr,function \
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize=undefined -fno-sanitize=vptr,function \
-fno-sanitize-recover=all")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize=undefined")
elseif(XGL_USE_SANITIZER STREQUAL "Thread")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize=undefined")
elseif(VKI_USE_SANITIZER STREQUAL "Thread")
xgl_append_common_sanitizer_flags()
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize=thread")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize=thread")
elseif(XGL_USE_SANITIZER STREQUAL "Address;Undefined" OR
XGL_USE_SANITIZER STREQUAL "Undefined;Address")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize=thread")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize=thread")
elseif(VKI_USE_SANITIZER STREQUAL "Address;Undefined" OR
VKI_USE_SANITIZER STREQUAL "Undefined;Address")
xgl_append_common_sanitizer_flags()
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize=address,undefined -fno-sanitize=vptr,function \
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize=address,undefined -fno-sanitize=vptr,function \
-fno-sanitize-recover=all")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize=address,undefined")
elseif(XGL_USE_SANITIZER STREQUAL "Leaks")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize=address,undefined")
elseif(VKI_USE_SANITIZER STREQUAL "Leaks")
xgl_append_common_sanitizer_flags()
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize=leak")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize=leak")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize=leak")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize=leak")
else()
message(FATAL_ERROR "Unsupported value of XGL_USE_SANITIZER: ${XGL_USE_SANITIZER}")
message(FATAL_ERROR "Unsupported value of VKI_USE_SANITIZER: ${VKI_USE_SANITIZER}")
endif()
elseif(MSVC)
if(XGL_USE_SANITIZER STREQUAL "Address")
if(VKI_USE_SANITIZER STREQUAL "Address")
xgl_append_common_sanitizer_flags()
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize=address")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -fsanitize=address")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize=address")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -fsanitize=address")
else()
message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${XGL_USE_SANITIZER}")
message(FATAL_ERROR "This sanitizer not yet supported in the MSVC environment: ${VKI_USE_SANITIZER}")
endif()
else()
message(FATAL_ERROR "XGL_USE_SANITIZER is not supported on this platform.")
message(FATAL_ERROR "VKI_USE_SANITIZER is not supported on this platform.")
endif()

if(XGL_USE_SANITIZER MATCHES "(Undefined;)?Address(;Undefined)?")
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fsanitize-address-use-after-scope")
if(VKI_USE_SANITIZER MATCHES "(Undefined;)?Address(;Undefined)?")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fsanitize-address-use-after-scope")
endif()
endif()

string(APPEND CMAKE_EXE_LINKER_FLAGS "${ICD_SANITIZER_LINK_FLAGS}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS "${ICD_SANITIZER_LINK_FLAGS}")
string(APPEND CMAKE_C_FLAGS "${ICD_SANITIZER_COMPILE_FLAGS}")
string(APPEND CMAKE_CXX_FLAGS "${ICD_SANITIZER_COMPILE_FLAGS}")
string(APPEND CMAKE_EXE_LINKER_FLAGS "${VKI_SANITIZER_LINK_FLAGS}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS "${VKI_SANITIZER_LINK_FLAGS}")
string(APPEND CMAKE_C_FLAGS "${VKI_SANITIZER_COMPILE_FLAGS}")
string(APPEND CMAKE_CXX_FLAGS "${VKI_SANITIZER_COMPILE_FLAGS}")

# LLVM libc++
if(XGL_ENABLE_LIBCXX)
if(VKI_ENABLE_LIBCXX)
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
string(APPEND CMAKE_EXE_LINKER_FLAGS " -stdlib=libc++")
string(APPEND CMAKE_SHARED_LINKER_FLAGS " -stdlib=libc++")
Expand All @@ -189,24 +189,24 @@ endif()

### GCOV source code coverage #########################################################################################
# Temporary variables
set(ICD_GCOV_LINK_FLAGS "")
set(ICD_GCOV_COMPILE_FLAGS "")
set(VKI_GCOV_LINK_FLAGS "")
set(VKI_GCOV_COMPILE_FLAGS "")

if(XGL_ENABLE_GCOV)
if(VKI_ENABLE_GCOV)
if(UNIX)
message(STATUS "This gcov is supported on the UNIX environment: ${XGL_ENABLE_GCOV}")
message(STATUS "This gcov is supported on the UNIX environment: ${VKI_ENABLE_GCOV}")
xgl_append_gcov_coverage_flags()
elseif(MSVC)
message(FATAL_ERROR "This gcov not yet supported in the MSVC environment: ${XGL_ENABLE_GCOV}")
message(FATAL_ERROR "This gcov not yet supported in the MSVC environment: ${VKI_ENABLE_GCOV}")
else()
message(FATAL_ERROR "XGL_ENABLE_GCOV is not supported on this platform.")
message(FATAL_ERROR "VKI_ENABLE_GCOV is not supported on this platform.")
endif()
endif()

string(APPEND CMAKE_EXE_LINKER_FLAGS "${ICD_GCOV_LINK_FLAGS}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS "${ICD_GCOV_LINK_FLAGS}")
string(APPEND CMAKE_C_FLAGS "${ICD_GCOV_COMPILE_FLAGS}")
string(APPEND CMAKE_CXX_FLAGS "${ICD_GCOV_COMPILE_FLAGS}")
string(APPEND CMAKE_EXE_LINKER_FLAGS "${VKI_GCOV_LINK_FLAGS}")
string(APPEND CMAKE_SHARED_LINKER_FLAGS "${VKI_GCOV_LINK_FLAGS}")
string(APPEND CMAKE_C_FLAGS "${VKI_GCOV_COMPILE_FLAGS}")
string(APPEND CMAKE_CXX_FLAGS "${VKI_GCOV_COMPILE_FLAGS}")

### Generator Dependencies ############################################################################################
# Python3
Expand All @@ -228,7 +228,7 @@ endif()
set(PERL_CMD ${PERL_EXECUTABLE})

# Wayland required
if (BUILD_WAYLAND_SUPPORT)
if (VKI_BUILD_WAYLAND)
find_package(PkgConfig REQUIRED)
pkg_check_modules(WAYLAND REQUIRED wayland-client)
endif()
Expand Down
29 changes: 8 additions & 21 deletions cmake/XglCompileDefinitions.cmake
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,20 +30,13 @@ macro(xgl_set_compile_definitions)
target_compile_definitions(xgl PRIVATE ${TARGET_ARCHITECTURE_ENDIANESS}ENDIAN_CPU)

if(TARGET_ARCHITECTURE_BITS EQUAL 32)
target_compile_definitions(xgl PRIVATE ICD_X86_BUILD)
target_compile_definitions(xgl PRIVATE VKI_X86_BUILD)
elseif(TARGET_ARCHITECTURE_BITS EQUAL 64)
target_compile_definitions(xgl PRIVATE ICD_X64_BUILD)
target_compile_definitions(xgl PRIVATE VKI_X64_BUILD)
endif()

# Turn on the memory tracker if enabled.
if(ICD_MEMTRACK)
target_compile_definitions(xgl PRIVATE ICD_MEMTRACK)
endif()

# Enable relevant GPUOpen preprocessor definitions
if(ICD_GPUOPEN_DEVMODE_BUILD)
target_compile_definitions(xgl PRIVATE ICD_GPUOPEN_DEVMODE_BUILD)
endif()
target_compile_definitions(xgl PRIVATE $<$<BOOL:${VKI_MEMTRACK}>:VKI_MEMTRACK>)

if(ICD_BUILD_LLPC)
target_compile_definitions(xgl PRIVATE ICD_BUILD_LLPC)
Expand All @@ -68,13 +61,13 @@ macro(xgl_set_compile_definitions)
target_compile_definitions(xgl PRIVATE PAL_BUILD_GFX9=1)

#if VKI_BUILD_GFX115
if(XGL_BUILD_GFX115)
if(VKI_BUILD_GFX115)
target_compile_definitions(xgl PRIVATE VKI_BUILD_GFX115=1)
endif()
#endif

#if VKI_BUILD_STRIX1
if(XGL_BUILD_STRIX1)
if(VKI_BUILD_STRIX1)
target_compile_definitions(xgl PRIVATE VKI_BUILD_STRIX1=1)
endif()
#endif
Expand All @@ -87,17 +80,11 @@ macro(xgl_set_compile_definitions)
endif()
#endif

#if VKI_NORMALIZED_TRIG_FUNCTIONS
if(VKI_NORMALIZED_TRIG_FUNCTIONS)
target_compile_definitions(xgl PRIVATE VKI_NORMALIZED_TRIG_FUNCTIONS)
endif()
#endif

#if VKI_RAY_TRACING
#endif

if (XGL_ENABLE_GCOV)
target_compile_definitions(xgl PRIVATE ICD_ENABLE_GCOV)
if (VKI_ENABLE_GCOV)
target_compile_definitions(xgl PRIVATE VKI_ENABLE_GCOV)
endif()

#if VKI_GPU_DECOMPRESS
Expand All @@ -109,7 +96,7 @@ macro(xgl_set_compile_definitions)
#if VKI_RAY_TRACING
#endif

if(BUILD_WAYLAND_SUPPORT)
if(VKI_BUILD_WAYLAND)
target_compile_definitions(xgl PRIVATE VK_USE_PLATFORM_WAYLAND_KHR)
endif()

Expand Down
6 changes: 3 additions & 3 deletions cmake/XglCompilerOptions.cmake
View file
Original file line number Diff line number Diff line change
Expand Up @@ -156,7 +156,7 @@ macro(xgl_set_compiler)
endif()

# Assertions
if(XGL_ENABLE_ASSERTIONS)
if(VKI_ENABLE_ASSERTIONS)
# MSVC doesn't like _DEBUG on release builds.
if(NOT MSVC)
add_definitions(-D_DEBUG)
Expand Down Expand Up @@ -221,7 +221,7 @@ function(xgl_compiler_options TARGET)
-Wno-unused-parameter
)

if(ICD_ANALYSIS_WARNINGS_AS_ERRORS)
if(VKI_ANALYSIS_WARNINGS_AS_ERRORS)
target_compile_options(${TARGET} PRIVATE
-Werror
-Wno-error=comment
Expand Down Expand Up @@ -304,7 +304,7 @@ function(xgl_compiler_options TARGET)

if(CMAKE_BUILD_TYPE_RELEASE)
target_compile_options(${TARGET} PRIVATE -O3)
if(XGL_ENABLE_LTO)
if(VKI_ENABLE_LTO)
if(${CMAKE_CXX_COMPILER_ID} MATCHES "GNU")
execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
if(GCC_VERSION VERSION_GREATER 5.3 OR GCC_VERSION VERSION_EQUAL 5.3)
Expand Down
24 changes: 12 additions & 12 deletions cmake/XglHelper.cmake
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,19 +28,19 @@ include_guard()
macro(xgl_append_common_sanitizer_flags)
if(NOT MSVC)
# Append -fno-omit-frame-pointer and turn on debug info to get better stack traces.
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -fno-omit-frame-pointer")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -fno-omit-frame-pointer")
if (NOT CMAKE_BUILD_TYPE_DEBUG)
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -gline-tables-only")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -gline-tables-only")
else()
# Use -O1 even in debug mode, otherwise sanitizers slowdown is too large.
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " -O1")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " -O1")
endif()
elseif(CLANG_CL)
# Keep frame pointers around.
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " /Oy-")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " /Oy-")
# Always ask the linker to produce symbols with asan.
string(APPEND ICD_SANITIZER_COMPILE_FLAGS " /Z7")
string(APPEND ICD_SANITIZER_LINK_FLAGS " -debug")
string(APPEND VKI_SANITIZER_COMPILE_FLAGS " /Z7")
string(APPEND VKI_SANITIZER_LINK_FLAGS " -debug")
endif()
endmacro()

Expand All @@ -49,18 +49,18 @@ macro(xgl_append_gcov_coverage_flags)
# This option is used to compile and link code instrumented for coverage analysis.
# The option --coverage is a synonym for -fprofile-arcs -ftest-coverage (when compiling) and -lgcov (when linking)
# Ref link: https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html#Instrumentation-Options
string(APPEND ICD_GCOV_COMPILE_FLAGS " --coverage")
string(APPEND ICD_GCOV_LINK_FLAGS " --coverage")
string(APPEND VKI_GCOV_COMPILE_FLAGS " --coverage")
string(APPEND VKI_GCOV_LINK_FLAGS " --coverage")

if (NOT CMAKE_BUILD_TYPE_DEBUG)
# Use -O0 even in not debug mode, otherwise code coverage is not accurate.
string(APPEND ICD_GCOV_COMPILE_FLAGS " -O0")
string(APPEND VKI_GCOV_COMPILE_FLAGS " -O0")
endif()

if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
string(APPEND ICD_GCOV_COMPILE_FLAGS " -Xclang -coverage-cfg-checksum")
string(APPEND ICD_GCOV_COMPILE_FLAGS " -Xclang -coverage-no-function-names-in-data")
string(APPEND ICD_GCOV_COMPILE_FLAGS " -Xclang -coverage-version='408*'")
string(APPEND VKI_GCOV_COMPILE_FLAGS " -Xclang -coverage-cfg-checksum")
string(APPEND VKI_GCOV_COMPILE_FLAGS " -Xclang -coverage-no-function-names-in-data")
string(APPEND VKI_GCOV_COMPILE_FLAGS " -Xclang -coverage-version='408*'")
endif()
else()
message(FATAL_ERROR "Unknown compiler ID: ${CMAKE_CXX_COMPILER_ID}")
Expand Down
31 changes: 11 additions & 20 deletions cmake/XglOptions.cmake
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,21 +39,18 @@ macro(xgl_options)
option(VKI_DEVMODE_COMPILER_SETTINGS "Build with devmode compiler settings?" OFF)
#endif

option(XGL_ENABLE_PRINTS_ASSERTS "Build with debug print enabled?" OFF)
option(VKI_ENABLE_PRINTS_ASSERTS "Build with debug print enabled?" OFF)

option(XGL_ENABLE_LTO "Build with LTO enabled?" ON)
option(VKI_ENABLE_LTO "Build with LTO enabled?" ON)

option(XGL_ENABLE_GCOV "Build with gcov source code coverage?" OFF)
#if VKI_BUILD_GFX115
option(XGL_BUILD_GFX115 "Build vulkan for GFX115" ON)
#endif
option(VKI_ENABLE_GCOV "Build with gcov source code coverage?" OFF)
#if VKI_BUILD_STRIX1
option(XGL_BUILD_STRIX1 "Build vulkan for STRIX1" ON)
option(VKI_BUILD_STRIX1 "Build vulkan for STRIX1" ON)
#endif

option(XGL_BUILD_TESTS "Build tests?" OFF)
option(VKI_BUILD_TESTS "Build tests?" OFF)

option(XGL_BUILD_TOOLS "Build tools?" OFF)
option(VKI_BUILD_TOOLS "Build tools?" OFF)

#if VKI_RAY_TRACING
option(VKI_RAY_TRACING "Build vulkan with RAY_TRACING" ON)
Expand All @@ -65,22 +62,16 @@ macro(xgl_options)

option(ICD_BUILD_LLPC "Build LLPC?" ON)

option(XGL_LLVM_UPSTREAM "Build with upstreamed LLVM?" OFF)

option(XGL_ENABLE_ASSERTIONS "Enable assertions in release builds" OFF)

option(XGL_ENABLE_LIBCXX "Use libc++. This is intended for MemorySanitizer support only." OFF)

option(ICD_GPUOPEN_DEVMODE_BUILD "Build ${PROJECT_NAME} with GPU Open Developer Mode driver support?" ON)
option(VKI_ENABLE_ASSERTIONS "Enable assertions in release builds" OFF)

option(ICD_MEMTRACK "Turn on memory tracking?" ${CMAKE_BUILD_TYPE_DEBUG})
option(VKI_ENABLE_LIBCXX "Use libc++. This is intended for MemorySanitizer support only." OFF)

if(UNIX AND (NOT ANDROID))
option(BUILD_WAYLAND_SUPPORT "Build XGL with Wayland support" ON)
option(VKI_BUILD_WAYLAND "Build XGL with Wayland support" ON)

option(BUILD_DRI3_SUPPORT "Build XGL with Dri3 support" ON)
option(VKI_BUILD_DRI3 "Build XGL with Dri3 support" ON)
endif()

option(ICD_ANALYSIS_WARNINGS_AS_ERRORS "Warnings as errors?" OFF)
option(VKI_ANALYSIS_WARNINGS_AS_ERRORS "Warnings as errors?" OFF)

endmacro()
Loading

0 comments on commit a367518

Please sign in to comment.