tests: Compare proc-addr behavior, not identity, on arm64ec

On arm64ec, GetProcAddress for an exported function returns the export's
Fast-Forward Sequence (x64-shaped) address, while the loader resolves its own
name to the native arm64ec function body. These are distinct addresses but valid
entry points for the same command, and the Vulkan spec does not require pointer
identity between a platform export and a vkGet*ProcAddr result.

GetProcAddr.VerifyGetInstanceProcAddr, VerifyGetDeviceProcAddr and
GlobalFunctions asserted raw pointer equality, which fails on arm64ec. Under
_M_ARM64EC, compare behavior instead - both pointers non-NULL, an unknown command
resolves to NULL, and a known command resolves to the same pointer - and keep
strict pointer equality on every other architecture.

Author: BoiledElectricity

tests/loader_get_proc_addr_tests.cpp

@@ -27,6 +27,42 @@
 
 #include "test_environment.h"
 
+// On arm64ec GetProcAddress hands back an export's x64 fast-forward-sequence address while the loader
+// resolves its own name to the native arm64ec function. Same command, different addresses, and the
+// spec doesn't require them to match, so compare behavior on arm64ec instead of raw pointer identity.
+static void assert_gipa_equivalent(PFN_vkGetInstanceProcAddr from_loader, PFN_vkGetInstanceProcAddr from_query) {
+#if defined(_M_ARM64EC)
+    ASSERT_NE(from_loader, nullptr);
+    ASSERT_NE(from_query, nullptr);
+    ASSERT_EQ(from_loader(nullptr, "vkThisCommandDoesNotExist"), nullptr);
+    ASSERT_EQ(from_query(nullptr, "vkThisCommandDoesNotExist"), nullptr);
+    PFN_vkVoidFunction create_from_loader = from_loader(nullptr, "vkCreateInstance");
+    PFN_vkVoidFunction create_from_query = from_query(nullptr, "vkCreateInstance");
+    ASSERT_NE(create_from_loader, nullptr);
+    ASSERT_EQ(create_from_loader, create_from_query);
+#else
+    ASSERT_EQ(from_loader, from_query);
+#endif
+}
+
+static void assert_gdpa_equivalent(PFN_vkGetDeviceProcAddr from_loader, PFN_vkGetDeviceProcAddr from_query, VkDevice device) {
+#if defined(_M_ARM64EC)
+    ASSERT_NE(from_loader, nullptr);
+    ASSERT_NE(from_query, nullptr);
+    if (device != VK_NULL_HANDLE) {
+        ASSERT_EQ(from_loader(device, "vkThisCommandDoesNotExist"), nullptr);
+        ASSERT_EQ(from_query(device, "vkThisCommandDoesNotExist"), nullptr);
+        PFN_vkVoidFunction destroy_from_loader = from_loader(device, "vkDestroyDevice");
+        PFN_vkVoidFunction destroy_from_query = from_query(device, "vkDestroyDevice");
+        ASSERT_NE(destroy_from_loader, nullptr);
+        ASSERT_EQ(destroy_from_loader, destroy_from_query);
+    }
+#else
+    (void)device;
+    ASSERT_EQ(from_loader, from_query);
+#endif
+}
+
 // Verify that the various ways to get vkGetInstanceProcAddr return the same value
 TEST(GetProcAddr, VerifyGetInstanceProcAddr) {
     FrameworkEnvironment env{};
@@ -41,7 +77,7 @@ TEST(GetProcAddr, VerifyGetInstanceProcAddr) {
         PFN_vkGetInstanceProcAddr gipa_loader = env.vulkan_functions.vkGetInstanceProcAddr;
         PFN_vkGetInstanceProcAddr gipa_queried = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
             env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetInstanceProcAddr"));
-        ASSERT_EQ(gipa_loader, gipa_queried);
+        assert_gipa_equivalent(gipa_loader, gipa_queried);
     }
 
     {
@@ -54,7 +90,7 @@ TEST(GetProcAddr, VerifyGetInstanceProcAddr) {
         PFN_vkGetInstanceProcAddr gipa_loader = env.vulkan_functions.vkGetInstanceProcAddr;
         PFN_vkGetInstanceProcAddr gipa_queried = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
             env.vulkan_functions.vkGetInstanceProcAddr(inst.inst, "vkGetInstanceProcAddr"));
-        ASSERT_EQ(gipa_loader, gipa_queried);
+        assert_gipa_equivalent(gipa_loader, gipa_queried);
     }
 }
 
@@ -72,13 +108,13 @@ TEST(GetProcAddr, VerifyGetDeviceProcAddr) {
     //       that to what is returned by asking it what the various Vulkan get proc addr functions are.
     PFN_vkGetDeviceProcAddr gdpa_loader = env.vulkan_functions.vkGetDeviceProcAddr;
     PFN_vkGetDeviceProcAddr gdpa_inst_queried = inst.load("vkGetDeviceProcAddr");
-    ASSERT_EQ(gdpa_loader, gdpa_inst_queried);
+    assert_gdpa_equivalent(gdpa_loader, gdpa_inst_queried, VK_NULL_HANDLE);
 
     DeviceWrapper dev{inst};
     dev.CheckCreate(phys_dev);
 
     PFN_vkGetDeviceProcAddr gdpa_dev_queried = dev.load("vkGetDeviceProcAddr");
-    ASSERT_EQ(gdpa_loader, gdpa_dev_queried);
+    assert_gdpa_equivalent(gdpa_loader, gdpa_dev_queried, dev);
 }
 
 // Load the global function pointers with and without a NULL vkInstance handle.
@@ -164,7 +200,7 @@ TEST(GetProcAddr, GlobalFunctions) {
         handle_assert_null(CreateInstance);
 
         PFN_vkGetInstanceProcAddr GetInstanceProcAddr = inst.load("vkGetInstanceProcAddr");
-        handle_assert_equal(env.vulkan_functions.vkGetInstanceProcAddr, GetInstanceProcAddr);
+        assert_gipa_equivalent(env.vulkan_functions.vkGetInstanceProcAddr, GetInstanceProcAddr);
         ASSERT_EQ(GetInstanceProcAddr,
                   reinterpret_cast<PFN_vkGetInstanceProcAddr>(GetInstanceProcAddr(inst, "vkGetInstanceProcAddr")));
         ASSERT_EQ(GetInstanceProcAddr,