build: Update to header 1.3.240

- Update known-good
- Generate source

Re-checking loader.rc file

The loader.rc file is now checked into the source, and is automatically updated
by python whenever the headers are updated so that it contains the version used
to build the loader.

If BUILD_DLL_VERSIONINFO is set in the command line, then the loader will use
that version to configure a new loader.rc and place it in the build directory.
Then it will use that loader.rc rather than the checked in file. This allows
Vulkan Runtimes to be built with an exact version.

The file is checked in to allow builds without modifying the source directory
and allowing GN builds to not need any additional configuration to work.

ci: Fix CI warnings

Fix copyright in windows .rc file

This commit makes the copyright date to be taken from the day of the build
instead of it being hardcoded, which is liable to be out of date.

This commit also makes the loader.rc be generated into the build directory
rather than the source tree. Because this commit modifies the version info to
include the current header version for debug builds, this prevents needing to
update the file whenever the headers update.

Log when VK_LAYER_PATH is ignored

The current design of the loader make the Override Layer, with its override
paths, take priority over VK_LAYER_PATH. This is fine, but if the override
layer accidentally was left around, it can cause confusion as VK_LAYER_PATH
suddenly stops working for no apparent reason. This commit adds a log message
to indicate that it is being ignored.

github: Use main instead of master

closes #1107

docs: Notify users about upcoming master to main change

build: Update to header 1.3.239

- Update known-good
- Generate source

Add Vulkan Loader and Driver Interface Version 7

The changes made by Version 7 are as follows.
If a Driver supports any of the following functions,
they must be exposed by with vk_icdGetInstanceProcAddr:
 * vk_icdNegotiateLoaderICDInterfaceVersion
 * vk_icdGetPhysicalDeviceProcAddr
 * vk_icdEnumerateAdapterPhysicalDevices (Windows only)
This makes it optional for a driver to export these functions. Drivers may still
export them for compatibility with older loaders.

Loader and Driver Interface Version 7 allows for drivers provided through the
VK_LUNARG_direct_driver_loading extension to support the entire Loader and Driver
Interface.

This commit makes many small fixes to the documentation. Main changes are adding
Version 7 of the Loader and Driver Interface, clarifies when the functions
associated with this version must be exported, when they can be optionally exported
and when they must be exposed through vk_icdGetInstanceProcAddr. This also
clarifies LDP_DRIVER_10 to note the exact behavior of drivers that is disallowed.
In the process of these documentation changes, the glossary was amended with
definitions for Exported Functions, Exposed Functions, and Querying Functions.

build: Remove VS2015 support

ci: Test CMake minimum

Add guard for GetPhysDevProcAddr typedef

vk_layer_dispatch_table.h may be included after vk_icd.h and may cause multiple
definitions. This commit adds a macro guard on whether the type is defined just
in case.

Try to catch OOM errors when loading binaries

If there is an error loading a dynamic library, check to see if it is
the result of an OOM condition. Then return the appropriate OOM error
code up the callchain. This commit is the result of an OOM condition
when trying to load the validation layers, which resulted in the return
code VK_ERROR_LAYER_NOT_PRESENT. This is very misleading. If the
loader can catch then report more accurate information, then it should.

Added target condition to vulkan headers

cmake: Fix usage of Vulkan::Registry

Vulkan::Registry was deprecated by Vulkan-Headers

Use 'VULKAN_HEADERS_REGISTRY_DIRECTORY' instead.

closes #1106

Document behavior change in how bundles drivers are used

Document that a bundled driver on macOS will cause the loader to ignore drivers
in system installed locations.

Add macOS bundles support to test framework

Allow basic tests to be written which exercise the bundle discovery and loading logic
in the loader. This allows testing whether drivers found in bundles disables searching
for drivers on the rest of the system.

This commit also inclues fixes for a half dozen non essential spelling mistakes.

Fix Bundled drivers on MacOS taking precedence

Previous commits broke the behavior of only using bundled drivers if found,
this commit fixes the condition to make sure the bundled drivers are used while
no other drivers are loaded.

Add Vulkan-Headers version to source

The version of the Vulkan-Headers used to generate the source code is what should be
used to set the version of the binary, rather than the version of the Vulkan-Headers
that is currently available. This commit checks that version into the repo so that
it is used, and adds the necessary python code to update it.

This behavior was previously in the repo but was broken by the update to use the
version parsing logic from the Vulkan-Headers.

Fix allocation callback test to start at 0

While working on the code, it is common to start the allocation tests at a fail_index
greater than zero, usually close to when the issue starts. This was accidentally
checked in, this commit fixes that mistake.

