loader: add support for GNU/Hurd

* add the Hurd to COMMON_UNIX_PLATFORMS, as it is a POSIX OS
* use the Linux paths for getting the executable path (i.e. using
  /proc/self/exe): the Linux procfs provides both "self" and
  "<pid>/exe"
* follow the Linux behaviour in tests w.r.t. the platform shim
  behaviour, the test dummy binaries, and few more other bits

build: Update to header 1.3.256

- Update known-good
- Generate source

build: Update to header 1.3.255

- Update known-good
- Generate source

Add test for layer_prop_list out of bounds indexing

This test makes sure that we correctly query for unknown functions implemented
only in a single layer while there are other layers present. This commit
successfully reproduces the error that the previous commit fixes. It was
difficult to reproduce because to get an crash, the test has to have the
instance_layer_list be in a different order than how they appear in
expanded_activated_layer_list.

Remove indexing on layer_prop_list

The usage of the layer property list inside of
loader_check_layer_list_for_phys_dev_ext_address was modified when the
list changed from an array of struct loader_layer_properties, to an array
of pointers to struct loader_layer_properties. Except, the usages of
layer_prop_list were not updated in kind, leading to out of bounds indexes
when searching for unknown physical device functions in layers. This causes
crashes in the validation layer tests, which make use of this functionality.

Cleanup test layer GIPA & GDPA function exports

Splits apart the Version 0 layer into one with 'vkGetInstanceProcAddr'
and one with 'test_layerGetInstanceProcAddr' (with a similar change for
vkGetDeviceprocAddr). This is more in line with how layers in the wild
are written.

Removes the NO_PREFIX GIPA & GDPA exports as that is not supported by
the loader.

Clarify requirements for Layer Interface Version 1

The loader has never searched for `GetInstanceProcAddr` or `GetDeviceProcAddr`,
yet has documented that Layer Interface Version 1 supports layers that export
those functions.

cmake: Update update_deps.py logic

Refactor return value of env.add_icd()

Make it return the driver that was just added rather than the ICD that
holds the driver, allowing for more concise code. This is because most
tests which modify the driver in some fashion do it in one go, and by
using the builder pattern, can be done all in a single statement.

Cleanup test creation of queues

This commit removes queue creation from many tests because they were not a
primary part of the test. Many tests are written by first copying a previous
test and modifying it, which meant that a handful of initial tests would
include queue creation logic then get copied into many other tests where it
does not make sense.

Refactor how tests load function pointers

The `load()` helper function exists so that tests dont need to
manually reinterpret_cast the returned value.

Also took liberty to change the names of function pointers which
come from extensions to include the extension in the name.
EX: AcquireDrmDisplay -> AcquireDrmDisplayEXT

Add EnumerateLayerDeviceExtensions helper to tests

Removes code duplication by taking EnumerateDeviceExtensions and modifying
it to accept a layer parameter.

Remove tests PhysicalDevice constructor overload

Having constructors to initialize specific values doesn't make sense when
the struct itself has extensive setter functions for the value in question.

Refactor how tests enable WSI

Moved the various free functions to setup WSI on drivers &
instances to member functions.

Use [[maybe_unused]] in tests

Many components of the test framework have functions where not all parameters
are used, necessitating marking the parameter as unused. Before C++17, this was
done with `(void)parameter;` syntax, but now can be done more cleanly.

Remove unnecessary constructors in tests

C++11 does not allow aggregate initialization for types with default values.
Thus, many structs used in the tests had to have constructors written which only
filled in values. With C++17, these constructors can be removed and aggregate
initialization used in many places.

This commit also provides default values for previously undefined structs to
prevent any bugs deriving from uninitialized data.

Update tests to require a C++17 compiler

Cleanup BUILD.md

Removes a lot of unnecessary text, fixes a few places that still
referred to Vulkan-ValidationLayers, replaces usage of CMake
options in the form `-DOPTION=...` with `-D OPTION=...`, moves a
few blocks of text to be in a more sensible order, and adds a
brief description of the build requirements like needing a C99
compiler.

