WIP: CMake (#3326)

* More robust input and output selection in generator tools

* Add cmake build system

* Get slang-test running with cmake

* Bump lz4 and miniz dependencies

* Make cmake build more declarative

* Correct preprocessor logic in slang.h

* Add cuda test to compute/simple

* Remove empty cmake files

* output placement for cmake, and commenting

* Correct include paths in spirv-embed-generator

* Format cmake with gersemi

* Make cmake build clerer

* Neaten header generation

Also work around https://gitlab.kitware.com/cmake/cmake/-/issues/18399
by introducing correct_generated_properties to set the GENERATED flag in
the correct scope

* remove unused files

* use 3.20 to set GENERATOR property properly

* spelling

* more flexible linker arg setting

* replace slang-static with obj collection

* Set rpath and linker path correctly

* neaten generated file generation

* tests working with cmake build

* fix premake5 build

* comment and neaten cmake

* remove unnecessary dependency

* Build aftermath example only when aftermath is enabled

* Add slang-llvm and other dependencies

* Put modules alongside binaries

* Find slang-glslang correctly

* Better option handling

* comments

* add llvm build test

* Better option handling

* cmake wobble

* use UNICODE and _UNICODE

* remove other workflows

* use ccache

* neaten

* limit parallel for llvm build

* use ninja for build

* Windows and Darwin slang-llvm builds

* cache key

* verbose llvm build

* cl on windows

* sccache and cl.exe

* use cl.exe

* Correct package detection

* less verbosity

* Simplify miniz inclusion

* fix build with sccache

* Neaten llvm building

* neaten

* Neaten slang-llvm fetching

* more surgical workarounds

* Add ci action

* Get version from git

* better variable naming

* add missing include

* clean up after premake in cmake

* more docs on cmake build

* ci wobble

* add imgui target

* more selective source

* do not download swiftshader

* Some missing dependencies

* only build llvm on dispatch

* Disable /Zi in CI where sccache is present

* simplify

* set PIC for miniz

* set policies before project

* reengage workaround

* more runs on ci

* Add cmake presets

* Add cpack

* move iterator debug level to preset

* Correct lib flag

* simplify action

* Neaten cmake init

* Add todo

* Add simple test wrapper

* Add tests to workflow presets

* rename packing preset

* Correctly set definitions

* docs

* correct preset names

* Make slang-test depend on test-server/test-process

* neaten

* use workflow in actions

* install docs

* Correct module install dir

* debug dist workflow

* Install headers

* neaten header globbing

* Neaten dependency handling

* make lib and bin variables

* Do not set compiler for vs builds, unnecessary

* docs

* allow setting explicit source for target

* maintain archive subdir

* cmake docs

* install headers

* place targets into folders

* cmake docs

* nest external projects in folder

* remove name clash

* Neater external packages

* meta targets in folder structure

* cleaner slang-glslang dll

* Add missing static directive to slang-no-embedded-stdlib

* more robust module copying

* make slang-test the startup project

* folder tweak

* Make FETCH_BINARY the default on all platforms

* Set DEBUG_DIR

* add natvis files to source

* skip spirv tests

* remove test step from debug dist

* Add build to .gitignore

* redo warnings to be more like premake

* Update imgui

* clean more premake files

* Disable PCH for glslang, gcc throws a warning

* Add /MP for msvc builds

* warning wobble

* Add script to build llvm

* Add slang-llvm and generators components

* Build slang-llvm in ci

* comments

* fetch llvm with git

* better abi approximation for cache

* better sccache key

* formatting

* Correct logic around disabling problematic debug info for ccache

* exclude gcc and clang from windows ci

* Make dist workflows use system llvm

* naming

* restore normal dist builds

* formatting

* run tests in ci

* Correct slang-llvm url setting

* Rely on the system to find the test tool library

* actions matrix wiggle

* cope with OSX ancient bash

* Correct compilers on windows

* more ci debugging

* Correct rpath handling on OSX

* neaten

* correct path to slang-llvm

* Correct rpath separator on osx

* Find slang-llvm correctly

* smoke tests only on osx

* ci wobble

* Give MacOS module a dylib suffix

* get swiftshader correctly

* cope with bsd cp

* remove debug output

* full tests on osx

* ci wobble

* Add some vk tests to expected failures

* simplify ci

* ci wobble

* exclude dx12 tests from github ci

* remove cmake code for building llvm

* warnings

* warnings as errors for cl

* spirv-tools in path

* add aarch64 ci build

* Add SLANG_GENERATORS_PATH option for prebuilt generators

* neaten

* Correct generator target name

* remove yaml anchors because github actions does not support them

* Demote CMake in docs

Also add info on cross compiling

* Restore premake CI

* use minimal ci for cmake

* Write miniz_export for premake build

and .gitignore it

* Mention build config tool options in docs

* Remove redefined macro for miniz

* regenerate vs project

1 files changed, 217 insertions, 0 deletions

diff --git a/cmake/CompilerFlags.cmake b/cmake/CompilerFlags.cmake
new file mode 100644
index 000000000..2a9988d4e
--- /dev/null
+++ b/cmake/CompilerFlags.cmake
@@ -0,0 +1,217 @@
+#
+# Given a list of flags, add those which the C++ compiler supports to the target
+#
+include(CheckCXXCompilerFlag)
+function(add_supported_cxx_flags target)
+    cmake_parse_arguments(ARG "PRIVATE;PUBLIC;INTERFACE" "" "" ${ARGN})
+    set(flags ${ARG_UNPARSED_ARGUMENTS})
+    if(ARG_PRIVATE)
+        set(private PRIVATE)
+    endif()
+    if(ARG_PUBLIC)
+        set(public PUBLIC)
+    endif()
+    if(ARG_INTERFACE)
+        set(interface INTERFACE)
+    endif()
+
+    foreach(flag ${flags})
+        # remove the `no-` prefix from warnings because gcc doesn't treat it as an
+        # error on its own
+        string(REGEX REPLACE "\\-Wno\\-(.+)" "-W\\1" flag_to_test "${flag}")
+        string(
+            REGEX REPLACE
+            "[^a-zA-Z0-9]+"
+            "_"
+            test_name
+            "CXXFLAG_${flag_to_test}"
+        )
+        check_cxx_compiler_flag("${flag_to_test}" ${test_name})
+        if(${test_name})
+            target_compile_options(
+                ${target}
+                ${private}
+                ${public}
+                ${interface}
+                ${flag}
+            )
+        endif()
+    endforeach()
+endfunction()
+
+#
+# Given a list of linker flags, add those which the compiler supports to the
+# target
+#
+include(CheckLinkerFlag)
+function(add_supported_cxx_linker_flags target)
+    cmake_parse_arguments(ARG "PRIVATE;PUBLIC;INTERFACE;BEFORE" "" "" ${ARGN})
+    set(flags ${ARG_UNPARSED_ARGUMENTS})
+    if(ARG_BEFORE)
+        set(before BEFORE)
+    endif()
+    if(ARG_PRIVATE)
+        set(private PRIVATE)
+    endif()
+    if(ARG_PUBLIC)
+        set(public PUBLIC)
+    endif()
+    if(ARG_INTERFACE)
+        set(interface INTERFACE)
+    endif()
+
+    foreach(flag ${flags})
+        string(
+            REGEX REPLACE
+            "[^a-zA-Z0-9]+"
+            "_"
+            test_name
+            "CXXLINKFLAG_${flag}"
+        )
+        check_linker_flag(CXX "${flag}" ${test_name})
+        if(${test_name})
+            target_link_options(
+                ${target}
+                ${before}
+                ${private}
+                ${public}
+                ${interface}
+                ${flag}
+            )
+        endif()
+    endforeach()
+endfunction()
+
+#
+# Add our default compiler flags to a target
+#
+# Pass USE_EXTRA_WARNINGS to enable -WExtra or /W3
+#
+function(set_default_compile_options target)
+    cmake_parse_arguments(
+        ARG
+        "USE_EXTRA_WARNINGS;USE_FEWER_WARNINGS"
+        ""
+        ""
+        ${ARGN}
+    )
+
+    set(warning_flags)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+        list(
+            APPEND
+            warning_flags
+            -Wall
+            # Disabled warnings:
+            -Wno-switch
+            -Wno-parentheses
+            -Wno-unused-local-typedefs
+            -Wno-class-memaccess
+            -Wno-assume
+            -Wno-reorder
+            -Wno-invalid-offsetof
+            -Wno-newline-eof
+            -Wno-return-std-move
+            # Enabled warnings:
+            # If a function returns an address/reference to a local, we want it to
+            # produce an error, because it probably means something very bad.
+            -Werror=return-local-addr
+            # Some warnings which are on by default in MSVC
+            -Wnarrowing
+        )
+        if(ARG_USE_EXTRA_WARNINGS)
+            list(APPEND warning_flags -Wextra)
+        endif()
+        if(ARG_USE_FEWER_WARNINGS)
+            list(
+                APPEND
+                warning_flags
+                -Wno-class-memaccess
+                -Wno-unused-variable
+                -Wno-unused-parameter
+                -Wno-sign-compare
+                -Wno-unused-function
+                -Wno-unused-value
+                -Wno-unused-but-set-variable
+                -Wno-implicit-fallthrough
+                -Wno-missing-field-initializers
+                -Wno-strict-aliasing
+                -Wno-maybe-uninitialized
+            )
+        endif()
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+        list(APPEND warning_flags)
+        if(ARG_USE_EXTRA_WARNINGS)
+            list(APPEND warning_flags /W4)
+        elseif(ARG_USE_FEWER_WARNINGS)
+            list(APPEND warning_flags /W0)
+        else()
+            list(APPEND warning_flags /W2)
+        endif()
+    endif()
+
+    add_supported_cxx_flags(${target} PRIVATE ${warning_flags})
+
+    # Don't assume that symbols will be resolved at runtime
+    add_supported_cxx_linker_flags(${target} PRIVATE "-Wl,--no-undefined")
+
+    set_target_properties(
+        ${target}
+        PROPERTIES # -fvisibility=hidden
+            CXX_VISIBILITY_PRESET
+            hidden
+            # C++ standard
+            CXX_STANDARD
+            17
+            # pic
+            POSITION_INDEPENDENT_CODE
+            ON
+    )
+
+    target_compile_definitions(
+        ${target}
+        PRIVATE # Add _DEBUG depending on the build configuration
+            $<$<CONFIG:Debug>:_DEBUG>
+            # For including windows.h in a way that minimized namespace
+            # pollution. Although we define these here, we still set them
+            # manually in any header files which may be included by another
+            # project
+            WIN32_LEAN_AND_MEAN
+            VC_EXTRALEAN
+            NOMINMAX
+            # Use multi-byte character set on Windows
+            UNICODE
+            _UNICODE
+    )
+
+    #
+    # Settings dependent on config options
+    #
+
+    if(SLANG_ENABLE_FULL_DEBUG_VALIDATION)
+        target_compile_definitions(
+            ${target}
+            PRIVATE SLANG_ENABLE_FULL_IR_VALIDATION
+        )
+    endif()
+
+    if(SLANG_ENABLE_DX_ON_VK)
+        target_compile_definitions(${target} PRIVATE SLANG_CONFIG_DX_ON_VK)
+    endif()
+
+    if(SLANG_ENABLE_ASAN)
+        add_supported_cxx_flags(
+            ${target}
+            PRIVATE
+            /fsanitize=address
+            -fsanitize=address
+        )
+        add_supported_cxx_linker_flags(
+            ${target}
+            BEFORE
+            PUBLIC
+            /INCREMENTAL:NO
+            -fsanitize=address
+        )
+    endif()
+endfunction()