Revert asm_offset CMake code to work with 3.10

The revertion of gen_defines.asm generation during cross compilation changed the
form of add_custom_command used, which inadvertently relied on CMake 3.16 support.

From the CMake Docs:
DEPENDS:
...
A target-level dependency is added if any dependency is a byproduct of a target or
any of its build events in the same directory to ensure the byproducts will be
available before this target is built.

cmake: Use VulkanHeaders_VERSION

Removes need for a bit of python code / parsing.
And it's consistent with VVL's approach.

build: Update to header 1.3.238

- Update known-good
- Generate source

Fix for Apple compiler bug

build: Update to header 1.3.237

- Update known-good
- Generate source

Document interaction of layer env-vars for linux

> If `VK_LAYER_PATH` is present, then `VK_ADD_LAYER_PATH` will not be
used by the loader and any values will be ignored.

This was present for the Windows documentation but not for linux and
company.

Layers: expand tests to check layer names loaded are expected

Layers: update log message and documentation so it is clear that VK_LAYER_PATH does not only search directories

Layers: modify TestLayerDetails so either files or directories can be set on VK_LAYER_PATH env var

Layers: add tests to verify VK_LAYER_PATH works with full file paths

Layers: add test to verify VK_LAYER_PATH supports explicit file paths instead of just directories

Layers: update documentation to make it clear the VK_LAYER_PATH supports both explicit directories and files

loader: Fix parsing VK_INSTANCE_LAYERS

build: Update to header 1.3.236

- Update known-good
- Generate source

loader: Mark unknown_ext_chain symbols as hidden

These don't need to be exported from the shared library, as they're just
internal implementation details.

Closes #1079

Use integrity_level >= HIGH for is_high_integrity

Previously it used integrity_level > MEDIUM, which causes issues since
occasionally windows elevates certain regular user mode processes to
be MEDIUM + 0x100 or similar, causing the `is_high_integrity()` to
return true even though it isn't an admin level process.

cmake: fix pkgconfig file for absolute install paths

Fixes #1076

Add more OOM handling paths and refactor OOM tests

There were more cases where OOM wasn't being propagated correctly, or
even caught in the first place. This change makes all of those paths
report OOM to the application as is expected. One case was due to linux
sorting erroring out but then leaking memory, which wasn't caught because
the tests didn't create devices that supported PhysDevProps2.

Lastly, since the Allocation tests were taking much longer due to making
many more allocations, the MemoryTracker was rewritten to use
std::unordered_map to speed up insertion and lookup of allocations made.

build: Update to header 1.3.235

- Update known-good
- Generate source

Add complex json file to allocation tests

This helps exercise the cJSON OOM handling code. The json file is
just a copy of the validation layer manifest file.

Propagate OOHM error from json parsing

There was a few places where an out of memory error could be generated
by parsing json but were not passed on upwards, causing CTS tests to fail.

Fix cases where OOM was handled wrong

goto's were replaced by returns erroneously. This caused unfreed memory in
certain OOM scenarios, caught by CTS. The reason the loader tests didn't catch
this was because the fake drivers did not report any extensions, thus no memory
was allocated (which would later be leaked). This commit addressess this
deficiency in the tests as well, which included correctly incrementing the
MemoryTracker's allocation count during realloc.

Handle invalid files & symlinks properly

If loader_get_json fails due to the file missing or the file being a
stale symlink, it returns VK_ERROR_INITIALIZATION_FAILED
which loader_parse_icd_manifest passed upwards. Since the caller of
loader_parse_icd_manifest wasn't expecting that error code, it didn't
skip the ICD, causing an infinite recusion in EnumInstExtProps due
to the call to dlsym("vkEnumerateInstanceExtensionProperties");

This also required changes to callers of loader_get_json which would
propagate VK_ERROR_INITIALIZATION failed during layer searching to
no longer cause vkCreateInstance to abort if any invalid files were
found.

Added tests for symlinks as the origin of this bug is due to 'stale'
symlinks after driver installers

Recheck API version in terminator_CreateInstance

Layers are liable of changing the API version during the call down
vkCreateInstance. Certain layers use the guarantees of 1.1 to allow
using VK_KHR_get_physical_device_properties2 functionality. This
commit checks and assignes a new API version if it was modified.

Add tests for when the application forgets to enable 1.1 and when
a layer enabled 1.1 on behalf of the application.

Remove redundant code
loader_make_version recently was changed to zero out the patch version, explicitly doing it is no longer necessary.

cmake: CMake cleanup