Add ENABLE_WERROR to github actions

Makes github actions fail if there are any warnings generated.

Add and fix warnings for unused functions and parameters

These warnings were disabled, and this commit enables them.
It also fixes the many warnings that were present but were silenced. This
includes many unused parameters that could be safely removed. But it also
required marking some parameters as `(void)param;` to indicate to the
compiler that the parameter is infact required. If a function is a stub
function, then instead all of the names of the parameters were removed.

The biggest change is for vk_dispatch_table_helper.h which had stubs for
every device function. Rather than try to mark every parameter as unused
it was simpler to remove all stub functions, which aren't useful for
testing anyhow. Tests should crash rather than silently continue anyhow.

build: Update to header 1.3.254

- Update known-good
- Generate source

Mark thread_safe_strtok as inline

Because the function definition lives in a header, it needs to be marked inline
to prevent compiler warnings stating that "thread_safe_strtok is unused".

loader: fix 32-bit jwasm compilation

jwasm, and by extension uasm, requires setting a cpu model to at least
386 in order to set the model to flat.

References:
https://github.com/JWasm/JWasm/blob/7218960b65d69216693a655d928eb4c2fb6b505c/cpumodel.c#L330-L332
https://github.com/Terraspace/UASM/blob/bffb18461dd541479064990c3b2750ab50ae23e2/cpumodel.c#L326-L328

Signed-off-by: Christopher Degawa <ccom@randomderp.com>

Use CMAKE_MSVC_RUNTIME_LIBRARY to set desired C runtime for windows

CMake 3.15 added the capability to directly set the desired C runtime
used. The loader itself should use -MT, or multithreaded static, so
that it statically links in the C runtime into itself. The tests use -MD,
or multithreaded dynamic because they share allocations between the various
dll's and .exe boundaries.

The TESTS_STANDARD_CXX_PROPERTIES makes setting the MSVC_RUNTIME_LIBRARY
easier across the many various components that need it set.

Simply usage of LOADER_STANDARD_C_PROPERTIES in cmake

LOADER_STANDARD_C_PROPERTIES and LOADER_STANDARD_CXX_PROPERTIES included
PROPERTIES, which made it difficult to compose with other properties.
Removing PROPERTIES and adding it to every use of LOADER_STANDARD_C_PROPERTIES
makes the cmake code easier to understand.

Fix EnvVarWrapper overwriting values

When EnvVarWrapper gets created, it clobbers the existing value of the
environment variable if it exists. When running multiple tests in a row
inside of a single process, the values set by the loader_testing_main.cpp
should be what every test is initialized with. To make that happen,
EnvVarWrapper now will save the existing value if it exists, then re-apply
it during its destructor.

Add tests for longer version strings

Include tests which exercise parsing logic for versions longer than
a single character.

Replace strok with threadsafe versions

strtok is not threadsafe, which was previously not a problem thanks to the
'read json' mutex. But since that was removed, it left strtok potentially
corrupting data as multiple threads try to use it. The fix is to replace
strtok with platform specific threadsafe versions, namely strtok_s for
windows platforms and strtok_r for unix platforms.

Better handle missing settings file

build: Update to header 1.3.253

- Update known-good
- Generate source

Fix USE_MASM=OFF in github actions

The windows_vs-no-asm was incorrectly setup, causing the assembler to
be found when it should have used the fallback path.

Change settings file location

Move the settings registry to "LoaderSettings" and the unix location
to "loader_settings.d".

The  validation layers looks for the settings file on windows in
"SOFTWARE/Khronos/Vulkan/Settings" but doesn't check the file name.
To maintain compatibility, the loader's settings file needs to be
in a different location.

Disable MinGW Github Actions run

MinGW uses JWASM to compile the assembly code. This commit disables that run
for the time being because github actions currently doesn't have JWASM setup.
While work could be done to get it working, it is low priority.

