From 1b7646ced0f0b969f818084887885827ed1a4244 Mon Sep 17 00:00:00 2001
From: Khem Raj <raj.khem@gmail.com>
Date: Mon, 31 May 2021 17:31:33 -0700
Subject: [PATCH] vulkancts: Include missing <cstdint>

Fixes build with gcc-13

../git/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmFloatControlsTests.cpp:2798:102: error: 'uintptr_t' in namespace 'std' does not name a type
 2798 |                 BufferDataType type              = static_cast<BufferDataType>(reinterpret_cast<std::uintptr_t>(expectedOutputs[resultIndex].getUserData()));
      |                                                                                                      ^~~~~~~~~

Upstream-Status: Submitted [https://github.com/KhronosGroup/VK-GL-CTS/pull/378]
Signed-off-by: Khem Raj <raj.khem@gmail.com>
---
 .../vulkan/spirv_assembly/vktSpvAsmFloatControlsTests.cpp        | 1 +
 1 file changed, 1 insertion(+)

diff --git a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmFloatControlsTests.cpp b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmFloatControlsTests.cpp
index ab02be1dc..3d3ee4829 100644
--- a/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmFloatControlsTests.cpp
+++ b/external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmFloatControlsTests.cpp
@@ -33,6 +33,7 @@
 #include "deFloat16.h"
 #include "vkQueryUtil.hpp"
 #include "vkRefUtil.hpp"
+#include <cstdint>
 #include <cstring>
 #include <vector>
 #include <limits>
-- 
2.39.1