- Use idiom for CMAKE_MODULE_PATH
- find_package(PkgConfig) instead of include(FindPkgConfig)
- Remove CMake 2.X code workaround
- Use CMAKE_CURRENT_BINARY_DIR instead of CMAKE_BINARY_DIR
- CMakeParseArguments is now part of the language

Add macOS-latest CI action

Re-enables using the macOS-latest github actions runner now that the loader
has been fixed for newer macOS versions.

build: Update to header 1.3.234

- Update known-good
- Generate source

Call both EnumPhysDevs & EnumAdapterPhysDevs on drivers

This change is necessary to allow drivers that have both real physical
devices with a LUID and software based physical devices which lack a LUID.
It works by calling both vk_icdEnumerateAdapterPhysicalDevice and
vkEnumeratePhysicalDevice then deduplicating the returned physical devices
using the VkPhysicalDevice handles.

This commit also fixes an issue where tests would erroneously add a layer to the
driver registry.

Remove log message of ICD extension lists

Dont abort when WSI functions are NULL.

Commit d1db6c5bce9ed474ca124f0bffed9aa2468f3973 changed a few WSI functions
to abort when the driver's function was NULL, which is a change of existing
behavior. It should instead return VK_SUCCESS. At least now there is a
warning message.

This commit also adds tests for the above situation and for debug utils
& debug marker functions to make sure the pre-existing behavior is maintained.
This was tested by running the loader with a previous build through the new
tests and verified that they both passed. The tests run the cases of whether
the extensions were enabled, how the functions were queried (GIPA vs GDPA), and
whether the hardware supports the extensions.

cmake: Use new VulkanHeaders cmake support

Removes need to have FindVulkanHeaders.cmake

Remove USE_CCACHE build option

The way to use ccache has changed since this documentation & build
option were added. Update the docs with the new way to enable ccache
and remove the build option.

loader/cJSON: replace sprintf calls with snprintf

This makes it possible to build Vulkan-Loader without warnings using the
macOS 13 SDK. Calls to sprintf are replaced with snprintf, passing
appropriate buffer sizes.

It doesn’t appear that any of the changed uses of sprintf were actually
unsafe, so no behavior change is expected aside from SDK compatibility.

The macOS 13 SDK deprecates sprintf as it’s difficult to use safely. The
deprecation warning message is visible when building C++, but it is not
normally visible when building plain C code due to a quirk in how
sprintf is declared in the SDK. However, the deprecation message is
visible when building plain C under Address Sanitizer
(-fsanitize=address). This discrepancy was discovered at
https://crbug.com/1381706 and reported to Apple with a copy at
https://openradar.appspot.com/FB11761475.

The macOS 13 SDK is packaged in Xcode 14.1, released on 2022-11-01. This
also affects the iOS 16 SDK and other 2022-era Apple OS SDKs packaged in
Xcode 14.0, released on 2022-09-12.

Vulkan-Loader is visible to the Chromium build via PDFium, and this
change is needed to allow Chromium to move forward to the macOS 13 SDK.

Fix vulkan.pc Libs.private for static builds

The Libs.private field shouldn't be present for shared library builds,
so now the field wont be present in that case. For static library builds
it should be present, but the fields should be deduplicated as well.

Additionally, this adds a github actions run for testing the static
build of the loader on MacOS. This requires making the test framework
capable of using a statically built loader, which mainly took making
VulkanFunctions capable of assigning the statically defined functions
instead of loading them with dlsym.

The static build option required changes to the unix_shim.cpp to not
cause infinite loops.

Fix tests for env-var filtering due to previous commit

The previous commit altered vkCreateInstance erroring out if the
application tries to enable an env-var disabled layer, so the tests
need to be revised for it. This commit also makes lot of modifications
to the tests in addition to that.

Also adds tests for when the override layer is present and when
implicit layer's enable-environment variables are present.

Fix env-var filtering in layer enumeration

Disabled layers would appear in the output of EnumerateInstanceLayers, which was
not intended. Move the removal of layers that are disabled by the env-var to after
the explicit layers are found.

Add the 1.3.224 Header version to the Env-Var documentation

This way users know exactly which version of the loader contains the
new environment variables.

Remove redundant layer searching in term_EnumDevExts

When terminator_EnumerateDeviceExtensionProperties is called, the app
now only checks that the type flag is implicit rather than building up a new
list of implicit layers, as building a list could cause many suprious log
messages and was unecessary. This commit also removes some redundant copies &
for loops in the function.

Update and clarify filter documentation

Based on review feedback from @hadess

Put placeholder for loader version

TODO: Replace all 1.3.yyyy with appropriate header version after
approval.

Update so filters apply results to vkEnumInstanceLayerProps

Also remove duplication so that common code is used in several places.