Silence MINGW error about casting functions

When compiling with MinGW, GCC emits a warning:
"error: cast between incompatible function types from 'FARPROC' to ..."

GCC doesn't like the cast after calls to GetProcAddress, so
casting to void* first fixes the warning.

Fix fallback unknown function build logic

The build logic for enabling the unknown function support when ASM code doesn't
work or is disabled was broken. This fixes it by consolidating the various code
paths as well as making sure it is enabled when it should be.

This also fixes the fallback path for macOS by making sure to only modify the
names of functions if and only if the corresponding assembly code is active.

Add CI runs for unknown function fallbacks

There is C code that is used when the ASM support for unknown function fails to build
or the ASM build is explicitly disabled. This previously had no tests for these code
paths. Now there is a Github actions run for each platform, such as linux, windows,
macOS, as well as 32 bit linux and mingw.

ci: Add MinGW build

Remove inclusion of winsock2.h

The header is unused and causes compilation issues due to the header needing
to be included before windows.h

loader: Add void to function arguments

UBSan was detecting a function type mismatch for these module
ctor/dtors since libc expects the function type to be void (*)(void)
rather than just void (*)().

Make assembly work on macOS

The assembly for unknown function support did not need too many changes to
make it compile, link, and pass all tests on macOS.

The main change is working around the ABI of macOS, namely that C symbols have
an underscore prepended. To workaround this, the __asm("name") syntax was
used to make sure the symbols weren't modified. All of the declarations in
dev_ext_trampoline.c and phys_dev_ext.c need the
change, but so does loader_log because it gets called by the asm code.

Additionally, the .hidden attribute is only present for the ELF output. So
that has to be removed during compilation on macOS.

Remove loader.aps

The aps file is a Visual Studio binary file that is a compiled version of
loader.rc used by resource editors. The documentation calls out that this
file should not be checked into source control, so it can be safely removed.

Add clang-cl run to github actions CI

Chromium builds use clang-cl so best to make sure we don't break them.

Remove unused variable for clang-cl on windows

read_data_files_in_search_paths' `relative_path` is only used on unix
platforms but is defined for all platforms. This causes clang-cl to
warn about it, and causes the build to fail when ENABLE_WERROR is on.

The fix is to *not* define the offending variable on windows. Makes the
code more annoying to read due to the excessive #if #else macros, but
that is the simplest change.

build: Update to header 1.3.251

- Update known-good
- Generate source

Remove foward declaration of VkResult and VkFlags

While it is nice to forward declare the 1 type needed, it is better to include
vulkan.h since the enum forward declaration is a microsoft specific extension.

Fix issues found with clang-tidy

clang-tidy found numerous issues, roughly divided into three categories:
* Unused variables
* strcpy is unsafe
* NULL dereference due to missing NULL check

Use strncpy in loader_add_environment_layers

Propagate OOM in more places

Add NULL checks to cJSON helper functions

Separate meta layer verification & update logic

verify_meta_layer_component_layers previously would update the extension lists
of valid meta layers, which possibly allocates memory. The function had no
way to report OOM so instead, the updating of extension lists was added to a
separate function that gets called for successfully verified meta layers. Now
that the updating is moved out, the function can be simplified to return
false if any check fails.

This commit also cleans up verify_all_meta_layers such that the OOM is
propagated upwards if necessary, including modifying any callers of that
function.

Add loader settings file

The loader settings file is a json file that enables external tools, such as
VkConfig to precisely enable and order the layers. This mirrors the
functionality of the override meta layer but by not being a layer, is able to
be much more cleanly implemented.

The primary capability of the settings file is to be able to dictate the
order of all layers regardless of their type. If the loader detects a settings
file, it will use the order provided in it. It has similar functionality for
applying a setting per-application as well as globally. A new feature is the
ability to dictate the 'global' logging behavior, eg overriding the
VK_LOADER_DEBUG environment variable.