Add loader enable/disable env vars

Add new environment variables that will allow the loader to filter
layers and drivers in specific ways.
This control should give developers ways to more quickly narrow down
issues with a layer or driver.
Also, it should give CI environments a mechanism to selectively enable
only drivers and layers that are needed for testing.

Add tests to support validating the new changes.

Add documentation that describes the new changes and also create new
loader debugging markdown document to help people debug issues with
drivers or layers using the new filter enums.

Rename the old get_environment.* source files to loader_environment.*.
Then put all the environment variable helpers from loader.c into the
new files.

Do not include vk_sdk_platform.h

Nothing in this file was being used.

build: Update to header 1.3.233

- Update known-good
- Generate source

Dont abort when driver doesn't support debug utils

A recent change made it so that when either vkDebugMarkerSetObjectTagEXT,
vkDebugMarkerSetObjectNameEXT, vkSetDebugUtilsObjectNameEXT, or
vkSetDebugUtilsObjectTagEXT is called, if a driver doesn't support any
of those functions the loader would abort. This is incorrect because drivers
may not support the debug utils extension while the loader & layers might.
Now the loader only aborts if the Device handle is invalid, and simply
returns VK_SUCCESS if a driver doesn't support those functions.

Remove override layer expiration

This was an undocumented feature of the override manifest layer.
Since vkconfig is the primary user of the override layer, and vkconfig
makes no effort to include expiration support, this feature is not being
used. Thus, it is best to remove it entirely.

Remove implicit fallthroughs; Add warning

Previously, cJSON used implicit fallthrough in a switch statement. Naked
fallthroughs are a common bug source, and while this use case was well
behaved, it did require disabling the compiler warnings for it. Thus,
converting it to an explicit for loop prevents unnecessary compiler
warning flags being disabled.

Test Wrap Layer didn't unwrap in vkGetInstanceProcAddr

Wrapping layer should be unwrapping the instance handle inside of GetProcAddr
functions.

Null check vk_icdGetPhysicalDeviceProcAddr

Forgotten NULL check causes crashes if a driver forgets to export
vk_icdGetPhysicalDeviceProcAddr but does report a 4 or higher
ICD Interface Version.

Use macos-11 in github actions to work around bugs

There seems to be an incompatible change in macos-12 which breaks the loader's test
framework. While this is being resolved, move the github actions runners from the latest
to only using 11.

Remove Device functions from ICD Dispatch table

There are numerous terminators to device level functions that the loader must
insert in the call chain. However, the Device Dispatch Tables contain pointers
to these terminators rather than the driver's function. This was worked around
by storing the driver's functions in the ICD dispatch table and calling those.
This leads to rather confusing code where the application is querying for the
ICD dispatch table inside a device level function.

The solution is to create a bespoke dispatch table for device level functions
that require a terminator, and use that table when required.

build: Update to header 1.3.232

- Update known-good
- Generate source

Revert "Remove vkCreateSwapchainKHR from ICD Dispatch table"

This reverts commit d79e2731d45bf4c81f650f27205e208a023269aa.

Revert "Document vk_icdGetInstanceProcAddr querying device functions"

This reverts commit 068e83f5f20e38c3ae1687e7f1aeb59bf6ce3e72.

Document vk_icdGetInstanceProcAddr querying device functions

vk_icdGetInstanceProcAddr has similar semantics to vkGetInstanceProcAddr.
It was created to prevent dynamic linker issues. It stated that it should support
global & instance level function querying. But this differs from the Vulkan spec
which states that vkGetInstanceProcAddr should be able to query all functions.
This creates confusion about what takes precendence, the spec or the loader's docs.

This commit makes it explicit that it should have the same semanics what the spec
says.

Remove vkCreateSwapchainKHR from ICD Dispatch table

vkCreateSwapchainKHR and vkGetDeviceGroupSurfacePresentModesKHR were added to
the icd dispatch table then loaded with GIPA. While this is possible, for best
performance and consistency, the loader should use the device's dispatch table
for these functions. This required changing the terminators for both functions
so that they checked that the dev pointer isn't null and its dispatch entry for
each function isn't null.

Additionally, various debug marker/util functions checked if an ICD supported
surfaces by checking the ICD's dispatch table for vkCreateSwapchainKHR. These
have been updated to use the device's dispatch table instead.

Add 32 bit github actions CI

Fix linux 32 bit unknown function error handling

The issue was that passing a string to loader_log wouldn't work, likely due
to relocation issues. Workaround is to create a bespoke function that contained
the format string embedded in it.