Settings are per-instance, so if an application destroys its instance and
creates a new one, it will get the most up to date settings file. There is
a 'global' settings file used for pre-instance functions, and is updated on
every call that makes use of the settings (aka all global functions except for
vkGetInstanceProcAddr).

Most of the new code lives in settings.h and settings.c but changes were made
to loader_scan_for_layers, loader_scan_for_implicit_layers,
loader_enable_instance_layers, and loader_validate_instance_extensions.

Modify test framework surface creation helpers

The surface creation helper functions were overloaded with a function that
only needs the VulkanFunctions* and VkInstance paramters, which allows them
to be used in the Out Of Memory allocation callback tests. To facilitate this
change, the return value of create_surface was changed to a straight VkResult,
requiring calling code to check that the result value is what they expect.

Add header files to source file list in CMake

Gives a better experience for Visual Studio and XCode developers.

Use braces consistently in new helper functions

Remove guard for C++ in cJSON.h

The cJSON.h library is only used by C code, so the macro guard for C++ is not
needed.

Fix cJSON_print using wrong allocation scope

Because cJSON_print uses cJSON_malloc, it meant that all calls to cJSON_print
used the command allocation scope. With the change to directly store the strings
returned by cJSON, this meant that various strings were being stored in the
instance that were not allocated with the instance scope. This fixes that.

This commit also adds a safeguard to ensure the cJSON object is cleaned up if
loader_get_json fails

Refactor to not use fixed length strings

Many places in the loader stored paths in fixed length strings. This has
two major downsides, firstly that the loader could not support paths greater
than 1024 characters, and secondly that it greatly increased the memory
overhead needed for an instance. The memory pressure was something in the
order of 100kb+, most of which was completely empty strings.

To facilitate this change, the loader_layer_list type was added along with
several utility functions to create string lists, destroy string lists,
add elements to a string list, etc. The liberal use of the new type allows
for a lot of duplicate code to be deleted - as much of the layer parsing
logic was just to manage the various arrays of strings.

The loader_layer_properties struct now contains many char*'s and
loader_string_lists, and owns any of the strings inside of it. Compared to
before the commit, the loader_layer_properties struct is a mere 700 bytes
large versus the 11kb it was before.

loader_data_files is just a list of strings, so was replaced with the new
loader_string_list type, along with removal of any custom functions that
created/destroyed it.

One downside of the change is that various places in the loader used the
fact that a string was never NULL to not need to do a nullptr check. Because
many strings were just char arrays with a value of 0 throughout, the logic
was not needed. Switching to char*'s required adding NULL checks in various
places, such as loader_getenv and loader_secure_getenv.

The combine_manifest_directory_and_library_path function is the most
complex change in the entire commit. It implements behavior that was
duplicated between two separate places (layer and driver loading). The previous
logic also used dirname(), which required creating a new string to use. The
new function implements the behavior of dirname without the extra string.
It also will reuse a passed in string if appropriate - removing another
potential string copy.

loader_read_layer_json was refactored to be much easier to follow as well as
using the various json parsing utility functions that make it easy to get
strings, lists of strings, etc. The refactor changed the logic to only add
the loader_layer_properties structure to the list if it is successfully parsed,
rather than having to remove the properties if it fails in any way. Also the
macros were removed since they decreased readibility for marginal deduplication.
Before this commit, cJSON_Print was called many times in loader_read_layer_json,
which returns a newly allocated string, only for the data to be copied out of
it into a char array, then immediately freeing the allocated string. Now, those
allocations are put into the properties struct, saving a stack alloc & memcpy
per string.

Turn layer lists into lists of pointers

The expanded_activated_layer_list and app_activated_layer_list now are lists of
pointers to the instance_layer_list of actual layers. This change was done to
remove the very large copies done to store the various layer lists.

This commit introduces a new type, loader_pointer_layer_list, which is a simple
list like structure for holding the pointers to the loader_layer_properties.

This commit moves the responsibility of unloading layers from
expanded_activated_layer_list to the instance_layer_list, meaning that closing of
libraries is now done during the calls to loader_delete_layer_list_and_properties.
loader_delete_layer_list_and_properties is also now called after the return from
vkDestroyInstance, since layer libraries need to stay alive until after they get a
chance to clean themselves up.

loader_add_layer_properties_to_list was modified to only ever add one layer at a
time, since all uses of it did this and it makes the definition easier to follow.

Meta layers now dont add layers more than once

The check to make sure a layer isn't being added more than once was not present
for component layers of meta layers. Now, component layers from meta layers are
only added if they haven't been added before.

Remove layer list copies from loader_device

The layer lists do not need to be separate from the instance - as layers that
are active on a device must also be active on the instance. This saves unecessary
storage and allocations.

The concern of being able to create devices in multiple threads is alleviated
because device creation is a read-only process, so there is no contention. As
well as the instance must be valid (not destroyed) so that means the layer data
must also be available.

Remove DEFAULT_VK_DRIVERS_PATH macro define

DEFAULT_VK_DRIVERS_PATH was undocumented and a compile time build - so anyone
using it would need to rebuild. VK_DRIVER_FILES and VK_ICD_FILENAMES are
environment variables which serve the same purpose without the need to recompile.

Add tests for system installed binaries

When library_path in a manifest doesn't contain any directory separators, it
signals to the loader that the library name should be passed directly to
dlopen/LoadLibrary and for those functions to use the dynamic linkers default
search paths. This commit adds tests that do that, as well as sets up the
required functionality to implement this behavior in the test framework. For
Unix systems, this involves redirecting dlopen so that it loads the correct
binary - rather than relying on dlopen to find it for us. For Windows, we
use AddDllDirectory to modify LoadLibrary's search path as well as
SetDefaultDllDirectory to change LoadLibrary's behavior to do what we want.

Fix tests dying if an exception is thrown.

The test framework will generate an exception if any googletest assertion fails.
However, if there already is an ongoing exception, we do not want to throw
another one. Thus, we check if std::current_exception() is nullptr, and only
throw our own exception if it is nullptr.

Significantly reduce duplicate layer scanning code

The layer scan functions had a pattern of calling loader_get_data_files,
parse the json found, and put the resulting parsed loader_layer_properties
into the output instance_layers list. This pattern was done twice in each
layer scan function, so in total 4 times. Thus, it was ripe for pulling the
common code into a new function, loader_parse_instance_layers().

The one bit of logic not shared between the two paths is whether or not the
layers being scanned are implicit or explicit. This is made easy by the fact
that the manifest_type dictates whether to parse the scanned manifests as
implicit or explicit layers.

Also, the code to get the override path was identical - but was copy pasted.
Moving it into a separate function cleans up the functions quite
siginificantly.

Remove redundant clear when scanning for layers

All callers of loader_scan_for_implicit_layers and loader_scan_for_layers
clear out instance_layers before calling, making the call to
loader_delete_layer_list_and_properties redundant.

Also reordered the local variable declaration order to match.

Remove useless lock & comment out cJSON error handling

Because the error handling mechanism used a static variable, that meant that to
use cJSON_GetErrorPtr required a lock. This error function was never used, meaning
the lock that was there wasn't guarding any resource. cJSON doesn't have any non
const static variables.

This commit removes the lock and any associated code, which was improperly handled
in loader_scan_for_layers anyhow (potentially unlocking an already unlocked mutex).

Remove useless if check in loader_scan_for_layers

The for loop will automatically skip the logic if manifest_files.count is zero.

Remove redundant variable in loader_scan_for_layers

total_count would only ever be non-zero if manifest_files.count is non zero, thus
it doesn't ever impact the control flow used.

Pass inst rather than NULL during layer scanning

This commit fixes a bug in loader_scan_for_layers where the getting of filter
environment variables used NULL rather than the already available inst handle.

Move library list allocation to out of layer search function