Additionally, CMAKE_SYSTEM_PROCESSOR is incorrect in the case of x86 builds on
x64. Checking for sizeof(void*) == 8 allows distinguishing building for 32 bit
and 64 bit, and so the correct gen_defines.asm is created while cross compiling.

Also rename the error to note that its a function which isn't supported, not
an extension.

Revert "Don't query vkCreateSwapchainKHR with GIPA"

This reverts commit af67fccebe59e8d8e30e8c02b7b0069ce4242fc4.

Revert "Document vk_icdGetInstanceProcAddr querying device functions"

This reverts commit e5680db8ae5640dde10b58b8ab45e4a6201ae3e9.

fix: format code

fix: add null pointer checking

fix: add dev pointer checking

fix: add dev pointer checking before using

Document vk_icdGetInstanceProcAddr querying device functions

vk_icdGetInstanceProcAddr has similar semantics to vkGetInstanceProcAddr.
It was created to prevent dynamic linker issues. It stated that it should support
global & instance level function querying. But this differs from the Vulkan spec
which states that vkGetInstanceProcAddr should be able to query all functions.
This creates confusion about what takes precendence, the spec or the loader's docs.

This commit makes it explicit that it should have the same semanics what the spec
says.

Don't query vkCreateSwapchainKHR with GIPA

Previously, the loader would initialize vkCreateSwapchainKHR and
vkGetDeviceGroupSurfacePresentModeskHR with vkGetInstanceProcAddr, instead
of what should have happened, which is to use vkGetDeviceProcAddr.

Update BUILD.md

Remove references to VS 2015, as it is no longer supported.
Update the build instructions to include UPDATE_DEPS more prominently.
Move mentions of tests to the very end, and to use `ctest`.
Mention Cross Compilation caveats.

Restore asm_offset printing code

The cross compiling workaround for asm_offset requires python, but this meant
that all builds required python. This commit re-adds the removed asm_offset
logic and then only requires python during cross compilation.

Use correct allocator in debug_utils.c

loader_calloc_with_instance_fallback is used in places where a user can
supply their own allocator, but should default to the allocator used with
the instance otherwise. The issue was that loader_free was being used with
objects created with the instance allocator, but loader_free only takes the
user provided one, leading to leaks.

Only deduplicate driver manifests

Code which was originally meant to deduplicate drivers that moved from the old
registry HKEY_LOCAL_MACHINE/SOFTWARE/Khronos/Vulkan/Drivers to PnP locations
was incorrectly applied to layers as well. The issue is that multiple layers
can share the same json file name but not actually contain the same manifest.
Worse, the first layer found would be assumed to be correct, even the file had
been deleted from the file system.

Write gen_defines.asm using a python script

This allows cross compilation to enable unkonwn function handling as
gen_defines.asm will be generated without needing to run code meant for the
target platform. Previously, asm_offset.c wrote the gen_defines.asm file
by being run. Now, compilers emit their intermediate assembly output that the
parse_asm_values.py script knows how to find the relevant information from.

Additionally set the test framework `framework_config` build option to always
copy, instead of copy_if_different. This is needed since cmake wouldn't update
this file when changing from/to debug & release mode.

ci: Use MACOS_DEPLOYMENT_TARGET

- This approach matches what our SDK release process expect
  - Since setting CMAKE_MACOS_DEPLOYMENT_TARGET ignores env variable which SDK
release process uses, which could will cause issues in the future, if
the version is changed
- CMAKE_MACOS_DEPLOYMENT_TARGET doesn't propogate to dependencies via
  update_deps.py

build: Update to header 1.3.231

- Update known-good
- Generate source

Correctly handle layers not being loaded in vkCreateDevice

This reverts the previous commit which reverted bad behavior.

Revert "Don't load layer libraries in vkCreateDevice"

This reverts commit cd9b4afed4e556ac88a75371eb7283fed94ca3c6.

Guard loader.instances access with mutex.

While the adding and removing of data from this global linked list
was guarded, GetInstanceProcAddr & GetDeviceProcAddr did not have
such guards. This results in race conditions that were detected with
thread sanitizer. This commit adds a mutex solely for the
loader.instances global variable.

Fix issue with MSVC 15 failing to compile test code

Was a basic case of googletest not allowing implicit conversion between
types.

Don't abort when drivers don't support WSI calls

Instance extensions are aggregated, therefore an application has no way of
knowing whether an ICD supports a WSI function or not. This necessitates
returning instead of aborting from WSI functions, as well as writing 0,
NULL, or returning false as needed for each function. This also needs
additional NULL checks before calling down into the driver.

Enable cross compile test discovery

gtest_discover_tests() doesn't work in cross compilation environments, so if
that is happening fall back to gtest_add_tests().