The allocation of the library list shouldn't be happening in the call to
loader_scan_for_implicit_layers.

Fix log.h to use #pragma once

Also only include whats absolutely necessary and forward declare the rest.

Include Hive in windows registry logs

Which hive is being queried is useful information to have, this commit adds the
HKEY_CURRENT_USER and HKEY_LOCAL_MACHINE hive strings to the appropriate log
messages.

Make Allocation tests less noisy

The allocation tests will flood the output, change the debug log to only
issue error and warning level messages.

Add test utilities for getting instance layers and extensions

Since it is incredibly common for tests to query the instance layers and
extensions, add helper functions to ease the enumeration of them and place the
results into an output vector, as well as check that the expected count is
equalt to the real count.

The GetActiveLayers function which did not take an expected count was removed
as tests should always know the exact number of layers that are present.

ASSERT_NO_FATAL_FAILURE was added to anyplace that queried extensions or layers
but requested a count of 0. This was done to insure that future maintainers do
not remove the seemingly redudant query of 0, as it is very much a part of the
test code since there are EXPECT macros inside the respective enumeration
utility functions.

Add unsecured manifest location to tests

Meta layer should not be loaded if it originated from an unsecured location.
This commit contains the necessary changes needed to test layers & drivers that
live in the user local directory on linux and HKEY_CURRENT_USER on windows.

Cleanup JSON output in tests with utility

Got tired of writing manual json output code, and moved the necessary
formatting logic into an easy to use utility. Makes the code MUCH cleaner and
easier to follow. Plus, it is now trivial to create JSON files so it will be
much easier to test the loader's parsing code.

Add GetActiveLayers function helper in tests

GetActiveLayers call vkEnumerateDeviceLayerProperties - which the loader treats
as the list of active layers. This helper function cleans up a lot of tests by
moving the exact same logic repeated many dozens of times into a single
location.

This commit also moves the EnumerateDeviceExtensions into the InstWrapper as a
helper, and updated its interface to require the requested extension count.

Make EnvVarWrapper remove env-vars initially

When an EnvVarWrapper object is created, it will now remove the env-var instead
of leaving the value unset (in the case of no initial value being given). This
is preferrable because it prevents external state from creeping in accidentally
if the test forgot to provide a value.

Add helper parsing functions to cJSON

Since parsing an array of strings and strings from json files is very common,
this commit adds helper functions to do exactly that.

Refactor loader_log for clarity and performance

Use strncat more efficiently by always starting at the place where the last
character was written. Also does not strncat the message and instead writes
that directly to the output stream. This allows shortening the character
buffer since the max possible length for the prefix is the only thing
written.

Rename log level to reflect its global status

The log level is set only during dynamic initializatoin, rather than during any
specific vulkan call. This commit renames the log to reflect this global
nature of the debug level.

Make cJSON not add double quotes to strings

In JSON, strings are surrounded with double quotes. Because the loader is
only using cJSON_Print to 'get' the underlying string, we have to strip away
the quotes. To do that, we have to create a new string and copy it over. That
is unnecessary if cJSON didn't add the quotes in the first place. This commit
does just that, but leaves the original code commented out in case it needs
to be reverted.

Note that in many places the loader still does a strcpy to place the string
into a char array, but this commit seeks to do the minimal set of changes to
accomplish the stated goal. Removing the rest of the strcpy's would require
more invasive work to make sure all the char*'s are deleted when they should
be.

Move loader_get_json to cJSON

Since opening a json file and reading it into a cJSON structure is done in
every source file that wishes to read json files, it is helpful to pull the
loader_get_json function into the source file.

Add FrameworkSettings to more easily configure the framework

Introduce the FrameworkSettings struct to allow tests to easy and clearly
configure the basic settings of the FrameworkEnvironment. The previous
method just used overloaded constructors which is difficult to read compared
to an explicit structure that contains all the settings.

Create Dummy function just for windows_initialization

The function call to get the current dll on windows requires the address of a
function inside the dll. Rather than use loader_debug_init, create a dedicated
function for this purpose.

ci: Test pkg-config and installation

closes #1204

cmake: Don't install GTEST along with vulkan loader

cmake: Add LOADER_CODEGEN

docs: Document LOADER_CODEGEN

LOADER_USE_UNSAFE_FILE_SEARCH

Make LOADER_USE_UNSAFE_FILE_SEARCH a CMake option.

Allows validation layers to disable safe search to work around
permissions issues on Github Actions.

Add a test for loader_gpa_instance_terminator

When loader_gpa_instance_terminator is called during vkCreateDevice, it should
use the terminator functions for the instance, which gets stored in struct
loader_instance's terminator_dispatch. This test is accomplished by querying
vkEnumerateDeviceExtensionProperties using the vkGetInstanceProcAddr provided
by chainInfo->u.pLayerInfo->pfnNextGetInstanceProcAddr and comparing the
function pointer with the one queried during vkCreateInstance.

Make ChainInfo nextGIPA work in vkCreateDevice

Layers are given chainInfo during instance and device creation. This contains
vkGetInstanceProcAddr (GIPA) that corresponds to the next layer in the chain,
and if there is none, the loader's GIPA terminator. During vkCreateInstance
the instance dispatch table contains the terminators for instance functions.
After vkCreateInstance returns up the call chain, these terminators get
overwritten by calling GIPA on the first layer in the chain.

The problem is that after vkCreateInstance, the instance dispatch table
is being used by loader_gpa_instance_terminator, resulting in the wrong
function being returned to a layer who calls it.

This problem typically only shows up during vkCreateDevice, because the
chainInfo is given to each layer and that chainInfo contains a "nextGIPA".
Except, only the last layer gets a pointer to loader_gpa_instance_terminator,
as every other layer gets the GIPA of the next layer in the chain. Still,
this last layer should not be getting a pointer to the first function in
the chain.

The solution is to stash the terminator dispatch table after returning up
the vkCreateInstance chain but before overwriting the dispatch table with
the first layer in each function chain. Then, inside of
loader_gpa_instance_terminator check if we are still inside of
vkCreateInstance or not.

Modify test layer binary names correctly

When creating test layer binaries, the test framework appends a unique
identifier, specifically `_X` where X is a unique number.
Previously, this was appended at the very end, like so:
`libtest_layer.so_0`
Now, the `_X` is added before the file extension, like so:
`libtest_layer_0.so`

Make loader_get_icd_and_device check for a NULL device

When loader_get_icd_and_device() is called with a NULL device handle, this
results in comparisons with NULL. If loader_get_dispatch(dev-icd_device) also
returns NULL (due to it being the wrong icd) then loader_get_icd_and_device
will compare NULL to NULL, get true, and return the wrong icd.

Simply checking if loader_get_dispatch(device) is NULL then returning NULL
immediately prevents this situation.

Fix crash from layers creating devices on different physical devices

The magic value for the device dispatch table was being set after calling down
the layer chain rather than before. This is wrong because of the situation when
layers create devices from different physical devices, the magic value using
the default value of zero means that loader_get_icd_and_device will return the
wrong loader_icd_term, leading to crashes elsewhere.

The fix is to set the magic value right after the dispatch table is allocated.

This commit adds tests for both drivers being created from the same physical
device and from different physical devices.

Don't export Vulkan functions when building the loader statically

If the loader is linked statically, there is no need to export all
vulkan functions from the linking application. This issue showed up
in ANGLE which would export all GLES and Vulkan functions on Mac.

Added libgcc-s1:i386 to linux-32 Github actions

Also split out the setup commands into separate run statements rather than
have them string together.

cmake: Fix LOADER_DISABLE_DYNAMIC_LIBRARY_UNLOADING

ci: Test LOADER_DISABLE_DYNAMIC_LIBRARY_UNLOADING

Fix LOADER_DISABLE_DYNAMIC_LIBRARY_UNLOADING WIN32 support